LayerManager.h

//
// Copyright 2017 Animal Logic
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.//
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
#pragma once

#include "../Api.h"

#include "AL/maya/utils/NodeHelper.h"
#include "pxr/pxr.h"
#include "pxr/usd/usd/stage.h"

#include "maya/MPxLocatorNode.h"
#include "maya/MNodeMessage.h"
#include "AL/maya/utils/MayaHelperMacros.h"

#include <iterator>
#include <map>
#include <set>
#include <boost/thread.hpp>

PXR_NAMESPACE_USING_DIRECTIVE

namespace AL {
namespace usdmaya {
namespace nodes {

class ProxyShape;

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
template <typename WrappedIterator>
class DirtyOnlyIterator
//    : public std::iterator<std::forward_iterator_tag,
//                           typename WrappedIterator::value_type>
{
public:
  typedef typename WrappedIterator::value_type value_type;

  DirtyOnlyIterator(WrappedIterator it, WrappedIterator end):
    m_iter(it),
    m_end(end)
  {
    SetToNextDirty();
  }

  DirtyOnlyIterator(const DirtyOnlyIterator& other):
    m_iter(other.m_iter),
    m_end(other.m_end)
  {
    SetToNextDirty();
  }

  DirtyOnlyIterator& operator++()
  {
    ++m_iter;
    SetToNextDirty();
    return *this;
  }

  DirtyOnlyIterator operator++(int)
  {
    WrappedIterator tmp(*this);
    operator++();
    return tmp;
  }

  bool operator == (const DirtyOnlyIterator& rhs) const
  {
    // You could argue we should check m_end too,
    // but all we really care about is whether we're pointed
    // at the same place, and it's faster...
    return m_iter == rhs.m_iter;
  }

  bool operator != (const DirtyOnlyIterator& rhs) const
  {
    return m_iter != rhs.m_iter;
  }

  value_type& operator * ()
    { return *m_iter; }

private:
  void SetToNextDirty()
  {
    while (m_iter != m_end && !m_iter->first->IsDirty())
    {
      ++m_iter;
    }
  }

  WrappedIterator m_iter;
  WrappedIterator m_end;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class LayerDatabase
{
public:
  typedef std::map<SdfLayerRefPtr, std::vector<std::string>> LayerToIdsMap;
  typedef std::map<std::string, SdfLayerRefPtr> IdToLayerMap;

  bool addLayer(SdfLayerRefPtr layer, const std::string& identifier = std::string());

  bool removeLayer(SdfLayerRefPtr layer);

  SdfLayerHandle findLayer(std::string identifier) const;

private:
  typedef const LayerToIdsMap LayerDatabase::*_UnspecifiedBoolType;
public:
  operator _UnspecifiedBoolType() const
    { return begin() == end() ? &LayerDatabase::m_layerToIds : nullptr; }

  size_t max_size() const
    { return m_layerToIds.size(); }

  // Iterator interface - skips past non-dirty items
  typedef DirtyOnlyIterator<LayerToIdsMap::iterator> iterator;
  typedef DirtyOnlyIterator<LayerToIdsMap::const_iterator> const_iterator;

  iterator begin()
    { return iterator(m_layerToIds.begin(), m_layerToIds.end()); }

  const_iterator begin() const
    { return const_iterator(m_layerToIds.cbegin(), m_layerToIds.cend()); }

  const_iterator cbegin() const
    { return const_iterator(m_layerToIds.cbegin(), m_layerToIds.cend()); }

  iterator end()
    { return iterator(m_layerToIds.end(), m_layerToIds.end()); }

  const_iterator end() const
    { return const_iterator(m_layerToIds.cend(), m_layerToIds.cend()); }

  const_iterator cend() const
    { return const_iterator(m_layerToIds.cend(), m_layerToIds.cend()); }

private:
  void _addLayer(SdfLayerRefPtr layer, const std::string& identifier,
      std::vector<std::string>& idsForLayer);

  LayerToIdsMap m_layerToIds;
  IdToLayerMap m_idToLayer;
};

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class LayerManager
  : public MPxNode,
    public AL::maya::utils::NodeHelper
{
public:

  inline LayerManager()
    : MPxNode(), NodeHelper() {}

  ~LayerManager();

  AL_USDMAYA_PUBLIC
  static MObject findNode();

  AL_USDMAYA_PUBLIC
  static MObject findOrCreateNode(MDGModifier* dgmod = nullptr, bool* wasCreated = nullptr);

  AL_USDMAYA_PUBLIC
  static LayerManager* findManager();

  AL_USDMAYA_PUBLIC
  static LayerManager* findOrCreateManager(MDGModifier* dgmod = nullptr, bool* wasCreated = nullptr);

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  AL_USDMAYA_PUBLIC
  bool addLayer(SdfLayerHandle layer, const std::string& identifier = std::string());

  AL_USDMAYA_PUBLIC
  bool removeLayer(SdfLayerHandle layer);

  AL_USDMAYA_PUBLIC
  SdfLayerHandle findLayer(std::string identifier);

  AL_USDMAYA_PUBLIC
  void getLayerIdentifiers(MStringArray& outputNames);

  AL_USDMAYA_PUBLIC
  MStatus populateSerialisationAttributes();

  AL_USDMAYA_PUBLIC
  MStatus clearSerialisationAttributes();

  AL_USDMAYA_PUBLIC
  void loadAllLayers();

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------
  AL_MAYA_DECLARE_NODE();

  AL_USDMAYA_PUBLIC
  static void* conditionalCreator();

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------

  // attributes to store the serialised layers (used for file IO only)

  // Note that the layers attribute should ONLY used during serialization, as this is the ONLY
  // times at which these attributes are guaranteed to "line up" to the internal layer register
  // (m_layerList).  Ie, immediately before save (due to the pre-save callback), the attributes will
  // be written from m_layerList; and immediate after open (due to the post-open callback), m_layerList
  // will be initialized from the attributes.  At all other times, the attributes will be OUT OF SYNC
  // (and, in fact, are intentionally set to be "empty", so there's no confusion / someone doesn't
  // try to use "out of date" information)
  AL_DECL_ATTRIBUTE(layers);
  // Not using AL_DECL_ATTRIBUTE for these, because we never want a generic, ie, identifierPlug() -
  // they only make sense for a particular index of the parent array-attribute... and it taking up
  // the "identifierPlug" name is confusing
  AL_DECL_MULTI_CHILD_ATTRIBUTE(identifier);
  AL_DECL_MULTI_CHILD_ATTRIBUTE(serialized);
  AL_DECL_MULTI_CHILD_ATTRIBUTE(anonymous);

private:
  static MObject _findNode();

  LayerDatabase m_layerDatabase;

  // Note on layerManager / multithreading:
  // I don't know that layerManager will be used in a multihreaded manenr... but I also don't know it COULDN'T be.
  // (I haven't really looked into the way maya's new multi-threaded node evaluation works, for instance.) This is
  // essentially a globally shared resource, so I figured better be safe...
  boost::shared_mutex m_layersMutex;

  //--------------------------------------------------------------------------------------------------------------------
  //--------------------------------------------------------------------------------------------------------------------









};

} // nodes
} // usdmaya
} // AL
//----------------------------------------------------------------------------------------------------------------------