notice.h

Go to the documentation of this file.

#ifndef USD_NOTICE_FRAMEWORK_NOTICE_H
#define USD_NOTICE_FRAMEWORK_NOTICE_H
 
 
#include "unf/api.h"
 
#include <pxr/base/arch/demangle.h>
#include <pxr/base/tf/notice.h>
#include <pxr/base/tf/refBase.h>
#include <pxr/base/tf/refPtr.h>
#include <pxr/pxr.h>
#include <pxr/usd/sdf/path.h>
#include <pxr/usd/usd/notice.h>
 
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
namespace unf {
 
using TfTokenSet =
    std::unordered_set<PXR_NS::TfToken, PXR_NS::TfToken::HashFunctor>;
 
using SdfPathSet = std::unordered_set<PXR_NS::SdfPath, PXR_NS::SdfPath::Hash>;
 
using ChangedFieldMap =
    std::unordered_map<PXR_NS::SdfPath, TfTokenSet, PXR_NS::SdfPath::Hash>;
 
namespace UnfNotice {
 
class StageNotice : public PXR_NS::TfNotice, public PXR_NS::TfRefBase {
  public:
    UNF_API virtual ~StageNotice() = default;
 
    UNF_API virtual bool IsMergeable() const { return true; }
 
    virtual void Merge(StageNotice&&)
    {
        PXR_NAMESPACE_USING_DIRECTIVE
        TF_FATAL_ERROR("Abstract class 'StageNotice' cannot be merged.");
    }
 
    virtual void PostProcess() {}
 
    UNF_API virtual std::string GetTypeId() const
    {
        PXR_NAMESPACE_USING_DIRECTIVE
        TF_FATAL_ERROR(
            "Abstract class 'StageNotice' does not have a unique identifier.");
        return "";
    }
 
    PXR_NS::TfRefPtr<StageNotice> Clone() const
    {
        return PXR_NS::TfCreateRefPtr(_Clone());
    }
 
  protected:
    UNF_API StageNotice() = default;
 
  private:
    virtual StageNotice* _Clone() const
    {
        PXR_NAMESPACE_USING_DIRECTIVE
        TF_FATAL_ERROR("Abstract class 'StageNotice' cannot be cloned.");
        return nullptr;
    }
};
 
using StageNoticeRefPtr = PXR_NS::TfRefPtr<StageNotice>;
 
using StageNoticeWeakPtr = PXR_NS::TfWeakPtr<StageNotice>;
 
template <class Self>
class StageNoticeImpl : public StageNotice {
  public:
    virtual ~StageNoticeImpl() = default;
 
    template <class... Args>
    static PXR_NS::TfRefPtr<Self> Create(Args&&... args)
    {
        return PXR_NS::TfCreateRefPtr(new Self(std::forward<Args>(args)...));
    }
 
    PXR_NS::TfRefPtr<Self> Clone() const
    {
        return PXR_NS::TfCreateRefPtr(static_cast<Self*>(_Clone()));
    }
 
    virtual void Merge(StageNotice&& notice) override
    {
        Merge(dynamic_cast<Self&&>(notice));
    }
 
    virtual void Merge(Self&&) {}
 
    virtual std::string GetTypeId() const override
    {
        return PXR_NS::ArchGetDemangled(typeid(Self).name());
    }
 
  private:
    virtual StageNotice* _Clone() const override
    {
        return new Self(static_cast<const Self&>(*this));
    }
};
 
class StageContentsChanged : public StageNoticeImpl<StageContentsChanged> {
  public:
    UNF_API virtual ~StageContentsChanged() = default;
 
  protected:
    explicit StageContentsChanged(
        const PXR_NS::UsdNotice::StageContentsChanged&)
    {
    }
 
    friend StageNoticeImpl<StageContentsChanged>;
};
 
class ObjectsChanged : public StageNoticeImpl<ObjectsChanged> {
  public:
    UNF_API virtual ~ObjectsChanged() = default;
 
    UNF_API ObjectsChanged(const ObjectsChanged&);
 
    UNF_API ObjectsChanged& operator=(const ObjectsChanged&);
 
    // Bring all Merge declarations from base class to prevent
    // overloaded-virtual warning.
    using StageNoticeImpl<ObjectsChanged>::Merge;
 
    UNF_API virtual void Merge(ObjectsChanged&&) override;
    UNF_API virtual void PostProcess() override;
 
    UNF_API bool AffectedObject(const PXR_NS::UsdObject& object) const
    {
        return ResyncedObject(object) || ChangedInfoOnly(object);
    }
 
    UNF_API bool ResyncedObject(const PXR_NS::UsdObject&) const;
 
    UNF_API bool ChangedInfoOnly(const PXR_NS::UsdObject&) const;
 
    UNF_API const PXR_NS::SdfPathVector& GetResyncedPaths() const
    {
        return _resyncChanges;
    }
 
    UNF_API const PXR_NS::SdfPathVector& GetChangedInfoOnlyPaths() const
    {
        return _infoChanges;
    }
 
    UNF_API TfTokenSet GetChangedFields(const PXR_NS::UsdObject&) const;
 
    UNF_API TfTokenSet GetChangedFields(const PXR_NS::SdfPath&) const;
 
    UNF_API bool HasChangedFields(const PXR_NS::UsdObject&) const;
 
    UNF_API bool HasChangedFields(const PXR_NS::SdfPath&) const;
 
    const ChangedFieldMap& GetChangedFieldMap() const { return _changedFields; }
 
  protected:
    explicit ObjectsChanged(const PXR_NS::UsdNotice::ObjectsChanged&);
 
    friend StageNoticeImpl<ObjectsChanged>;
 
  private:
    PXR_NS::SdfPathVector _resyncChanges;
 
    PXR_NS::SdfPathVector _infoChanges;
 
    ChangedFieldMap _changedFields;
};
 
class StageEditTargetChanged : public StageNoticeImpl<StageEditTargetChanged> {
  public:
    UNF_API virtual ~StageEditTargetChanged() = default;
 
  protected:
    explicit StageEditTargetChanged(
        const PXR_NS::UsdNotice::StageEditTargetChanged&)
    {
    }
 
    friend StageNoticeImpl<StageEditTargetChanged>;
};
 
class LayerMutingChanged : public StageNoticeImpl<LayerMutingChanged> {
  public:
    UNF_API virtual ~LayerMutingChanged() = default;
 
    UNF_API LayerMutingChanged(const LayerMutingChanged&);
 
    UNF_API LayerMutingChanged& operator=(const LayerMutingChanged&);
 
    // Bring all Merge declarations from base class to prevent
    // overloaded-virtual warning.
    using StageNoticeImpl<LayerMutingChanged>::Merge;
 
    UNF_API virtual void Merge(LayerMutingChanged&&) override;
 
    UNF_API const std::vector<std::string>& GetMutedLayers() const
    {
        return _mutedLayers;
    }
 
    UNF_API const std::vector<std::string>& GetUnmutedLayers() const
    {
        return _unmutedLayers;
    }
 
  protected:
    explicit LayerMutingChanged(const PXR_NS::UsdNotice::LayerMutingChanged&);
 
    friend StageNoticeImpl<LayerMutingChanged>;
 
  private:
    std::vector<std::string> _mutedLayers;
 
    std::vector<std::string> _unmutedLayers;
};
 
}  // namespace UnfNotice
 
}  // namespace unf
 
#endif  // USD_NOTICE_FRAMEWORK_NOTICE_H