primSpec.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_PRIM_SPEC_H
#define PXR_USD_SDF_PRIM_SPEC_H


#include "pxr/pxr.h"
#include "pxr/usd/sdf/declareSpec.h"
#include "pxr/usd/sdf/spec.h"
#include "pxr/usd/sdf/path.h"
#include "pxr/usd/sdf/payload.h"
#include "pxr/usd/sdf/proxyTypes.h"
#include "pxr/usd/sdf/types.h"
#include "pxr/usd/sdf/api.h"
#include "pxr/base/tf/declarePtrs.h"

#include <iosfwd>
#include <map>
#include <string>
#include <vector>

PXR_NAMESPACE_OPEN_SCOPE

class SdfPrimSpec : public SdfSpec
{
    SDF_DECLARE_SPEC(SdfPrimSpec, SdfSpec);

public:
    typedef SdfPrimSpecView NameChildrenView;
    typedef SdfPropertySpecView PropertySpecView;
    typedef SdfAttributeSpecView AttributeSpecView;
    typedef SdfRelationshipSpecView RelationshipSpecView;


    SDF_API
    static SdfPrimSpecHandle
    New(const SdfLayerHandle& parentLayer,
        const std::string& name, SdfSpecifier spec,
        const std::string& typeName = std::string());

    SDF_API
    static SdfPrimSpecHandle
    New(const SdfPrimSpecHandle& parentPrim,
        const std::string& name, SdfSpecifier spec,
        const std::string& typeName = std::string());


    SDF_API
    const std::string& GetName() const;

    SDF_API
    TfToken GetNameToken() const;

    SDF_API
    bool CanSetName(const std::string& newName, std::string* whyNot) const;

    SDF_API
    bool SetName(const std::string& newName, bool validate = true);

    SDF_API
    static bool IsValidName(const std::string& name);


    SDF_API
    SdfPrimSpecHandle GetNameRoot() const;

    SDF_API
    SdfPrimSpecHandle GetNameParent() const;

    SDF_API
    SdfPrimSpecHandle GetRealNameParent() const;

    SDF_API
    NameChildrenView GetNameChildren() const;

    SDF_API
    void SetNameChildren(const SdfPrimSpecHandleVector&);

    SDF_API
    bool InsertNameChild(const SdfPrimSpecHandle& child, int index = -1);

    SDF_API
    bool RemoveNameChild(const SdfPrimSpecHandle& child);

    SDF_API
    SdfNameChildrenOrderProxy GetNameChildrenOrder() const;

    SDF_API
    bool HasNameChildrenOrder() const;

    SDF_API
    void SetNameChildrenOrder(const std::vector<TfToken>& names);

    SDF_API
    void InsertInNameChildrenOrder(const TfToken& name, int index = -1);

    SDF_API
    void RemoveFromNameChildrenOrder(const TfToken& name);

    SDF_API
    void RemoveFromNameChildrenOrderByIndex(int index);

    SDF_API
    void ApplyNameChildrenOrder(std::vector<TfToken>* vec) const;


    SDF_API
    PropertySpecView GetProperties() const;

    SDF_API
    void SetProperties(const SdfPropertySpecHandleVector&);

    SDF_API
    bool InsertProperty(const SdfPropertySpecHandle& property, int index = -1);

    SDF_API
    void RemoveProperty(const SdfPropertySpecHandle& property);

    SDF_API
    AttributeSpecView GetAttributes() const;

    SDF_API
    RelationshipSpecView GetRelationships() const;

    SDF_API
    SdfPropertyOrderProxy GetPropertyOrder() const;

    SDF_API
    bool HasPropertyOrder() const;

    SDF_API
    void SetPropertyOrder(const std::vector<TfToken>& names);

    SDF_API
    void InsertInPropertyOrder(const TfToken& name, int index = -1);

    SDF_API
    void RemoveFromPropertyOrder(const TfToken& name);

    SDF_API
    void RemoveFromPropertyOrderByIndex(int index);

    SDF_API
    void ApplyPropertyOrder(std::vector<TfToken>* vec) const;


    SDF_API
    SdfSpecHandle GetObjectAtPath(const SdfPath& path) const;

    SDF_API
    SdfPrimSpecHandle GetPrimAtPath(const SdfPath& path) const;

    SDF_API
    SdfPropertySpecHandle GetPropertyAtPath(const SdfPath& path) const;

    SDF_API
    SdfAttributeSpecHandle GetAttributeAtPath(const SdfPath& path) const;

    SDF_API
    SdfRelationshipSpecHandle GetRelationshipAtPath(const SdfPath& path) const;


    SDF_API
    TfToken GetTypeName() const;

    SDF_API
    void SetTypeName(const std::string& value);

    SDF_API
    std::string GetComment() const;

    SDF_API
    void SetComment(const std::string& value);

    SDF_API
    std::string GetDocumentation() const;

    SDF_API
    void SetDocumentation(const std::string& value);

    SDF_API
    bool GetActive() const;

    SDF_API
    void SetActive(bool value);

    SDF_API
    bool HasActive() const;

    SDF_API
    void ClearActive();

    SDF_API
    bool GetHidden() const;

    SDF_API
    void SetHidden( bool value );

    SDF_API
    TfToken GetKind() const;

    SDF_API
    void SetKind(const TfToken& value);

    SDF_API
    bool HasKind() const;

    SDF_API
    void ClearKind();

    SDF_API
    TfToken GetSymmetryFunction() const;

    SDF_API
    void SetSymmetryFunction(const TfToken& functionName);

    SDF_API
    SdfDictionaryProxy GetSymmetryArguments() const;

    SDF_API
    void SetSymmetryArgument(const std::string& name, const VtValue& value);

    SDF_API
    std::string GetSymmetricPeer() const;

    SDF_API
    void SetSymmetricPeer(const std::string& peerName);

    SDF_API
    std::string GetPrefix() const;

    SDF_API
    void SetPrefix(const std::string& value);

    SDF_API
    std::string GetSuffix() const;

    SDF_API
    void SetSuffix(const std::string& value);

    SDF_API
    SdfDictionaryProxy GetCustomData() const;

    SDF_API
    SdfDictionaryProxy GetAssetInfo() const;

    SDF_API
    void SetCustomData(const std::string& name, const VtValue& value);

    SDF_API
    void SetAssetInfo(const std::string& name, const VtValue& value);

    SDF_API
    SdfSpecifier GetSpecifier() const;

    SDF_API
    void SetSpecifier(SdfSpecifier value);

    SDF_API
    SdfPermission GetPermission() const;

    SDF_API
    void SetPermission(SdfPermission value);

    SDF_API
    VtDictionary GetPrefixSubstitutions() const;

    SDF_API
    void SetPrefixSubstitutions(const VtDictionary& prefixSubstitutions);

    SDF_API
    VtDictionary GetSuffixSubstitutions() const;

    SDF_API
    void SetSuffixSubstitutions(const VtDictionary& suffixSubstitutions);

    SDF_API
    void SetInstanceable(bool instanceable);

    SDF_API
    bool GetInstanceable() const;

    SDF_API
    bool HasInstanceable() const;

    SDF_API
    void ClearInstanceable();


    SDF_API
    SdfPayloadsProxy GetPayloadList() const;

    SDF_API
    bool HasPayloads() const;

    SDF_API
    void ClearPayloadList();


    SDF_API
    SdfInheritsProxy GetInheritPathList() const;

    SDF_API
    bool HasInheritPaths() const;

    SDF_API
    void ClearInheritPathList();


    SDF_API
    SdfSpecializesProxy GetSpecializesList() const;

    SDF_API
    bool HasSpecializes() const;

    SDF_API
    void ClearSpecializesList();


    SDF_API
    SdfReferencesProxy GetReferenceList() const;

    SDF_API
    bool HasReferences() const;

    SDF_API
    void ClearReferenceList();


    SDF_API
    SdfVariantSetNamesProxy GetVariantSetNameList() const;

    SDF_API
    bool HasVariantSetNames() const;

    SDF_API
    std::vector<std::string> GetVariantNames(const std::string& name) const;

    SDF_API
    SdfVariantSetsProxy GetVariantSets() const;

    SDF_API
    void RemoveVariantSet(const std::string& name);

    SDF_API
    SdfVariantSelectionProxy GetVariantSelections() const;

    SDF_API
    void SetVariantSelection(const std::string& variantSetName,
                             const std::string& variantName);

    SDF_API
    void BlockVariantSelection(const std::string& variantSetName);


    SDF_API
    SdfRelocatesMapProxy GetRelocates() const;
    
    SDF_API
    void SetRelocates(const SdfRelocatesMap& newMap);

    SDF_API
    bool HasRelocates() const;
    
    SDF_API
    void ClearRelocates();


private:
    // Returns true if this object is the pseudo-root.
    bool _IsPseudoRoot() const;

    // Raises an error and returns false if this is the pseudo-root,
    // otherwise returns true.  We want to allow clients to be able
    // to use pseudo-roots as any other prim in namespace editing
    // operations as well as silently permit read accesses on fields
    // pseudo-roots don't actually have in order to promote generic
    // algorithm programming.  Mutating methods on SdfPrimSpec use
    // this function as write access validation.
    bool _ValidateEdit(const TfToken& key) const;

private:
    static SdfPrimSpecHandle
    _New(const SdfPrimSpecHandle &parentPrim,
         const TfToken &name, SdfSpecifier spec,
         const TfToken &typeName);
};

SDF_API 
SdfPrimSpecHandle SdfCreatePrimInLayer(const SdfLayerHandle& layer,
                                       const SdfPath& primPath);


SDF_API 
bool SdfJustCreatePrimInLayer(const SdfLayerHandle& layer,
                              const SdfPath& primPath);

PXR_NAMESPACE_CLOSE_SCOPE

#endif // PXR_USD_SDF_PRIM_SPEC_H