layerStackIdentifier.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_PCP_LAYER_STACK_IDENTIFIER_H
#define PXR_USD_PCP_LAYER_STACK_IDENTIFIER_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/pcp/expressionVariablesSource.h"
 
#include "pxr/usd/sdf/declareHandles.h"
#include "pxr/usd/ar/resolverContext.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
SDF_DECLARE_HANDLES(SdfLayer);
 
class PcpLayerStackIdentifier {
public:
    typedef PcpLayerStackIdentifier This;
 
    PCP_API
    PcpLayerStackIdentifier();
 
    PCP_API
    PcpLayerStackIdentifier(
        const SdfLayerHandle& rootLayer,
        const SdfLayerHandle& sessionLayer = TfNullPtr,
        const ArResolverContext& pathResolverContext = ArResolverContext(),
        const PcpExpressionVariablesSource& expressionVariablesOverrideSource = 
            PcpExpressionVariablesSource());
 
    // XXX: Allow assignment because there are clients using this
    //      as a member that themselves want to be assignable.
    PCP_API
    PcpLayerStackIdentifier& operator=(const PcpLayerStackIdentifier&);
 
    // Validity.
    PCP_API
    explicit operator bool() const;
 
    // Comparison.
    PCP_API
    bool operator==(const This &rhs) const;
    bool operator!=(const This &rhs) const
    {
        return !(rhs == *this);
    }
 
    PCP_API
    bool operator<(const This &rhs) const;
    bool operator<=(const This& rhs) const
    {
        return !(rhs < *this);
    }
    bool operator>(const This& rhs) const
    {
        return rhs < *this;
    }
    bool operator>=(const This& rhs) const
    {
        return !(*this < rhs);
    }
 
    // Hashing.
    struct Hash {
        size_t operator()(const This & x) const
        {
            return x.GetHash();
        }
    };
    size_t GetHash() const
    {
        return _hash;
    }
 
public:
    const SdfLayerHandle rootLayer;
 
    const SdfLayerHandle sessionLayer;
 
    const ArResolverContext pathResolverContext;
 
    const PcpExpressionVariablesSource expressionVariablesOverrideSource;
 
private:
    size_t _ComputeHash() const;
 
private:
    const size_t _hash;
};
 
template <typename HashState>
inline void
TfHashAppend(HashState& h, const PcpLayerStackIdentifier& x)
{
    h.Append(x.GetHash());
}
 
inline
size_t
hash_value(const PcpLayerStackIdentifier& x)
{
    return TfHash{}(x);
}
 
PCP_API
std::ostream& operator<<(std::ostream&, const PcpLayerStackIdentifier&);
 
PCP_API
std::ostream& PcpIdentifierFormatBaseName(std::ostream&);
 
PCP_API
std::ostream& PcpIdentifierFormatRealPath(std::ostream&);
 
PCP_API
std::ostream& PcpIdentifierFormatIdentifier(std::ostream&);
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_LAYER_STACK_IDENTIFIER_H