notice.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_USD_NOTICE_H
#define PXR_USD_USD_NOTICE_H
 
#include "pxr/pxr.h"
#include "pxr/usd/usd/api.h"
#include "pxr/usd/usd/common.h"
#include "pxr/usd/usd/object.h"
 
#include "pxr/usd/sdf/changeList.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/base/tf/notice.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
 
class UsdNotice {
public:
 
    class StageNotice : public TfNotice {
    public:
        USD_API
        StageNotice(const UsdStageWeakPtr &stage);
        USD_API
        ~StageNotice() override;
 
        const UsdStageWeakPtr &GetStage() const { return _stage; }
 
    private:
        UsdStageWeakPtr _stage;
    };
 
    class StageContentsChanged : public StageNotice {
    public:
        explicit StageContentsChanged(const UsdStageWeakPtr& stage)
            : StageNotice(stage) {}
        USD_API ~StageContentsChanged() override;
    };
 
    class ObjectsChanged : public StageNotice {
 
    public:
        enum class PrimResyncType {
            RenameSource,
            RenameDestination,
            ReparentSource,
            ReparentDestination,
            RenameAndReparentSource,
            RenameAndReparentDestination,
 
            Delete,
 
            UnchangedPrimStack,
 
            Other,
 
            Invalid
        };
 
        using RenamedProperties = std::vector<std::pair<SdfPath, TfToken>>;      
 
    private:
        using _PathsToChangesMap = 
            std::map<SdfPath, std::vector<const SdfChangeList::Entry*>>;
 
        struct _PrimResyncInfo {
            PrimResyncType resyncType;
            SdfPath associatePath;
        };
        using _PrimResyncInfoMap = std::map<SdfPath, _PrimResyncInfo>;
 
        struct _NamespaceEditsInfo {
            _PrimResyncInfoMap primResyncsInfo;
            RenamedProperties renamedProperties;
        };
 
        static const _PathsToChangesMap& _GetEmptyChangesMap();
        static const _NamespaceEditsInfo& _GetEmptyNamespaceEditsInfo();
 
        friend class UsdStage;
        ObjectsChanged(const UsdStageWeakPtr &stage,
                       const _PathsToChangesMap *resyncChanges,
                       const _PathsToChangesMap *infoChanges,
                       const _PathsToChangesMap *assetPathChanges,
                       const _NamespaceEditsInfo *namespaceEditsInfo)
            : StageNotice(stage)
            , _resyncChanges(resyncChanges)
            , _infoChanges(infoChanges)
            , _assetPathChanges(assetPathChanges)
            , _namespaceEditsInfo(namespaceEditsInfo) {}
 
        ObjectsChanged(const UsdStageWeakPtr &stage,
                       const _PathsToChangesMap *resyncChanges);
 
    public:
        USD_API ~ObjectsChanged() override;
 
        bool AffectedObject(const UsdObject &obj) const {
            return ResyncedObject(obj) || ResolvedAssetPathsResynced(obj) 
                || ChangedInfoOnly(obj);
        }
 
        USD_API bool ResyncedObject(const UsdObject &obj) const;
 
        USD_API bool ResolvedAssetPathsResynced(const UsdObject &obj) const;
 
        USD_API bool ChangedInfoOnly(const UsdObject &obj) const;
 
        class PathRange
        {
        public:
            class iterator {
                using _UnderlyingIterator = _PathsToChangesMap::const_iterator;
            public:
                using iterator_category = std::forward_iterator_tag;
                using value_type = const SdfPath&;
                using reference = const SdfPath&;
                using pointer = const SdfPath*;
                using difference_type =
                    typename _UnderlyingIterator::difference_type;
 
                iterator() = default;
                reference operator*() const { return dereference(); }
                pointer operator->() const { return &(dereference()); }
 
                iterator& operator++() {
                    ++_underlyingIterator;
                    return *this;
                }
 
                iterator operator++(int) {
                    iterator result = *this;
                    ++_underlyingIterator;
                    return result;
                }
 
                bool operator==(const iterator& other) const{
                    return _underlyingIterator == other._underlyingIterator;
                }
 
                bool operator!=(const iterator& other) const{
                    return _underlyingIterator != other._underlyingIterator;
                }
 
                USD_API TfTokenVector GetChangedFields() const;
 
                USD_API bool HasChangedFields() const;
 
                _UnderlyingIterator GetBase() const {
                    return _underlyingIterator;
                }
 
                _UnderlyingIterator base() const {
                    return GetBase();
                }
 
            private:
                friend class PathRange;
 
                explicit iterator(_UnderlyingIterator baseIter)
                    : _underlyingIterator(baseIter) {}
 
                inline reference dereference() const { 
                    return _underlyingIterator->first;
                }
 
                _UnderlyingIterator _underlyingIterator;
            };
 
            using const_iterator = iterator;
 
            PathRange() : _changes(nullptr) { }
 
            explicit operator SdfPathVector() const {
                return SdfPathVector(begin(), end());
            }
        
            bool empty() const { 
                return !_changes || _changes->empty(); 
            }
 
            size_t size() const { 
                return _changes ? _changes->size() : 0; 
            }
 
            iterator begin() const { 
                return iterator(_changes->cbegin()); 
            }
 
            const_iterator cbegin() const { 
                return iterator(_changes->cbegin()); 
            }
 
            iterator end() const { 
                return iterator(_changes->cend()); 
            }
 
            const_iterator cend() const { 
                return iterator(_changes->cend()); 
            }
 
            const_iterator find(const SdfPath& path) const {
                return const_iterator(_changes->find(path));
            }
 
        private:
            friend class ObjectsChanged;
            explicit PathRange(const _PathsToChangesMap* changes)
                : _changes(changes)
            { }
 
            const _PathsToChangesMap* _changes;
        };
 
        USD_API PathRange GetResyncedPaths() const;
 
        USD_API PathRange GetChangedInfoOnlyPaths() const;
 
        USD_API PathRange GetResolvedAssetPathsResyncedPaths() const;
 
        USD_API TfTokenVector GetChangedFields(const UsdObject &obj) const;
 
        USD_API TfTokenVector GetChangedFields(const SdfPath &path) const;
 
        USD_API bool HasChangedFields(const UsdObject &obj) const;
        
        USD_API bool HasChangedFields(const SdfPath &path) const;
 
        USD_API PrimResyncType GetPrimResyncType(
            const SdfPath &primPath,
            SdfPath *associatedPrimPath = nullptr) const;       
 
        const RenamedProperties &GetRenamedProperties() const {
            return _namespaceEditsInfo->renamedProperties;
        }
 
    private:
        const _PathsToChangesMap *_resyncChanges;
        const _PathsToChangesMap *_infoChanges;
        const _PathsToChangesMap *_assetPathChanges;
        const _NamespaceEditsInfo *_namespaceEditsInfo;
    };
 
    class StageEditTargetChanged : public StageNotice {
    public:
        explicit StageEditTargetChanged(const UsdStageWeakPtr &stage)
            : StageNotice(stage) {}
        USD_API ~StageEditTargetChanged() override;
    };
 
    class LayerMutingChanged : public StageNotice {
    public:
        explicit LayerMutingChanged(const UsdStageWeakPtr &stage, 
                const std::vector<std::string>& mutedLayers, 
                const std::vector<std::string>& unmutedLayers)
            : StageNotice(stage),
             _mutedLayers(mutedLayers),
             _unMutedLayers(unmutedLayers) {}
 
        USD_API ~LayerMutingChanged() override;
 
        const std::vector<std::string>& GetMutedLayers() const {
            return _mutedLayers;
        }
 
        const std::vector<std::string>& GetUnmutedLayers() const {
            return _unMutedLayers;
        }
 
    private:
        const std::vector<std::string>& _mutedLayers;
        const std::vector<std::string>& _unMutedLayers;
    };
 
};
 
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_USD_NOTICE_H