VariantDB.h

#pragma once
#include <cstdint>
#include "maya/MDagPath.h"
#include "AL/usdmaya/fileio/translators/TranslatorBase.h"
#include "AL/usdmaya/fileio/translators/TranslatorContext.h"

#include "pxr/usd/sdf/path.h"
#include "pxr/usd/usd/stage.h"

namespace AL {
namespace usdmaya {
namespace nodes {

//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class SchemaNodeRef
{
public:

  SchemaNodeRef(const SdfPath& path, MObject mayaObj)
    : m_primPath(path), m_mayaObj(mayaObj) {}

  ~SchemaNodeRef() {}

  const SdfPath& primPath() const
    { return m_primPath; }

  MObject mayaObject() const
    { return m_mayaObj.object(); }

private:
  SdfPath m_primPath;
  MObjectHandle m_mayaObj;
};


//----------------------------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------------------------
class SchemaNodeRefDB
{
public:

  struct value_compare
  {
    inline bool operator() (const SchemaNodeRef& a, const SdfPath& b) const
      { return a.primPath() < b; }

    inline bool operator() (const SdfPath& a, const SchemaNodeRef& b) const
      { return a < b.primPath(); }

    inline bool operator() (const SchemaNodeRef& a, const SchemaNodeRef& b) const
      { return a.primPath() < b.primPath(); }
  };

  SchemaNodeRefDB(nodes::ProxyShape* const proxy);

  ~SchemaNodeRefDB();

  void lock()
    {}

  bool hasEntry(const SdfPath& path, const TfToken& type)
  {
    auto it = std::lower_bound(m_nodeRefs.begin(), m_nodeRefs.end(), path, value_compare());
    if(it != m_nodeRefs.end() && (it->primPath() == path))
    {
      return type == context()->getTypeForPath(path);
    }
    return false;
  }

  void addEntry(const SdfPath& primPath, const MObject& primObj);

  void unlock()
    { std::sort(m_nodeRefs.begin(), m_nodeRefs.end(), value_compare()); }

  void preRemoveEntry(const SdfPath& primPath, SdfPathVector& itemsToRemove);

  void removeEntries(const SdfPathVector& itemsToRemove);

  void outputPrims(std::ostream& os);

  fileio::translators::TranslatorContextPtr context();

  inline fileio::translators::TranslatorManufacture& translatorManufacture()
    { return m_translatorManufacture; }

  inline nodes::ProxyShape* proxy() const
    { return m_proxy; }

private:
  void unloadPrim(
      const SdfPath& primPath,
      const MObject& primObj);
  void preUnloadPrim(
      UsdPrim& primPath,
      const MObject& primObj);

  typedef std::vector<SchemaNodeRef> SchemaNodeRefs;
  SchemaNodeRefs m_nodeRefs;
  nodes::ProxyShape* const m_proxy;
  fileio::translators::TranslatorContextPtr m_context;
  fileio::translators::TranslatorManufacture m_translatorManufacture;
};

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