node.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_PCP_NODE_H
#define PXR_USD_PCP_NODE_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/types.h"
#include "pxr/usd/sdf/types.h"
#include "pxr/base/tf/iterator.h"
#include "pxr/base/tf/hashset.h"
 
PXR_NAMESPACE_OPEN_SCOPE
 
class PcpArc;
class PcpLayerStackSite;
class PcpMapExpression;
class PcpNodeRef;
class PcpNodeRef_ChildrenIterator;
class PcpNodeRef_ChildrenReverseIterator;
class PcpErrorBase;
typedef std::shared_ptr<PcpErrorBase> PcpErrorBasePtr;
 
TF_DECLARE_REF_PTRS(PcpPrimIndex_Graph);
 
class PcpNodeRef
{
public:
    typedef PcpNodeRef_ChildrenIterator child_const_iterator;
    typedef PcpNodeRef_ChildrenReverseIterator child_const_reverse_iterator;
    typedef std::pair<child_const_iterator,
                      child_const_iterator> child_const_range;
    typedef std::pair<child_const_reverse_iterator,
                      child_const_reverse_iterator> child_const_reverse_range;
 
    PcpNodeRef() : _graph(0), _nodeIdx(PCP_INVALID_INDEX) {}
 
 
    typedef size_t PcpNodeRef::*UnspecifiedBoolType;
    inline operator UnspecifiedBoolType() const {
        return (_graph && _nodeIdx != PCP_INVALID_INDEX) ? &PcpNodeRef::_nodeIdx : 0;
    }        
    
    inline bool operator==(const PcpNodeRef& rhs) const {
        return _nodeIdx == rhs._nodeIdx && _graph == rhs._graph;
    }
 
    inline bool operator!=(const PcpNodeRef& rhs) const {
        return !(*this == rhs);
    }
 
    PCP_API
    bool operator<(const PcpNodeRef& rhs) const;
 
    bool operator<=(const PcpNodeRef& rhs) const {
        return !(rhs < *this);
    }
 
    bool operator>(const PcpNodeRef& rhs) const {
        return rhs < *this;
    }
 
    bool operator>=(const PcpNodeRef& rhs) const {
        return !(*this < rhs);
    }
 
    struct Hash {
        size_t operator()(const PcpNodeRef& rhs) const
        { return (size_t)rhs.GetUniqueIdentifier(); }
    };
 
    PcpPrimIndex_Graph *GetOwningGraph() const {
        return _graph;
    }
 
    PCP_API
    void* GetUniqueIdentifier() const;
 
 
 
    PCP_API
    PcpArcType GetArcType() const;
 
    PCP_API
    PcpNodeRef GetParentNode() const;
 
    PCP_API
    child_const_range GetChildrenRange() const;
 
    PCP_API
    child_const_reverse_range GetChildrenReverseRange() const;
 
    PCP_API
    PcpNodeRef InsertChild(const PcpLayerStackSite& site, const PcpArc& arc,
        PcpErrorBasePtr *error);
 
    PCP_API
    PcpNodeRef InsertChildSubgraph(
        const PcpPrimIndex_GraphRefPtr& subgraph, const PcpArc& arc,
        PcpErrorBasePtr *error);
 
    PCP_API
    PcpNodeRef GetOriginNode() const;
 
    PCP_API
    PcpNodeRef GetOriginRootNode() const;
 
    PCP_API
    PcpNodeRef GetRootNode() const;
 
    PCP_API
    const PcpMapExpression& GetMapToParent() const;
 
    PCP_API
    const PcpMapExpression& GetMapToRoot() const;
 
    PCP_API
    int GetSiblingNumAtOrigin() const;
 
    PCP_API
    int GetNamespaceDepth() const;
 
    PCP_API
    int GetDepthBelowIntroduction() const;
 
    PCP_API
    SdfPath GetPathAtIntroduction() const;
 
    PCP_API
    SdfPath GetIntroPath() const;
 
    PCP_API 
    SdfPath GetPathAtOriginRootIntroduction() const;
 
 
 
    PCP_API
    PcpLayerStackSite GetSite() const;
 
    PCP_API
    const SdfPath& GetPath() const;
 
    PCP_API
    const PcpLayerStackRefPtr& GetLayerStack() const;
 
    PCP_API
    bool IsRootNode() const;
 
    PCP_API
    void SetIsDueToAncestor(bool isDueToAncestor);
    PCP_API
    bool IsDueToAncestor() const;
 
    PCP_API
    void SetHasSymmetry(bool hasSymmetry);
    PCP_API
    bool HasSymmetry() const;
 
    PCP_API
    void SetPermission(SdfPermission perm);
    PCP_API
    SdfPermission GetPermission() const;
 
    PCP_API
    void SetInert(bool inert);
    PCP_API
    bool IsInert() const;
    
    PCP_API
    void SetCulled(bool culled);
    PCP_API
    bool IsCulled() const;
 
    PCP_API
    void SetRestricted(bool restricted);
    PCP_API
    bool IsRestricted() const;
 
    PCP_API
    bool CanContributeSpecs() const;
 
    PCP_API
    size_t GetSpecContributionRestrictedDepth() const;
 
    PCP_API
    void SetSpecContributionRestrictedDepth(size_t depth);
    
    PCP_API
    void SetHasSpecs(bool hasSpecs);
    PCP_API
    bool HasSpecs() const;
 
    PCP_API
    void SetHasValueClips(bool hasValueClips);
    PCP_API
    bool HasValueClips() const;
 
 
    // Returns a compressed Sd site.  For internal use only.
    Pcp_CompressedSdSite GetCompressedSdSite(size_t layerIndex) const
    {
        return Pcp_CompressedSdSite(_nodeIdx, layerIndex);
    }
 
    PCP_API
    friend std::ostream & operator<<(std::ostream &out, const PcpNodeRef &node);
 
private:
    friend class PcpPrimIndex_Graph;
    friend class PcpNodeIterator;
    friend class PcpNodeRef_ChildrenIterator;
    friend class PcpNodeRef_ChildrenReverseIterator;
    friend class PcpNodeRef_PrivateChildrenConstIterator;
    friend class PcpNodeRef_PrivateChildrenConstReverseIterator;
    friend class PcpNodeRef_PrivateSubtreeConstIterator;
    template <class T> friend class Pcp_TraversalCache;
    friend bool Pcp_IsPropagatedSpecializesNode(const PcpNodeRef& node);
 
    // Private constructor for internal use.
    PcpNodeRef(PcpPrimIndex_Graph* graph, size_t idx)
        : _graph(graph), _nodeIdx(idx)
    {}
 
    size_t _GetNodeIndex() const { return _nodeIdx; }
 
    inline size_t _GetParentIndex() const;
    inline size_t _GetOriginIndex() const;
 
    inline void _SetInert(bool inert);
    inline void _SetRestricted(bool restricted);
 
    enum class _Restricted { Yes, Unknown };
    void _RecordRestrictionDepth(_Restricted isRestricted);
 
private: // Data
    PcpPrimIndex_Graph* _graph;
    size_t _nodeIdx;
};
 
template <typename HashState>
inline
void
TfHashAppend(HashState& h, const PcpNodeRef& x){
    h.Append((size_t)(x.GetUniqueIdentifier()));
}
inline
size_t
hash_value(const PcpNodeRef& x)
{
    return TfHash{}(x);
}
 
typedef TfHashSet<PcpNodeRef, PcpNodeRef::Hash> PcpNodeRefHashSet;
typedef std::vector<PcpNodeRef> PcpNodeRefVector;
 
class PcpNodeRef_PtrProxy {
public:
    PcpNodeRef* operator->() { return &_nodeRef; }
private:
    friend class PcpNodeRef_ChildrenIterator;
    friend class PcpNodeRef_ChildrenReverseIterator;
    explicit PcpNodeRef_PtrProxy(const PcpNodeRef& nodeRef) : _nodeRef(nodeRef) {}
    PcpNodeRef _nodeRef;
};
 
class PcpNodeRef_ChildrenIterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = PcpNodeRef;
    using reference = PcpNodeRef;
    using pointer = PcpNodeRef_PtrProxy;
    using difference_type = std::ptrdiff_t;
 
    PCP_API
    PcpNodeRef_ChildrenIterator();
 
    PCP_API
    PcpNodeRef_ChildrenIterator(const PcpNodeRef& node, bool end = false);
 
    reference operator*() const { return dereference(); }
    pointer operator->() const { return pointer(dereference()); }
 
    PcpNodeRef_ChildrenIterator& operator++() {
        increment();
        return *this;
    }
 
    PcpNodeRef_ChildrenIterator operator++(int) {
        const PcpNodeRef_ChildrenIterator result = *this;
        increment();
        return result;
    }
 
    bool operator==(const PcpNodeRef_ChildrenIterator& other) const {
        return equal(other);
    }
 
    bool operator!=(const PcpNodeRef_ChildrenIterator& other) const {
        return !equal(other);
    }
 
private:
    PCP_API
    void increment();
    bool equal(const PcpNodeRef_ChildrenIterator& other) const
    {
        // Note: The default constructed iterator is *not* equal to any
        //       other iterator.
        return (_node == other._node && _index == other._index);
    }
    reference dereference() const
    {
        return reference(_node._graph, _index);
    }
 
private:
    // Current graph node this iterator is pointing at.
    PcpNodeRef _node;
 
    // Index of current child.
    size_t _index;
 
    friend class PcpNodeRef_ChildrenReverseIterator;
};
 
class PcpNodeRef_ChildrenReverseIterator
{
public:
    using iterator_category = std::forward_iterator_tag;
    using value_type = PcpNodeRef;
    using reference = PcpNodeRef;
    using pointer = PcpNodeRef_PtrProxy;
    using difference_type = std::ptrdiff_t;
 
    PCP_API
    PcpNodeRef_ChildrenReverseIterator();
 
    PCP_API
    PcpNodeRef_ChildrenReverseIterator(const PcpNodeRef_ChildrenIterator&);
 
    PCP_API
    PcpNodeRef_ChildrenReverseIterator(const PcpNodeRef& node,bool end = false);
 
    reference operator*() const { return dereference(); }
    pointer operator->() const { return pointer(dereference()); }
 
    PcpNodeRef_ChildrenReverseIterator& operator++() {
        increment();
        return *this;
    }
 
    PcpNodeRef_ChildrenReverseIterator operator++(int) {
        const PcpNodeRef_ChildrenReverseIterator result = *this;
        increment();
        return result;
    }
 
    bool operator==(const PcpNodeRef_ChildrenReverseIterator& other) const {
        return equal(other);
    }
 
    bool operator!=(const PcpNodeRef_ChildrenReverseIterator& other) const {
        return !equal(other);
    }
 
private:
    PCP_API
    void increment();
    bool equal(const PcpNodeRef_ChildrenReverseIterator& other) const
    {
        // Note: The default constructed iterator is *not* equal to any
        //       other iterator.
        return (_node == other._node && _index == other._index);
    }
    reference dereference() const
    {
        return reference(_node._graph, _index);
    }
 
private:
    // Current graph node this iterator is pointing at.
    PcpNodeRef _node;
 
    // Index of current child.
    size_t _index;
};
 
template <>
struct Tf_IteratorInterface<PcpNodeRef::child_const_range, false> {
    typedef PcpNodeRef::child_const_iterator IteratorType;
    static IteratorType Begin(PcpNodeRef::child_const_range const &c)
    {
        return c.first;
    }
    static IteratorType End(PcpNodeRef::child_const_range const &c)
    {
        return c.second;
    }
};
 
template <>
struct Tf_IteratorInterface<PcpNodeRef::child_const_range, true> {
    typedef PcpNodeRef::child_const_reverse_iterator IteratorType;
    static IteratorType Begin(PcpNodeRef::child_const_range const &c)
    {
        return c.second;
    }
    static IteratorType End(PcpNodeRef::child_const_range const &c)
    {
        return c.first;
    }
};
 
template <>
struct Tf_ShouldIterateOverCopy<PcpNodeRef::child_const_range> :
    std::true_type {};
 
inline
PcpNodeRef_ChildrenIterator
begin(const PcpNodeRef::child_const_range& r)
{
    return r.first;
}
 
inline
PcpNodeRef_ChildrenIterator
end(const PcpNodeRef::child_const_range& r)
{
    return r.second;
}
 
inline
PcpNodeRef_ChildrenReverseIterator
begin(const PcpNodeRef::child_const_reverse_range& r)
{
    return r.first;
}
 
inline
PcpNodeRef_ChildrenReverseIterator
end(const PcpNodeRef::child_const_reverse_range& r)
{
    return r.second;
}
 
// Helper to count the non-variant path components of a path; equivalent
// to path.StripAllVariantSelections().GetPathElementCount() except
// this method avoids constructing a new SdfPath value.
int PcpNode_GetNonVariantPathElementCount(const SdfPath &path);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_NODE_H