mapFunction.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_MAP_FUNCTION_H
#define PXR_USD_PCP_MAP_FUNCTION_H
 
#include "pxr/pxr.h"
#include "pxr/usd/pcp/api.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/sdf/layerOffset.h"
#include "pxr/usd/sdf/pathExpression.h"
 
#include <atomic>
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class PcpMapFunction
{
public:
    typedef std::map<SdfPath, SdfPath, SdfPath::FastLessThan> PathMap;
    typedef std::pair<SdfPath, SdfPath> PathPair;
    typedef std::vector<PathPair> PathPairVector;
 
    PcpMapFunction() = default;
 
    PCP_API
    static PcpMapFunction 
    Create(const PathMap &sourceToTargetMap,
           const SdfLayerOffset &offset);
 
    PCP_API
    static PcpMapFunction
    ImpliedClass(const PcpMapFunction& transferFunc,
                 const PcpMapFunction& classArc);
 
    PCP_API
    static const PcpMapFunction &Identity();
 
    PCP_API
    static const PathMap &IdentityPathMap();
    
    PCP_API
    void Swap(PcpMapFunction &map);
    void swap(PcpMapFunction &map) { Swap(map); }
 
    PCP_API
    bool operator==(const PcpMapFunction &map) const;
 
    PCP_API
    bool operator!=(const PcpMapFunction &map) const;
 
    PCP_API
    bool IsNull() const;
 
    PCP_API
    bool IsIdentity() const;
    
    PCP_API
    bool IsIdentityPathMapping() const;
 
    bool HasRootIdentity() const { return _data.hasRootIdentity; }
 
    PCP_API
    SdfPath MapSourceToTarget(const SdfPath &path) const;
 
    PCP_API
    SdfPath MapTargetToSource(const SdfPath &path) const;
 
    PCP_API
    SdfPathExpression
    MapSourceToTarget(
        const SdfPathExpression &pathExpr,
        std::vector<SdfPathExpression::PathPattern>
            *unmappedPatterns = nullptr,
        std::vector<SdfPathExpression::ExpressionReference>
            *unmappedRefs = nullptr
        ) const;
 
    PCP_API
    SdfPathExpression
    MapTargetToSource(
        const SdfPathExpression &pathExpr,
        std::vector<SdfPathExpression::PathPattern>
            *unmappedPatterns = nullptr,
        std::vector<SdfPathExpression::ExpressionReference>
            *unmappedRefs = nullptr
        ) const;
    
    PCP_API
    PcpMapFunction Compose(const PcpMapFunction &f) const;
 
    PCP_API
    PcpMapFunction ComposeOffset(const SdfLayerOffset &newOffset) const;
 
    PCP_API
    PcpMapFunction GetInverse() const;
 
    PCP_API
    PathMap GetSourceToTargetMap() const;
 
    const SdfLayerOffset &GetTimeOffset() const { return _offset; }
 
    PCP_API
    std::string GetString() const;
 
    PCP_API
    size_t Hash() const;
 
private:
 
    PCP_API
    PcpMapFunction(PathPair const *sourceToTargetBegin,
                   PathPair const *sourceToTargetEnd,
                   SdfLayerOffset offset,
                   bool hasRootIdentity);
 
    PCP_API
    SdfPathExpression
    _MapPathExpressionImpl(
        bool invert,
        const SdfPathExpression &pathExpr,
        std::vector<SdfPathExpression::PathPattern> *unmappedPatterns,
        std::vector<SdfPathExpression::ExpressionReference> *unmappedRefs
        ) const;
 
private:
    friend PcpMapFunction *Pcp_MakeIdentity();
 
    static const int _MaxLocalPairs = 2;
    struct _Data final {
        _Data() {};
 
        _Data(PathPair const *begin, PathPair const *end, bool hasRootIdentity)
            : numPairs(end-begin)
            , hasRootIdentity(hasRootIdentity) {
            if (numPairs == 0)
                return;
            if (numPairs <= _MaxLocalPairs) {
                std::uninitialized_copy(begin, end, localPairs);
            }
            else {
                new (&remotePairs) std::shared_ptr<PathPair>(
                    new PathPair[numPairs], std::default_delete<PathPair[]>());
                std::copy(begin, end, remotePairs.get());
            }
        }
        
        _Data(_Data const &other)
            : numPairs(other.numPairs)
            , hasRootIdentity(other.hasRootIdentity) {
            if (numPairs <= _MaxLocalPairs) {
                std::uninitialized_copy(
                    other.localPairs,
                    other.localPairs + other.numPairs, localPairs);
            }
            else {
                new (&remotePairs) std::shared_ptr<PathPair>(other.remotePairs);
            }
        }
        _Data(_Data &&other)
            : numPairs(other.numPairs)
            , hasRootIdentity(other.hasRootIdentity) {
            if (numPairs <= _MaxLocalPairs) {
                PathPair *dst = localPairs;
                PathPair *src = other.localPairs;
                PathPair *srcEnd = other.localPairs + other.numPairs;
                for (; src != srcEnd; ++src, ++dst) {
                    ::new (static_cast<void*>(std::addressof(*dst)))
                        PathPair(std::move(*src));
                }
            }
            else {
                new (&remotePairs)
                    std::shared_ptr<PathPair>(std::move(other.remotePairs));
            }
        }
        _Data &operator=(_Data const &other) {
            if (this != &other) {
                this->~_Data();
                new (this) _Data(other);
            }
            return *this;
        }
        _Data &operator=(_Data &&other) {
            if (this != &other) {
                this->~_Data();
                new (this) _Data(std::move(other));
            }
            return *this;
        }
        ~_Data() {
            if (numPairs <= _MaxLocalPairs) {
                for (PathPair *p = localPairs; numPairs--; ++p) {
                    p->~PathPair();
                }
            }
            else {
                remotePairs.~shared_ptr<PathPair>();
            }
        }
 
        bool IsNull() const {
            return numPairs == 0 && !hasRootIdentity;
        }
 
        PathPair const *begin() const {
            return numPairs <= _MaxLocalPairs ? localPairs : remotePairs.get();
        }
 
        PathPair const *end() const {
            return begin() + numPairs;
        }
 
        bool operator==(_Data const &other) const {
            return numPairs == other.numPairs &&
                hasRootIdentity == other.hasRootIdentity &&
                std::equal(begin(), end(), other.begin());
        }
 
        bool operator!=(_Data const &other) const {
            return !(*this == other);
        }
 
        template <class HashState>
        friend void TfHashAppend(HashState &h, _Data const &data){
            h.Append(data.hasRootIdentity);
            h.Append(data.numPairs);
            h.AppendRange(std::begin(data), std::end(data));
        }
 
        union {
            PathPair localPairs[_MaxLocalPairs > 0 ? _MaxLocalPairs : 1];
            std::shared_ptr<PathPair> remotePairs;
        };
        typedef int PairCount;
        PairCount numPairs = 0;
        bool hasRootIdentity = false;
    };
 
    // Specialize TfHashAppend for PcpMapFunction.
    template <typename HashState>
    friend inline
    void TfHashAppend(HashState& h, const PcpMapFunction& x){
        h.Append(x._data);
        h.Append(x._offset);
    }
 
    _Data _data;
    SdfLayerOffset _offset;
};
 
// Specialize hash_value for PcpMapFunction.
inline
size_t hash_value(const PcpMapFunction& x)
{
    return TfHash{}(x);
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_PCP_MAP_FUNCTION_H