attributeQuery.h

//
// Copyright 2016 Pixar
//
// Licensed under the terms set forth in the LICENSE.txt file available at
// https://openusd.org/license.
//
#ifndef PXR_USD_USD_ATTRIBUTE_QUERY_H
#define PXR_USD_USD_ATTRIBUTE_QUERY_H
 
#include "pxr/pxr.h"
#include "pxr/usd/usd/api.h"
#include "pxr/usd/usd/attribute.h"
#include "pxr/usd/usd/common.h"
#include "pxr/usd/usd/prim.h"
#include "pxr/usd/usd/resolveInfo.h"
#include "pxr/usd/usd/resolveTarget.h"
#include "pxr/usd/usd/timeCode.h"
 
#include "pxr/base/tf/token.h"
 
#include <vector>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class TsSpline;
 
class UsdAttributeQuery
{
public:
    USD_API
    UsdAttributeQuery();
 
    USD_API
    UsdAttributeQuery(const UsdAttributeQuery &other);
 
    USD_API
    UsdAttributeQuery(UsdAttributeQuery &&other) = default;
 
    USD_API
    explicit UsdAttributeQuery(const UsdAttribute& attr);
 
    USD_API
    UsdAttributeQuery(const UsdPrim& prim, const TfToken& attrName);
 
    USD_API
    UsdAttributeQuery(const UsdAttribute &attr, 
        const UsdResolveTarget &resolveTarget);
 
    USD_API
    static std::vector<UsdAttributeQuery> CreateQueries(
        const UsdPrim& prim, const TfTokenVector& attrNames);
 
    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //
 
 
    USD_API
    const UsdAttribute& GetAttribute() const;
 
    bool IsValid() const {
        return GetAttribute().IsValid();
    }
 
public:
    explicit operator bool() const {
        return IsValid();
    }
 
    USD_API
    UsdAttributeQuery &operator=(const UsdAttributeQuery &other);
 
    USD_API
    UsdAttributeQuery &operator=(UsdAttributeQuery &&other) = default;
 
 
    // --------------------------------------------------------------------- //
    // --------------------------------------------------------------------- //
 
 
    template <typename T>
    bool Get(T* value, UsdTimeCode time = UsdTimeCode::Default()) const {
        static_assert(SdfValueTypeTraits<T>::IsValueType,
                      "T must be an SdfValueType.");
        return _Get(value, time);
    }
    USD_API
    bool Get(VtValue* value, UsdTimeCode time = UsdTimeCode::Default()) const;
    
    //
    USD_API
    bool GetTimeSamples(std::vector<double>* times) const;
 
    USD_API
    TsSpline GetSpline() const;
 
    USD_API
    bool GetTimeSamplesInInterval(const GfInterval& interval,
                                  std::vector<double>* times) const;
 
    USD_API
    static bool GetUnionedTimeSamples(
        const std::vector<UsdAttributeQuery> &attrQueries, 
        std::vector<double> *times);
 
    USD_API
    static bool GetUnionedTimeSamplesInInterval(
        const std::vector<UsdAttributeQuery> &attrQueries, 
        const GfInterval &interval,
        std::vector<double> *times);
 
    USD_API
    size_t GetNumTimeSamples() const;
 
    USD_API
    bool GetBracketingTimeSamples(double desiredTime, 
                                  double* lower, 
                                  double* upper, 
                                  bool* hasTimeSamples) const;
 
    USD_API
    bool HasValue() const;
 
    USD_API
    bool HasSpline() const;
 
    USD_API
    bool HasAuthoredValueOpinion() const;
 
    USD_API
    bool HasAuthoredValue() const;
 
    USD_API
    bool HasFallbackValue() const;
 
    USD_API
    bool ValueMightBeTimeVarying() const;
 
 
private:
    void _Initialize();
 
    void _Initialize(const UsdResolveTarget &resolveTarget);
 
    template <typename T>
    USD_API
    bool _Get(T* value, UsdTimeCode time) const;
 
private:
    UsdAttribute _attr;
    UsdResolveInfo _resolveInfo;
    std::unique_ptr<UsdResolveTarget> _resolveTarget;
};
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_USD_ATTRIBUTE_QUERY_H