spec.h

Go to the documentation of this file.

//
// Copyright 2016 Pixar
//
// Licensed under the Apache License, Version 2.0 (the "Apache License")
// with the following modification; you may not use this file except in
// compliance with the Apache License and the following modification to it:
// Section 6. Trademarks. is deleted and replaced with:
//
// 6. Trademarks. This License does not grant permission to use the trade
//    names, trademarks, service marks, or product names of the Licensor
//    and its affiliates, except as required to comply with Section 4(c) of
//    the License and to reproduce the content of the NOTICE file.
//
// You may obtain a copy of the Apache License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the Apache License with the above modification is
// distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, either express or implied. See the Apache License for the specific
// language governing permissions and limitations under the Apache 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 <boost/type_traits/is_base_of.hpp>
#include <boost/utility/enable_if.hpp>

#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