vectorKey.h

Go to the documentation of this file.

//
// Copyright 2025 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_EXEC_EF_VECTOR_KEY_H
#define PXR_EXEC_EF_VECTOR_KEY_H
 
 
#include "pxr/pxr.h"
 
#include "pxr/exec/ef/api.h"
 
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/hashmap.h"
#include "pxr/exec/vdf/vector.h"
 
#include <memory>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class EF_API_TYPE Ef_VectorKey
{
public:
    using StoredType = std::shared_ptr<Ef_VectorKey>;
 
    Ef_VectorKey(const Ef_VectorKey&) = delete;
    Ef_VectorKey& operator=(const Ef_VectorKey&) = delete;
 
    EF_API
    virtual ~Ef_VectorKey();
 
    const VdfVector &GetValue() const {
        return _value;
    }
 
    virtual size_t CreateHash() const = 0;
 
    virtual bool IsEqual(const Ef_VectorKey &) const = 0;
 
    bool operator==(const Ef_VectorKey &rhs) const {
        return IsEqual(rhs);
    }
 
    bool operator!=(const Ef_VectorKey &rhs) const {
        return !(*this == rhs);
    }
 
    template <class HashState>
    friend void TfHashAppend(HashState &h, const Ef_VectorKey::StoredType &v) {
        h.Append(v->CreateHash());
    }
 
    struct Equal {
        size_t operator()(const StoredType &lhs, const StoredType &rhs) const {
            return lhs->IsEqual(*rhs);
        }
    };
 
    template < typename T >
    struct Map {
        using Type = TfHashMap<
            Ef_VectorKey::StoredType, T, TfHash, Ef_VectorKey::Equal>;
    };
 
protected:
    // Constructor.
    explicit Ef_VectorKey(const VdfVector &value) :
        _value(value)
    {}
 
    // The wrapped VdfVector.
    const VdfVector _value;
 
};
 
 
template < typename T >
class Ef_TypedVectorKey final : public Ef_VectorKey
{
public:
 
    explicit Ef_TypedVectorKey(const VdfVector &value) :
        Ef_VectorKey(value) 
    {}
 
    Ef_TypedVectorKey(const Ef_TypedVectorKey&) = delete;
    Ef_TypedVectorKey &operator=(const Ef_TypedVectorKey&) = delete;
 
    virtual size_t CreateHash() const {
        VdfVector::ReadAccessor<T> a = _value.GetReadAccessor<T>();
        size_t hash = TfHash::Combine(a.GetNumValues());
        for (size_t i = 0; i < a.GetNumValues(); ++i) {
            hash = TfHash::Combine(hash, a[i]);
        }
        return hash;
    }
 
    virtual bool IsEqual(const Ef_VectorKey &rhs) const {
        if (const Ef_TypedVectorKey<T> *rhsDerived =
                dynamic_cast<const Ef_TypedVectorKey<T>*>(&rhs)) {
 
            // Get the accessor to this vector
            VdfVector::ReadAccessor<T> a = _value.GetReadAccessor<T>();
 
            // Get the accessor to the right-hand-side vector
            const VdfVector &rhsV = rhsDerived->_value;
            VdfVector::ReadAccessor<T> rhsA = rhsV.GetReadAccessor<T>();
 
            // Compare each stored element. If two vectors do not hold
            // the same number of elements, they are considered not equal.
            if (a.GetNumValues() == rhsA.GetNumValues()) {
                for (size_t i = 0; i < a.GetNumValues(); ++i) {
                    if (a[i] != rhsA[i]) {
                        return false;
                    }
                }
                return true;
            }
        }
 
        // The two Ef_VectorKeys do not hold the same type T or their sizes do
        // not match, so we consider them unequal.
        return false;
    }
 
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif