spec.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_SDF_SPEC_H
#define PXR_USD_SDF_SPEC_H
 
 
#include "pxr/pxr.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/usd/sdf/abstractData.h"
#include "pxr/usd/sdf/identity.h"
#include "pxr/usd/sdf/declareSpec.h"
#include "pxr/usd/sdf/schema.h"
#include "pxr/usd/sdf/types.h"
#include "pxr/base/vt/value.h"
#include "pxr/base/tf/hash.h"
#include "pxr/base/tf/token.h"
#include "pxr/base/tf/type.h"
 
#include <iosfwd>
 
PXR_NAMESPACE_OPEN_SCOPE
 
class SdfSpec 
{
    SDF_DECLARE_BASE_SPEC(SdfSpec);
 
public:
    SDF_API
    SdfSpec &operator=(const SdfSpec &other);
 
    SDF_API
    ~SdfSpec();
 
 
    SDF_API
    const SdfSchemaBase& GetSchema() const;
 
    SDF_API
    SdfSpecType GetSpecType() const;
 
    SDF_API
    bool IsDormant() const;
 
    SDF_API
    SdfLayerHandle GetLayer() const;
 
    SDF_API
    SdfPath GetPath() const;
 
    SDF_API
    bool PermissionToEdit() const;
 
    SDF_API
    std::vector<TfToken> ListInfoKeys() const;
 
    SDF_API
    std::vector<TfToken> GetMetaDataInfoKeys() const;
 
    SDF_API
    TfToken GetMetaDataDisplayGroup(TfToken const &key) const;
 
    SDF_API
    VtValue GetInfo(const TfToken &key) const;
 
    SDF_API
    void SetInfo(const TfToken &key, const VtValue &value);
 
    SDF_API
    void SetInfoDictionaryValue(const TfToken &dictionaryKey, 
                                const TfToken &entryKey, const VtValue &value);
 
    SDF_API
    bool HasInfo(const TfToken &key) const;
 
    SDF_API
    void ClearInfo(const TfToken &key);
 
    SDF_API
    TfType GetTypeForInfo(const TfToken &key) const;
 
    SDF_API
    const VtValue& GetFallbackForInfo(const TfToken &key) const;
 
    SDF_API
    bool WriteToStream(std::ostream&, size_t indent = 0) const;
 
    SDF_API
    bool IsInert(bool ignoreChildren = false) const;
 
 
 
    SDF_API
    std::vector<TfToken> ListFields() const;
 
    SDF_API
    bool HasField(const TfToken &name) const;
 
    template <class T>
    bool HasField(const TfToken &name, T* value) const
    {
        if (!value) {
            return HasField(name);
        }
        
        SdfAbstractDataTypedValue<T> outValue(value);
        return _HasField(name, &outValue);
    }
 
    SDF_API
    VtValue GetField(const TfToken &name) const;
 
    template <typename T>
    T GetFieldAs(const TfToken & name, const T& defaultValue = T()) const
    {
        VtValue v = GetField(name);
        if (v.IsEmpty() || !v.IsHolding<T>())
            return defaultValue;
        return v.UncheckedGet<T>();
    }
 
    SDF_API
    bool SetField(const TfToken & name, const VtValue& value);
 
    template <typename T>
    bool SetField(const TfToken & name, const T& value)
    {
        return SetField(name, VtValue(value));
    }
 
    SDF_API
    bool ClearField(const TfToken & name);
 
 
 
    SDF_API bool operator==(const SdfSpec& rhs) const;
    SDF_API bool operator<(const SdfSpec& rhs) const;
 
 
    template <class HashState>
    friend void TfHashAppend(HashState &h, const SdfSpec& x);
 
private:
    SDF_API
    bool _HasField(const TfToken& name, SdfAbstractDataValue* value) const;
 
protected:
    bool _MoveSpec(const SdfPath &oldPath, const SdfPath &newPath) const;
    bool _DeleteSpec(const SdfPath &path);
 
private:
    Sdf_IdentityRefPtr _id;
};
 
template <class HashState>
void TfHashAppend(HashState &h, const SdfSpec& x) {
    h.Append(x._id.get());
}
 
inline size_t hash_value(const SdfSpec &x) {
    return TfHash()(x);
}
 
PXR_NAMESPACE_CLOSE_SCOPE
 
#endif // PXR_USD_SDF_SPEC_H