abstractData.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_SDF_ABSTRACT_DATA_H
#define PXR_USD_SDF_ABSTRACT_DATA_H
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/sdf/types.h"
 
#include "pxr/base/vt/value.h"
 
#include "pxr/base/tf/staticTokens.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/refBase.h"
#include "pxr/base/tf/weakBase.h"
#include "pxr/base/tf/declarePtrs.h"
 
#include <vector>
#include <type_traits>
 
PXR_NAMESPACE_OPEN_SCOPE
 
TF_DECLARE_WEAK_AND_REF_PTRS(SdfAbstractData);
class SdfAbstractDataSpecVisitor;
class SdfAbstractDataConstValue;
class SdfAbstractDataValue;
 
 
#define SDF_DATA_TOKENS                  \
        ((TimeSamples, "timeSamples"))
 
TF_DECLARE_PUBLIC_TOKENS(SdfDataTokens, SDF_API, SDF_DATA_TOKENS);
 
 
class SdfAbstractData : public TfRefBase, public TfWeakBase
{
public:
    SdfAbstractData() {}
    SDF_API
    virtual ~SdfAbstractData(); 
 
    SDF_API
    virtual void CopyFrom(const SdfAbstractDataConstPtr& source);
 
    SDF_API
    virtual bool StreamsData() const = 0;
 
    SDF_API
    virtual bool IsDetached() const;
 
    SDF_API
    virtual bool IsEmpty() const;
 
    // XXX: What are the right semantics for this?
    //      Does it matter if the underlying implementation matches?
    SDF_API
    virtual bool Equals(const SdfAbstractDataRefPtr &rhs) const;
 
    SDF_API
    virtual void WriteToStream(std::ostream& out) const;
 
 
    SDF_API
    virtual void CreateSpec(const SdfPath &path, 
                            SdfSpecType specType) = 0;
 
    SDF_API
    virtual bool HasSpec(const SdfPath &path) const = 0;
 
    SDF_API
    virtual void EraseSpec(const SdfPath &path) = 0;
 
    SDF_API
    virtual void MoveSpec(const SdfPath &oldPath, 
                          const SdfPath &newPath) = 0;
 
    virtual SdfSpecType GetSpecType(const SdfPath &path) const = 0;
 
    SDF_API
    void VisitSpecs(SdfAbstractDataSpecVisitor* visitor) const;
 
 
 
    SDF_API
    virtual bool Has(const SdfPath& path, const TfToken& fieldName,
                     SdfAbstractDataValue* value) const = 0;
 
    SDF_API
    virtual bool Has(const SdfPath& path, const TfToken &fieldName,
                     VtValue *value = NULL) const = 0;
 
    SDF_API
    virtual bool
    HasSpecAndField(const SdfPath &path, const TfToken &fieldName,
                    SdfAbstractDataValue *value, SdfSpecType *specType) const;
 
    SDF_API
    virtual bool
    HasSpecAndField(const SdfPath &path, const TfToken &fieldName,
                    VtValue *value, SdfSpecType *specType) const;
 
    SDF_API
    virtual VtValue Get(const SdfPath& path, 
                        const TfToken& fieldName) const = 0;
 
    SDF_API
    virtual std::type_info const &
    GetTypeid(const SdfPath &path, const TfToken &fieldName) const;
 
    SDF_API
    virtual void Set(const SdfPath &path, const TfToken &fieldName,
                     const VtValue &value) = 0;
 
    SDF_API
    virtual void Set(const SdfPath &path, const TfToken &fieldName,
                     const SdfAbstractDataConstValue& value) = 0;
 
    SDF_API
    virtual void Erase(const SdfPath& path, 
                       const TfToken& fieldName) = 0;
 
    SDF_API
    virtual std::vector<TfToken> List(const SdfPath& path) const = 0;
 
    template <class T>
    inline T GetAs(const SdfPath& path, const TfToken& fieldName,
                   const T& defaultValue = T()) const;
 
 
 
 
    // Return true and set \p value (if non null) if the field identified by
    // \p path and \p fieldName is dictionary-valued, and if there is an element
    // at \p keyPath in that dictionary.  Return false otherwise.  If
    // \p keyPath names an entire sub-dictionary, set \p value to that entire
    // sub-dictionary and return true.
    SDF_API
    virtual bool HasDictKey(const SdfPath& path,
                            const TfToken &fieldName,
                            const TfToken &keyPath,
                            SdfAbstractDataValue* value) const;
    SDF_API
    virtual bool HasDictKey(const SdfPath& path,
                            const TfToken &fieldName,
                            const TfToken &keyPath,
                            VtValue *value = NULL) const;
 
    // Same as HasDictKey but return empty VtValue on failure.
    SDF_API
    virtual VtValue GetDictValueByKey(const SdfPath& path,
                                      const TfToken &fieldName,
                                      const TfToken &keyPath) const;
 
    // Set the element at \p keyPath in the dictionary-valued field identified
    // by \p path and \p fieldName.  If the field itself is not
    // dictionary-valued, replace the field with a new dictionary and set the
    // element at \p keyPath in it.  If \p value is empty, invoke
    // EraseDictValueByKey instead.
    SDF_API
    virtual void SetDictValueByKey(const SdfPath& path,
                                   const TfToken &fieldName,
                                   const TfToken &keyPath,
                                   const VtValue &value);
    SDF_API
    virtual void SetDictValueByKey(const SdfPath& path,
                                   const TfToken &fieldName,
                                   const TfToken &keyPath,
                                   const SdfAbstractDataConstValue& value);
 
    // If \p path and \p fieldName identify a dictionary-valued field with an
    // element at \p keyPath, remove that element from the dictionary.  If this
    // leaves the dictionary empty, Erase() the entire field.
    SDF_API
    virtual void EraseDictValueByKey(const SdfPath& path,
                                     const TfToken &fieldName,
                                     const TfToken &keyPath);
 
    // If \p path, \p fieldName, and \p keyPath identify a (sub) dictionary,
    // return a vector of the keys in that dictionary, otherwise return an empty
    // vector.
    SDF_API
    virtual std::vector<TfToken> ListDictKeys(const SdfPath& path,
                                              const TfToken &fieldName,
                                              const TfToken &keyPath) const;
 
 
 
 
 
    SDF_API
    virtual std::set<double>
    ListAllTimeSamples() const = 0;
    
    SDF_API
    virtual std::set<double>
    ListTimeSamplesForPath(const SdfPath& path) const = 0;
 
    SDF_API
    virtual bool
    GetBracketingTimeSamples(double time, double* tLower, 
                             double* tUpper) const = 0;
 
    SDF_API
    virtual size_t
    GetNumTimeSamplesForPath(const SdfPath& path) const = 0;
 
    SDF_API
    virtual bool
    GetBracketingTimeSamplesForPath(const SdfPath& path, 
                                    double time,
                                    double* tLower, double* tUpper) const = 0;
 
    SDF_API
    virtual bool
    GetPreviousTimeSampleForPath(const SdfPath& path, double time, 
                                 double* tPrevious) const;
 
    SDF_API
    virtual bool
    QueryTimeSample(const SdfPath& path, double time,
                    VtValue *optionalValue = NULL) const = 0;
    SDF_API
    virtual bool
    QueryTimeSample(const SdfPath& path, double time,
                    SdfAbstractDataValue *optionalValue) const = 0;
 
    SDF_API
    virtual void
    SetTimeSample(const SdfPath& path, double time, 
                  const VtValue & value) = 0;
 
    SDF_API
    virtual void
    EraseTimeSample(const SdfPath& path, double time) = 0;
 
 
protected:
    SDF_API
    virtual void _VisitSpecs(SdfAbstractDataSpecVisitor* visitor) const = 0;
};
 
template <class T>
inline T SdfAbstractData::GetAs(
    const SdfPath& path, 
    const TfToken& field, const T& defaultVal) const
{
    VtValue val = Get(path, field);
    if (val.IsHolding<T>()) {
        return val.UncheckedGet<T>();
    }
    return defaultVal;
}
 
class SdfAbstractDataValue
{
public:
    template <class T> 
    bool StoreValue(T &&v) 
    {
        // this can be std::remove_cvref_t in c++20.
        using Type = std::remove_cv_t<std::remove_reference_t<T>>;
 
        if constexpr (std::is_same_v<Type, VtValue>) {
            return _StoreVtValue(std::forward<T>(v));
        }
        
        isValueBlock = false;
        isAnimationBlock = false;
        typeMismatch = false;
        if constexpr (std::is_same_v<Type, SdfValueBlock>) {
            isValueBlock = true;
            return true;
        } else if constexpr (std::is_same_v<Type, SdfAnimationBlock>) {
            isAnimationBlock = true;
            return true;
        }
        if (TfSafeTypeCompare(typeid(Type), valueType)) {
            *static_cast<Type*>(value) = std::forward<T>(v);
            return true;
        }
        typeMismatch = true;
        return false;
    }
 
    void* value;
    const std::type_info& valueType;
    bool isValueBlock;
    bool isAnimationBlock;
    bool typeMismatch;
 
protected:
    SdfAbstractDataValue(void* value_, const std::type_info& valueType_)
        : value(value_)
        , valueType(valueType_)
        , isValueBlock(false)
        , isAnimationBlock(false)
        , typeMismatch(false)
    { }
 
private:
    virtual bool _StoreVtValue(const VtValue& value) = 0;
    virtual bool _StoreVtValue(VtValue &&value) = 0;
};
 
template <class T>
class SdfAbstractDataTypedValue : public SdfAbstractDataValue
{
public:
    SdfAbstractDataTypedValue(T* value)
        : SdfAbstractDataValue(value, typeid(T))
    { }
 
private:
    T const &_Get(const VtValue &v) {
        return v.UncheckedGet<T>();
    }
 
    T _Get(VtValue &&v) {
        return v.UncheckedRemove<T>();
    }
 
    template <class Value>
    bool _StoreVtValueImpl(Value &&v) {
        typeMismatch = false;
        isValueBlock = false;
        isAnimationBlock = false;
        if (ARCH_LIKELY(std::forward<Value>(v).template IsHolding<T>())) {
            *static_cast<T*>(value) = _Get(std::forward<Value>(v));
            if constexpr (std::is_same_v<T, SdfValueBlock>) {
                isValueBlock = true;
            } else if constexpr (std::is_same_v<T, SdfAnimationBlock>) {
                isAnimationBlock = true;
            }
            return true;
        }
        
        if (std::forward<Value>(v).template IsHolding<SdfValueBlock>()) {
            isValueBlock = true;
            return true;
        } 
        else if (std::forward<Value>(v).template IsHolding<SdfAnimationBlock>()) 
        {
            isAnimationBlock = true;
            return true;
        }
 
        typeMismatch = true;
 
        return false;
    }
    
    virtual bool
    _StoreVtValue(const VtValue& v) override {
        return _StoreVtValueImpl(v);
    }
 
    virtual bool
    _StoreVtValue(VtValue &&v) override {
        return _StoreVtValueImpl(v);
    }
};
 
class SdfAbstractDataConstValue
{
public:
    virtual bool GetValue(VtValue* value) const = 0;
 
    template <class T> bool GetValue(T* v) const
    {
        if (TfSafeTypeCompare(typeid(T), valueType)) {
            *v = *static_cast<const T*>(value);
            return true;
        }
        return false;
    }
 
    virtual bool IsEqual(const VtValue& value) const = 0;
 
    const void* value;
    const std::type_info& valueType;
    const bool isArrayEdit;
    const std::type_info& elementValueType; // void unless isArrayEdit
 
protected:
    SdfAbstractDataConstValue(const void* value_, 
                              const std::type_info& valueType_,
                              const bool isArrayEdit_,
                              const std::type_info& elementValueType_)
        : value(value_)
        , valueType(valueType_)
        , isArrayEdit(isArrayEdit_)
        , elementValueType(elementValueType_)
    { 
    }
};
 
template <class T>
class SdfAbstractDataConstTypedValue : public SdfAbstractDataConstValue
{
public:
    static std::type_info const &_GetElementType() {
        if constexpr (VtIsArrayEdit<T>::value) {
            return typeid(typename T::ElementType);
        }
        else {
            return typeid(void);
        }
    }
 
    SdfAbstractDataConstTypedValue(const T* value)
        : SdfAbstractDataConstValue(
            value, typeid(T), VtIsArrayEdit<T>::value, this->_GetElementType())
        {}
    
    virtual bool GetValue(VtValue* v) const
    {
        *v = _GetValue();
        return true;
    }
 
    virtual bool IsEqual(const VtValue& v) const
    {
        return (v.IsHolding<T>() && v.UncheckedGet<T>() == _GetValue());
    }
 
private:
    const T& _GetValue() const 
    {
        return *static_cast<const T*>(value);
    }
};
 
// Specialization of SdAbstractDataConstTypedValue that converts character
// arrays to std::string. 
template <int N>
class SdfAbstractDataConstTypedValue<char[N]> 
    : public SdfAbstractDataConstTypedValue<std::string>
{
public:
    typedef char CharArray[N];
    SdfAbstractDataConstTypedValue(const CharArray* value)
        : SdfAbstractDataConstTypedValue<std::string>(&_str)
        , _str(*value)
    { }
 
private:
    std::string _str;
};
 
class SdfAbstractDataSpecVisitor
{
public:
    SDF_API
    virtual ~SdfAbstractDataSpecVisitor();
 
    SDF_API
    virtual bool VisitSpec(const SdfAbstractData& data, 
                           const SdfPath& path) = 0;
 
    SDF_API
    virtual void Done(const SdfAbstractData& data) = 0;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDF_ABSTRACT_DATA_H