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());
        return doc;
    }
 
    void importLibrary(const ConstDocumentPtr& library);
 
    StringSet getReferencedSourceUris() const;
 
 
    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(const NodeGraphPtr nodeGraph, const string& nodeDefName, const string& node, const string& version,
                                   bool isDefaultVersion, const string& nodeGroup, 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();
 
 
  public:
    static const string CATEGORY;
    static const string CMS_ATTRIBUTE;
    static const string CMS_CONFIG_ATTRIBUTE;
 
  private:
    class Cache;
    std::unique_ptr<Cache> _cache;
};
 
MX_CORE_API DocumentPtr createDocument();
 
MATERIALX_NAMESPACE_END
 
#endif