Document.h

Go to the documentation of this file.

//
// Copyright Contributors to the MaterialX Project
// SPDX-License-Identifier: Apache-2.0
//
 
#ifndef MATERIALX_DOCUMENT
#define MATERIALX_DOCUMENT

 
#include <MaterialXCore/Export.h>
 
#include <MaterialXCore/Look.h>
#include <MaterialXCore/Node.h>
 
MATERIALX_NAMESPACE_BEGIN
 
class Document;

using DocumentPtr = shared_ptr<Document>;
using ConstDocumentPtr = shared_ptr<const Document>;

class MX_CORE_API Document : public GraphElement
{
  public:
    Document(ElementPtr parent, const string& name);
    virtual ~Document();

    template <class T> static shared_ptr<T> createDocument()
    {
        shared_ptr<T> doc = std::make_shared<T>(ElementPtr(), EMPTY_STRING);
        doc->initialize();
        return doc;
    }

    virtual void initialize();

    virtual DocumentPtr copy() const
    {
        DocumentPtr doc = createDocument<Document>();
        doc->copyContentFrom(getSelf());
        doc->setDataLibrary(getDataLibrary());
        return doc;
    }

    StringSet getReferencedSourceUris() const;


    void setDataLibrary(ConstDocumentPtr dataLibrary)
    {
        _dataLibrary = dataLibrary;
    }

    bool hasDataLibrary() const
    {
        return (_dataLibrary != nullptr);
    }

    ConstDocumentPtr getDataLibrary() const
    {
        return _dataLibrary;
    }

    void importLibrary(const ConstDocumentPtr& library);


    NodeGraphPtr addNodeGraph(const string& name = EMPTY_STRING)
    {
        return addChild<NodeGraph>(name);
    }

    NodeGraphPtr getNodeGraph(const string& name) const
    {
        return getChildOfType<NodeGraph>(name);
    }

    vector<NodeGraphPtr> getNodeGraphs() const
    {
        return getChildrenOfType<NodeGraph>();
    }

    void removeNodeGraph(const string& name)
    {
        removeChildOfType<NodeGraph>(name);
    }

    vector<PortElementPtr> getMatchingPorts(const string& nodeName) const;


    GeomInfoPtr addGeomInfo(const string& name = EMPTY_STRING, const string& geom = UNIVERSAL_GEOM_NAME)
    {
        GeomInfoPtr geomInfo = addChild<GeomInfo>(name);
        geomInfo->setGeom(geom);
        return geomInfo;
    }

    GeomInfoPtr getGeomInfo(const string& name) const
    {
        return getChildOfType<GeomInfo>(name);
    }

    vector<GeomInfoPtr> getGeomInfos() const
    {
        return getChildrenOfType<GeomInfo>();
    }

    void removeGeomInfo(const string& name)
    {
        removeChildOfType<GeomInfo>(name);
    }

    ValuePtr getGeomPropValue(const string& geomPropName, const string& geom = UNIVERSAL_GEOM_NAME) const;


    GeomPropDefPtr addGeomPropDef(const string& name, const string& geomprop)
    {
        GeomPropDefPtr geomPropDef = addChild<GeomPropDef>(name);
        geomPropDef->setGeomProp(geomprop);
        return geomPropDef;
    }

    GeomPropDefPtr getGeomPropDef(const string& name) const
    {
        return getChildOfType<GeomPropDef>(name);
    }

    vector<GeomPropDefPtr> getGeomPropDefs() const
    {
        return getChildrenOfType<GeomPropDef>();
    }

    void removeGeomPropDef(const string& name)
    {
        removeChildOfType<GeomPropDef>(name);
    }


    vector<OutputPtr> getMaterialOutputs() const;


    LookPtr addLook(const string& name = EMPTY_STRING)
    {
        return addChild<Look>(name);
    }

    LookPtr getLook(const string& name) const
    {
        return getChildOfType<Look>(name);
    }

    vector<LookPtr> getLooks() const
    {
        return getChildrenOfType<Look>();
    }

    void removeLook(const string& name)
    {
        removeChildOfType<Look>(name);
    }


    LookGroupPtr addLookGroup(const string& name = EMPTY_STRING)
    {
        return addChild<LookGroup>(name);
    }

    LookGroupPtr getLookGroup(const string& name) const
    {
        return getChildOfType<LookGroup>(name);
    }

    vector<LookGroupPtr> getLookGroups() const
    {
        return getChildrenOfType<LookGroup>();
    }

    void removeLookGroup(const string& name)
    {
        removeChildOfType<LookGroup>(name);
    }


    CollectionPtr addCollection(const string& name = EMPTY_STRING)
    {
        return addChild<Collection>(name);
    }

    CollectionPtr getCollection(const string& name) const
    {
        return getChildOfType<Collection>(name);
    }

    vector<CollectionPtr> getCollections() const
    {
        return getChildrenOfType<Collection>();
    }

    void removeCollection(const string& name)
    {
        removeChildOfType<Collection>(name);
    }


    TypeDefPtr addTypeDef(const string& name)
    {
        return addChild<TypeDef>(name);
    }

    TypeDefPtr getTypeDef(const string& name) const
    {
        return getChildOfType<TypeDef>(name);
    }

    vector<TypeDefPtr> getTypeDefs() const
    {
        return getChildrenOfType<TypeDef>();
    }

    void removeTypeDef(const string& name)
    {
        removeChildOfType<TypeDef>(name);
    }


    NodeDefPtr addNodeDef(const string& name = EMPTY_STRING,
                          const string& type = DEFAULT_TYPE_STRING,
                          const string& node = EMPTY_STRING)
    {
        NodeDefPtr child = addChild<NodeDef>(name);
        if (!type.empty() && type != MULTI_OUTPUT_TYPE_STRING)
        {
            child->addOutput("out", type);
        }
        if (!node.empty())
        {
            child->setNodeString(node);
        }
        return child;
    }

    NodeDefPtr addNodeDefFromGraph(NodeGraphPtr nodeGraph, const string& nodeDefName,
                                   const string& category, const string& newGraphName);

    NodeDefPtr getNodeDef(const string& name) const
    {
        return getChildOfType<NodeDef>(name);
    }

    vector<NodeDefPtr> getNodeDefs() const
    {
        return getChildrenOfType<NodeDef>();
    }

    void removeNodeDef(const string& name)
    {
        removeChildOfType<NodeDef>(name);
    }

    vector<NodeDefPtr> getMatchingNodeDefs(const string& nodeName) const;


    AttributeDefPtr addAttributeDef(const string& name = EMPTY_STRING)
    {
        return addChild<AttributeDef>(name);
    }

    AttributeDefPtr getAttributeDef(const string& name) const
    {
        return getChildOfType<AttributeDef>(name);
    }

    vector<AttributeDefPtr> getAttributeDefs() const
    {
        return getChildrenOfType<AttributeDef>();
    }

    void removeAttributeDef(const string& name)
    {
        removeChildOfType<AttributeDef>(name);
    }


    TargetDefPtr addTargetDef(const string& name = EMPTY_STRING)
    {
        return addChild<TargetDef>(name);
    }

    TargetDefPtr getTargetDef(const string& name) const
    {
        return getChildOfType<TargetDef>(name);
    }

    vector<TargetDefPtr> getTargetDefs() const
    {
        return getChildrenOfType<TargetDef>();
    }

    void removeTargetDef(const string& name)
    {
        removeChildOfType<TargetDef>(name);
    }


    PropertySetPtr addPropertySet(const string& name = EMPTY_STRING)
    {
        return addChild<PropertySet>(name);
    }

    PropertySetPtr getPropertySet(const string& name) const
    {
        return getChildOfType<PropertySet>(name);
    }

    vector<PropertySetPtr> getPropertySets() const
    {
        return getChildrenOfType<PropertySet>();
    }

    void removePropertySet(const string& name)
    {
        removeChildOfType<PropertySet>(name);
    }


    VariantSetPtr addVariantSet(const string& name = EMPTY_STRING)
    {
        return addChild<VariantSet>(name);
    }

    VariantSetPtr getVariantSet(const string& name) const
    {
        return getChildOfType<VariantSet>(name);
    }

    vector<VariantSetPtr> getVariantSets() const
    {
        return getChildrenOfType<VariantSet>();
    }

    void removeVariantSet(const string& name)
    {
        removeChildOfType<VariantSet>(name);
    }


    ImplementationPtr addImplementation(const string& name = EMPTY_STRING)
    {
        return addChild<Implementation>(name);
    }

    ImplementationPtr getImplementation(const string& name) const
    {
        return getChildOfType<Implementation>(name);
    }

    vector<ImplementationPtr> getImplementations() const
    {
        return getChildrenOfType<Implementation>();
    }

    void removeImplementation(const string& name)
    {
        removeChildOfType<Implementation>(name);
    }

    vector<InterfaceElementPtr> getMatchingImplementations(const string& nodeDef) const;

 
    UnitDefPtr addUnitDef(const string& name)
    {
        if (name.empty())
        {
            throw Exception("A unit definition name cannot be empty");
        }
        return addChild<UnitDef>(name);
    }

    UnitDefPtr getUnitDef(const string& name) const
    {
        return getChildOfType<UnitDef>(name);
    }

    vector<UnitDefPtr> getUnitDefs() const
    {
        return getChildrenOfType<UnitDef>();
    }

    void removeUnitDef(const string& name)
    {
        removeChildOfType<UnitDef>(name);
    }

 
    UnitTypeDefPtr addUnitTypeDef(const string& name)
    {
        if (name.empty())
        {
            throw Exception("A unit type definition name cannot be empty");
        }
        return addChild<UnitTypeDef>(name);
    }

    UnitTypeDefPtr getUnitTypeDef(const string& name) const
    {
        return getChildOfType<UnitTypeDef>(name);
    }

    vector<UnitTypeDefPtr> getUnitTypeDefs() const
    {
        return getChildrenOfType<UnitTypeDef>();
    }

    void removeUnitTypeDef(const string& name)
    {
        removeChildOfType<UnitTypeDef>(name);
    }


    std::pair<int, int> getVersionIntegers() const override;

    void upgradeVersion();


    void setColorManagementSystem(const string& cms)
    {
        setAttribute(CMS_ATTRIBUTE, cms);
    }

    bool hasColorManagementSystem() const
    {
        return hasAttribute(CMS_ATTRIBUTE);
    }

    const string& getColorManagementSystem() const
    {
        return getAttribute(CMS_ATTRIBUTE);
    }


    void setColorManagementConfig(const string& cmsConfig)
    {
        setAttribute(CMS_CONFIG_ATTRIBUTE, cmsConfig);
    }

    bool hasColorManagementConfig() const
    {
        return hasAttribute(CMS_CONFIG_ATTRIBUTE);
    }

    const string& getColorManagementConfig() const
    {
        return getAttribute(CMS_CONFIG_ATTRIBUTE);
    }


    bool validate(string* message = nullptr) const override;


    void invalidateCache();

 
    //
    // These are deprecated wrappers for older versions of the function interfaces in this module.
    // Clients using these interfaces should update them to the latest API.
    //
    [[deprecated]] NodeDefPtr addNodeDefFromGraph(NodeGraphPtr nodeGraph, const string& nodeDefName, const string& node, const string& version,
                                                  bool isDefaultVersion, const string& nodeGroup, const string& newGraphName);
 
  public:
    static const string CATEGORY;
    static const string CMS_ATTRIBUTE;
    static const string CMS_CONFIG_ATTRIBUTE;
 
  private:
    class Cache;
 
  private:
    ConstDocumentPtr _dataLibrary;
    std::unique_ptr<Cache> _cache;
};

MX_CORE_API DocumentPtr createDocument();
 
MATERIALX_NAMESPACE_END
 
#endif