dependency.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_DEPENDENCY_H
#define PXR_USD_PCP_DEPENDENCY_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/mapFunction.h"
#include "pxr/usd/sdf/path.h"
 
#include "pxr/base/tf/declarePtrs.h"
 
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
TF_DECLARE_WEAK_AND_REF_PTRS(PcpLayerStack);
 
class PcpNodeRef;
 
enum PcpDependencyType {
    PcpDependencyTypeNone = 0,
 
    PcpDependencyTypeRoot = (1 << 0),
 
    PcpDependencyTypePurelyDirect = (1 << 1),
 
    PcpDependencyTypePartlyDirect = (1 << 2),
 
    PcpDependencyTypeAncestral = (1 << 3),
 
    PcpDependencyTypeVirtual = (1 << 4),
    PcpDependencyTypeNonVirtual = (1 << 5),
 
    PcpDependencyTypeDirect =
        PcpDependencyTypePartlyDirect
        | PcpDependencyTypePurelyDirect,
 
    PcpDependencyTypeAnyNonVirtual =
        PcpDependencyTypeRoot
        | PcpDependencyTypeDirect
        | PcpDependencyTypeAncestral
        | PcpDependencyTypeNonVirtual,
 
    PcpDependencyTypeAnyIncludingVirtual =
        PcpDependencyTypeAnyNonVirtual
        | PcpDependencyTypeVirtual,
};
 
typedef unsigned int PcpDependencyFlags;
 
struct PcpDependency {
    SdfPath indexPath;
    SdfPath sitePath;
    PcpMapFunction mapFunc;
 
    bool operator==(const PcpDependency &rhs) const {
        return indexPath == rhs.indexPath &&
            sitePath == rhs.sitePath &&
            mapFunc == rhs.mapFunc;
    }
    bool operator!=(const PcpDependency &rhs) const {
        return !(*this == rhs);
    }
};
 
using PcpDependencyVector = std::vector<PcpDependency>;
 
struct PcpCulledDependency
{
    PcpDependencyFlags flags = PcpDependencyTypeNone;
    PcpLayerStackRefPtr layerStack;
    SdfPath sitePath;
    SdfPath unrelocatedSitePath;
    PcpMapFunction mapToRoot;
};
 
using PcpCulledDependencyVector = std::vector<PcpCulledDependency>;
 
PCP_API
bool PcpNodeIntroducesDependency(const PcpNodeRef &n);
 
PCP_API
PcpDependencyFlags PcpClassifyNodeDependency(const PcpNodeRef &n);
 
PCP_API
std::string PcpDependencyFlagsToString(const PcpDependencyFlags flags);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_DEPENDENCY_H