MaterialX 1.38.8
Loading...
Searching...
No Matches
Element.h
Go to the documentation of this file.
1//
2// Copyright Contributors to the MaterialX Project
3// SPDX-License-Identifier: Apache-2.0
4//
5
6#ifndef MATERIALX_ELEMENT_H
7#define MATERIALX_ELEMENT_H
8
11
13
15#include <MaterialXCore/Util.h>
16#include <MaterialXCore/Value.h>
17
18MATERIALX_NAMESPACE_BEGIN
19
20class Element;
21class TypedElement;
22class ValueElement;
23class Token;
24class CommentElement;
25class NewlineElement;
26class GenericElement;
27class StringResolver;
28class Document;
29
31using ElementPtr = shared_ptr<Element>;
33using ConstElementPtr = shared_ptr<const Element>;
34
36using TypedElementPtr = shared_ptr<TypedElement>;
38using ConstTypedElementPtr = shared_ptr<const TypedElement>;
39
41using ValueElementPtr = shared_ptr<ValueElement>;
43using ConstValueElementPtr = shared_ptr<const ValueElement>;
44
46using TokenPtr = shared_ptr<Token>;
48using ConstTokenPtr = shared_ptr<const Token>;
49
51using CommentElementPtr = shared_ptr<CommentElement>;
53using ConstCommentElementPtr = shared_ptr<const CommentElement>;
54
56using NewlineElementPtr = shared_ptr<NewlineElement>;
58using ConstNewlineElementPtr = shared_ptr<const NewlineElement>;
59
61using GenericElementPtr = shared_ptr<GenericElement>;
63using ConstGenericElementPtr = shared_ptr<const GenericElement>;
64
66using StringResolverPtr = shared_ptr<StringResolver>;
67
69using ElementMap = std::unordered_map<string, ElementPtr>;
70
72using ElementPredicate = std::function<bool(ConstElementPtr)>;
73
79class MX_CORE_API Element : public std::enable_shared_from_this<Element>
80{
81 protected:
82 Element(ElementPtr parent, const string& category, const string& name) :
83 _category(category),
84 _name(name),
85 _parent(parent),
86 _root(parent ? parent->getRoot() : nullptr)
87 {
88 }
89
90 public:
91 virtual ~Element() { }
92 Element(const Element&) = delete;
93 Element& operator=(const Element&) = delete;
94
95 protected:
96 using DocumentPtr = shared_ptr<Document>;
97 using ConstDocumentPtr = shared_ptr<const Document>;
98
99 template <class T> friend class ElementRegistry;
100
101 public:
104 bool operator==(const Element& rhs) const;
105
108 bool operator!=(const Element& rhs) const;
109
112
114 void setCategory(const string& category)
115 {
116 _category = category;
117 }
118
122 const string& getCategory() const
123 {
124 return _category;
125 }
126
130
135 void setName(const string& name);
136
138 const string& getName() const
139 {
140 return _name;
141 }
142
148 string getNamePath(ConstElementPtr relativeTo = nullptr) const;
149
155 ElementPtr getDescendant(const string& namePath) const;
156
160
162 void setFilePrefix(const string& prefix)
163 {
164 setAttribute(FILE_PREFIX_ATTRIBUTE, prefix);
165 }
166
168 bool hasFilePrefix() const
169 {
170 return hasAttribute(FILE_PREFIX_ATTRIBUTE);
171 }
172
174 const string& getFilePrefix() const
175 {
176 return getAttribute(FILE_PREFIX_ATTRIBUTE);
177 }
178
181 const string& getActiveFilePrefix() const
182 {
183 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
184 {
185 if (elem->hasFilePrefix())
186 {
187 return elem->getFilePrefix();
188 }
189 }
190 return EMPTY_STRING;
191 }
192
196
198 void setGeomPrefix(const string& prefix)
199 {
200 setAttribute(GEOM_PREFIX_ATTRIBUTE, prefix);
201 }
202
204 bool hasGeomPrefix() const
205 {
206 return hasAttribute(GEOM_PREFIX_ATTRIBUTE);
207 }
208
210 const string& getGeomPrefix() const
211 {
212 return getAttribute(GEOM_PREFIX_ATTRIBUTE);
213 }
214
217 const string& getActiveGeomPrefix() const
218 {
219 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
220 {
221 if (elem->hasGeomPrefix())
222 {
223 return elem->getGeomPrefix();
224 }
225 }
226 return EMPTY_STRING;
227 }
228
232
234 void setColorSpace(const string& colorSpace)
235 {
236 setAttribute(COLOR_SPACE_ATTRIBUTE, colorSpace);
237 }
238
240 bool hasColorSpace() const
241 {
242 return hasAttribute(COLOR_SPACE_ATTRIBUTE);
243 }
244
246 const string& getColorSpace() const
247 {
248 return getAttribute(COLOR_SPACE_ATTRIBUTE);
249 }
250
253 const string& getActiveColorSpace() const
254 {
255 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
256 {
257 if (elem->hasColorSpace())
258 {
259 return elem->getColorSpace();
260 }
261 }
262 return EMPTY_STRING;
263 }
264
268
270 void setInheritString(const string& inherit)
271 {
272 setAttribute(INHERIT_ATTRIBUTE, inherit);
273 }
274
276 bool hasInheritString() const
277 {
278 return hasAttribute(INHERIT_ATTRIBUTE);
279 }
280
282 const string& getInheritString() const
283 {
284 return getAttribute(INHERIT_ATTRIBUTE);
285 }
286
289 {
290 if (super)
291 {
292 setInheritString(super->getName());
293 }
294 else
295 {
296 removeAttribute(INHERIT_ATTRIBUTE);
297 }
298 }
299
302 {
303 return hasInheritString() ? resolveNameReference<Element>(getInheritString()) : nullptr;
304 }
305
308 bool hasInheritedBase(ConstElementPtr base) const;
309
311 bool hasInheritanceCycle() const;
312
316
318 void setNamespace(const string& space)
319 {
320 setAttribute(NAMESPACE_ATTRIBUTE, space);
321 }
322
324 bool hasNamespace() const
325 {
326 return hasAttribute(NAMESPACE_ATTRIBUTE);
327 }
328
330 const string& getNamespace() const
331 {
332 return getAttribute(NAMESPACE_ATTRIBUTE);
333 }
334
337 string getQualifiedName(const string& name) const
338 {
339 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
340 {
341 const string& namespaceStr = elem->getNamespace();
342 if (!namespaceStr.empty())
343 {
344 // Check if the name is qualified already.
345 const size_t i = name.find_first_of(NAME_PREFIX_SEPARATOR);
346 if (i != string::npos && name.substr(0, i) == namespaceStr)
347 {
348 // The name is already qualified with this namespace,
349 // so just return it as is.
350 return name;
351 }
352 return namespaceStr + NAME_PREFIX_SEPARATOR + name;
353 }
354 }
355 return name;
356 }
357
361
363 void setDocString(const string& doc)
364 {
365 setAttribute(DOC_ATTRIBUTE, doc);
366 }
367
369 string getDocString() const
370 {
371 return getAttribute(DOC_ATTRIBUTE);
372 }
373
377
381 template <class T> bool isA(const string& category = EMPTY_STRING) const
382 {
383 if (!asA<T>())
384 return false;
385 if (!category.empty() && getCategory() != category)
386 return false;
387 return true;
388 }
389
391 template <class T> shared_ptr<T> asA();
392
394 template <class T> shared_ptr<const T> asA() const;
395
399
407 template <class T> shared_ptr<T> addChild(const string& name = EMPTY_STRING);
408
419 ElementPtr addChildOfCategory(const string& category, string name = EMPTY_STRING);
420
426 ElementPtr changeChildCategory(ElementPtr child, const string& category);
427
429 ElementPtr getChild(const string& name) const
430 {
431 ElementMap::const_iterator it = _childMap.find(name);
432 return (it != _childMap.end()) ? it->second : ElementPtr();
433 }
434
438 template <class T> shared_ptr<T> getChildOfType(const string& name) const
439 {
440 ElementPtr child = getChild(name);
441 return child ? child->asA<T>() : shared_ptr<T>();
442 }
443
446 const vector<ElementPtr>& getChildren() const
447 {
448 return _childOrder;
449 }
450
454 template <class T> vector<shared_ptr<T>> getChildrenOfType(const string& category = EMPTY_STRING) const
455 {
456 vector<shared_ptr<T>> children;
457 for (ElementPtr child : _childOrder)
458 {
459 shared_ptr<T> instance = child->asA<T>();
460 if (!instance)
461 continue;
462 if (!category.empty() && child->getCategory() != category)
463 continue;
464 children.push_back(instance);
465 }
466 return children;
467 }
468
471 void setChildIndex(const string& name, int index);
472
475 int getChildIndex(const string& name) const;
476
478 void removeChild(const string& name);
479
483 template <class T> void removeChildOfType(const string& name)
484 {
485 if (getChildOfType<T>(name))
486 removeChild(name);
487 }
488
492
494 void setAttribute(const string& attrib, const string& value);
495
497 bool hasAttribute(const string& attrib) const
498 {
499 return _attributeMap.count(attrib) != 0;
500 }
501
504 const string& getAttribute(const string& attrib) const
505 {
506 StringMap::const_iterator it = _attributeMap.find(attrib);
507 return (it != _attributeMap.end()) ? it->second : EMPTY_STRING;
508 }
509
512 {
513 return _attributeOrder;
514 }
515
519 template <class T> void setTypedAttribute(const string& attrib, const T& data)
520 {
521 setAttribute(attrib, toValueString(data));
522 }
523
527 template <class T> T getTypedAttribute(const string& attrib) const
528 {
529 if (hasAttribute(attrib))
530 {
531 try
532 {
533 return fromValueString<T>(getAttribute(attrib));
534 }
535 catch (ExceptionTypeError&)
536 {
537 }
538 }
539 return {};
540 }
541
543 void removeAttribute(const string& attrib);
544
548
551 {
552 return shared_from_this();
553 }
554
557 {
558 return shared_from_this();
559 }
560
563 {
564 return _parent.lock();
565 }
566
569 {
570 return _parent.lock();
571 }
572
574 ElementPtr getRoot();
575
577 ConstElementPtr getRoot() const;
578
580 DocumentPtr getDocument();
581
583 ConstDocumentPtr getDocument() const;
584
587 template <class T> shared_ptr<const T> getAncestorOfType() const
588 {
589 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
590 {
591 shared_ptr<const T> typedElem = elem->asA<T>();
592 if (typedElem)
593 {
594 return typedElem;
595 }
596 }
597 return nullptr;
598 }
599
603
622 TreeIterator traverseTree() const;
623
647 GraphIterator traverseGraph() const;
648
654 virtual Edge getUpstreamEdge(size_t index = 0) const;
655
657 virtual size_t getUpstreamEdgeCount() const
658 {
659 return 0;
660 }
661
667 ElementPtr getUpstreamElement(size_t index = 0) const;
668
683 InheritanceIterator traverseInheritance() const;
684
688
694 void setSourceUri(const string& sourceUri)
695 {
696 _sourceUri = sourceUri;
697 }
698
700 bool hasSourceUri() const
701 {
702 return !_sourceUri.empty();
703 }
704
706 const string& getSourceUri() const
707 {
708 return _sourceUri;
709 }
710
713 const string& getActiveSourceUri() const
714 {
715 for (ConstElementPtr elem = getSelf(); elem; elem = elem->getParent())
716 {
717 if (elem->hasSourceUri())
718 {
719 return elem->getSourceUri();
720 }
721 }
722 return EMPTY_STRING;
723 }
724
728
731 virtual bool validate(string* message = nullptr) const;
732
736
739 void copyContentFrom(const ConstElementPtr& source);
740
742 virtual void clearContent();
743
746 string createValidChildName(string name) const
747 {
748 name = name.empty() ? "_" : createValidName(name);
749 while (_childMap.count(name))
750 {
751 name = incrementName(name);
752 }
753 return name;
754 }
755
764 StringResolverPtr createStringResolver(const string& geom = EMPTY_STRING) const;
765
768 string asString() const;
769
771
772 protected:
773 // Resolve a reference to a named element at the scope of the given parent,
774 // taking the namespace at the scope of this element into account. If no parent
775 // is provided, then the root scope of the document is used.
776 template <class T> shared_ptr<T> resolveNameReference(const string& name, ConstElementPtr parent = nullptr) const
777 {
778 ConstElementPtr scope = parent ? parent : getRoot();
779 shared_ptr<T> child = scope->getChildOfType<T>(getQualifiedName(name));
780 return child ? child : scope->getChildOfType<T>(name);
781 }
782
783 // Enforce a requirement within a validate method, updating the validation
784 // state and optional output text if the requirement is not met.
785 void validateRequire(bool expression, bool& res, string* message, const string& errorDesc) const;
786
787 public:
788 static const string NAME_ATTRIBUTE;
789 static const string FILE_PREFIX_ATTRIBUTE;
790 static const string GEOM_PREFIX_ATTRIBUTE;
791 static const string COLOR_SPACE_ATTRIBUTE;
792 static const string INHERIT_ATTRIBUTE;
793 static const string NAMESPACE_ATTRIBUTE;
794 static const string DOC_ATTRIBUTE;
795
796 protected:
797 virtual void registerChildElement(ElementPtr child);
798 virtual void unregisterChildElement(ElementPtr child);
799
800 // Return a non-const copy of our self pointer, for use in constructing
801 // graph traversal objects that require non-const storage.
802 ElementPtr getSelfNonConst() const
803 {
804 return std::const_pointer_cast<Element>(shared_from_this());
805 }
806
807 protected:
808 string _category;
809 string _name;
810 string _sourceUri;
811
812 ElementMap _childMap;
813 vector<ElementPtr> _childOrder;
814
815 StringMap _attributeMap;
816 StringVec _attributeOrder;
817
818 weak_ptr<Element> _parent;
819 weak_ptr<Element> _root;
820
821 private:
822 template <class T> static ElementPtr createElement(ElementPtr parent, const string& name)
823 {
824 return std::make_shared<T>(parent, name);
825 }
826
827 private:
828 using CreatorFunction = ElementPtr (*)(ElementPtr, const string&);
829 using CreatorMap = std::unordered_map<string, CreatorFunction>;
830
831 static CreatorMap _creatorMap;
832};
833
836class MX_CORE_API TypedElement : public Element
837{
838 protected:
839 TypedElement(ElementPtr parent, const string& category, const string& name) :
840 Element(parent, category, name)
841 {
842 }
843
844 public:
845 virtual ~TypedElement() { }
846
847 protected:
848 using TypeDefPtr = shared_ptr<class TypeDef>;
849
850 public:
853
855 void setType(const string& type)
856 {
857 setAttribute(TYPE_ATTRIBUTE, type);
858 }
859
861 bool hasType() const
862 {
863 return hasAttribute(TYPE_ATTRIBUTE);
864 }
865
867 virtual const string& getType() const
868 {
869 return getAttribute(TYPE_ATTRIBUTE);
870 }
871
873 bool isMultiOutputType() const
874 {
875 return getType() == MULTI_OUTPUT_TYPE_STRING;
876 }
877
881
884 TypeDefPtr getTypeDef() const;
885
887
888 public:
889 static const string TYPE_ATTRIBUTE;
890};
891
894class MX_CORE_API ValueElement : public TypedElement
895{
896 protected:
897 ValueElement(ElementPtr parent, const string& category, const string& name) :
898 TypedElement(parent, category, name)
899 {
900 }
901
902 public:
903 virtual ~ValueElement() { }
904
907
909 void setValueString(const string& value)
910 {
911 setAttribute(VALUE_ATTRIBUTE, value);
912 }
913
915 bool hasValueString() const
916 {
917 return hasAttribute(VALUE_ATTRIBUTE);
918 }
919
921 const string& getValueString() const
922 {
923 return getAttribute(VALUE_ATTRIBUTE);
924 }
925
931 string getResolvedValueString(StringResolverPtr resolver = nullptr) const;
932
936
938 void setInterfaceName(const string& name)
939 {
940 setAttribute(INTERFACE_NAME_ATTRIBUTE, name);
941 }
942
944 bool hasInterfaceName() const
945 {
946 return hasAttribute(INTERFACE_NAME_ATTRIBUTE);
947 }
948
950 const string& getInterfaceName() const
951 {
952 return getAttribute(INTERFACE_NAME_ATTRIBUTE);
953 }
954
958
960 void setImplementationName(const string& name)
961 {
962 setAttribute(IMPLEMENTATION_NAME_ATTRIBUTE, name);
963 }
964
967 {
968 return hasAttribute(IMPLEMENTATION_NAME_ATTRIBUTE);
969 }
970
972 const string& getImplementationName() const
973 {
974 return getAttribute(IMPLEMENTATION_NAME_ATTRIBUTE);
975 }
976
980
982 template <class T> void setValue(const T& value, const string& type = EMPTY_STRING)
983 {
984 setType(!type.empty() ? type : getTypeString<T>());
985 setValueString(toValueString(value));
986 }
987
989 void setValue(const char* value, const string& type = EMPTY_STRING)
990 {
991 setValue(value ? string(value) : EMPTY_STRING, type);
992 }
993
995 bool hasValue() const
996 {
997 return hasAttribute(VALUE_ATTRIBUTE);
998 }
999
1006 {
1007 if (!hasValue())
1008 return ValuePtr();
1009 return Value::createValueFromStrings(getValueString(), getType());
1010 }
1011
1021 {
1022 if (!hasValue())
1023 return ValuePtr();
1024 return Value::createValueFromStrings(getResolvedValueString(resolver), getType());
1025 }
1026
1032 ValuePtr getDefaultValue() const;
1033
1037
1039 void setUnit(const string& unit)
1040 {
1041 setAttribute(UNIT_ATTRIBUTE, unit);
1042 }
1043
1045 bool hasUnit() const
1046 {
1047 return hasAttribute(UNIT_ATTRIBUTE);
1048 }
1049
1051 const string& getUnit() const
1052 {
1053 return getAttribute(UNIT_ATTRIBUTE);
1054 }
1055
1058 const string& getActiveUnit() const;
1059
1061 void setUnitType(const string& unit)
1062 {
1063 setAttribute(UNITTYPE_ATTRIBUTE, unit);
1064 }
1065
1067 bool hasUnitType() const
1068 {
1069 return hasAttribute(UNITTYPE_ATTRIBUTE);
1070 }
1071
1073 const string& getUnitType() const
1074 {
1075 return getAttribute(UNITTYPE_ATTRIBUTE);
1076 }
1077
1081
1083 void setIsUniform(bool value)
1084 {
1085 setTypedAttribute<bool>(UNIFORM_ATTRIBUTE, value);
1086 }
1087
1089 bool getIsUniform() const
1090 {
1091 return getTypedAttribute<bool>(UNIFORM_ATTRIBUTE);
1092 }
1093
1097
1100 bool validate(string* message = nullptr) const override;
1101
1103
1104 public:
1105 static const string VALUE_ATTRIBUTE;
1106 static const string INTERFACE_NAME_ATTRIBUTE;
1107 static const string IMPLEMENTATION_NAME_ATTRIBUTE;
1108 static const string IMPLEMENTATION_TYPE_ATTRIBUTE;
1109 static const string ENUM_ATTRIBUTE;
1110 static const string ENUM_VALUES_ATTRIBUTE;
1111 static const string UI_NAME_ATTRIBUTE;
1112 static const string UI_FOLDER_ATTRIBUTE;
1113 static const string UI_MIN_ATTRIBUTE;
1114 static const string UI_MAX_ATTRIBUTE;
1115 static const string UI_SOFT_MIN_ATTRIBUTE;
1116 static const string UI_SOFT_MAX_ATTRIBUTE;
1117 static const string UI_STEP_ATTRIBUTE;
1118 static const string UI_ADVANCED_ATTRIBUTE;
1119 static const string UNIT_ATTRIBUTE;
1120 static const string UNITTYPE_ATTRIBUTE;
1121 static const string UNIFORM_ATTRIBUTE;
1122};
1123
1129class MX_CORE_API Token : public ValueElement
1130{
1131 public:
1132 Token(ElementPtr parent, const string& name) :
1133 ValueElement(parent, CATEGORY, name)
1134 {
1135 }
1136 virtual ~Token() { }
1137
1138 public:
1139 static const string CATEGORY;
1140};
1141
1149class MX_CORE_API CommentElement : public Element
1150{
1151 public:
1152 CommentElement(ElementPtr parent, const string& name) :
1153 Element(parent, CATEGORY, name)
1154 {
1155 }
1156 virtual ~CommentElement() { }
1157
1158 public:
1159 static const string CATEGORY;
1160};
1161
1164class MX_CORE_API NewlineElement : public Element
1165{
1166 public:
1167 NewlineElement(ElementPtr parent, const string& name) :
1168 Element(parent, CATEGORY, name)
1169 {
1170 }
1171 virtual ~NewlineElement() { }
1172
1173 public:
1174 static const string CATEGORY;
1175};
1176
1179class MX_CORE_API GenericElement : public Element
1180{
1181 public:
1182 GenericElement(ElementPtr parent, const string& name) :
1183 Element(parent, CATEGORY, name)
1184 {
1185 }
1186 virtual ~GenericElement() { }
1187
1188 public:
1189 static const string CATEGORY;
1190};
1191
1205class MX_CORE_API StringResolver
1206{
1207 public:
1210 {
1211 return StringResolverPtr(new StringResolver());
1212 }
1213
1214 virtual ~StringResolver() { }
1215
1218
1220 void setFilePrefix(const string& filePrefix)
1221 {
1222 _filePrefix = filePrefix;
1223 }
1224
1226 const string& getFilePrefix() const
1227 {
1228 return _filePrefix;
1229 }
1230
1234
1236 void setGeomPrefix(const string& geomPrefix)
1237 {
1238 _geomPrefix = geomPrefix;
1239 }
1240
1242 const string& getGeomPrefix() const
1243 {
1244 return _geomPrefix;
1245 }
1246
1250
1253 void setUdimString(const string& udim);
1254
1257 void setUvTileString(const string& uvTile);
1258
1260 void setFilenameSubstitution(const string& key, const string& value)
1261 {
1262 _filenameMap[key] = value;
1263 }
1264
1266 void addTokenSubstitutions(ConstElementPtr element);
1267
1270 {
1271 return _filenameMap;
1272 }
1273
1277
1279 void setGeomNameSubstitution(const string& key, const string& value)
1280 {
1281 _geomNameMap[key] = value;
1282 }
1283
1286 {
1287 return _geomNameMap;
1288 }
1289
1293
1296 virtual string resolve(const string& str, const string& type) const;
1297
1299 static bool isResolvedType(const string& type)
1300 {
1301 return type == FILENAME_TYPE_STRING || type == GEOMNAME_TYPE_STRING;
1302 }
1303
1305
1306 protected:
1307 StringResolver() { }
1308
1309 protected:
1310 string _filePrefix;
1311 string _geomPrefix;
1312 StringMap _filenameMap;
1313 StringMap _geomNameMap;
1314};
1315
1319class MX_CORE_API ExceptionOrphanedElement : public Exception
1320{
1321 public:
1322 using Exception::Exception;
1323};
1324
1325template <class T> shared_ptr<T> Element::addChild(const string& name)
1326{
1327 string childName = name;
1328 if (childName.empty())
1329 {
1330 childName = createValidChildName(T::CATEGORY + "1");
1331 }
1332
1333 if (_childMap.count(childName))
1334 throw Exception("Child name is not unique: " + childName);
1335
1336 shared_ptr<T> child = std::make_shared<T>(getSelf(), childName);
1337 registerChildElement(child);
1338
1339 return child;
1340}
1341
1345MX_CORE_API bool targetStringsMatch(const string& target1, const string& target2);
1346
1349MX_CORE_API string prettyPrint(ConstElementPtr elem);
1350
1351MATERIALX_NAMESPACE_END
1352
1353#endif
shared_ptr< TypeDef > TypeDefPtr
A shared pointer to a TypeDef.
Definition: Definition.h:42
shared_ptr< const Document > ConstDocumentPtr
A shared pointer to a const Document.
Definition: Document.h:24
shared_ptr< Document > DocumentPtr
A shared pointer to a Document.
Definition: Document.h:22
shared_ptr< Token > TokenPtr
A shared pointer to a Token.
Definition: Element.h:46
shared_ptr< const GenericElement > ConstGenericElementPtr
A shared pointer to a const GenericElement.
Definition: Element.h:63
shared_ptr< TypedElement > TypedElementPtr
A shared pointer to a TypedElement.
Definition: Element.h:36
shared_ptr< StringResolver > StringResolverPtr
A shared pointer to a StringResolver.
Definition: Element.h:66
shared_ptr< const CommentElement > ConstCommentElementPtr
A shared pointer to a const CommentElement.
Definition: Element.h:53
std::unordered_map< string, ElementPtr > ElementMap
A hash map from strings to elements.
Definition: Element.h:69
shared_ptr< NewlineElement > NewlineElementPtr
A shared pointer to a NewlineElement.
Definition: Element.h:56
shared_ptr< const Token > ConstTokenPtr
A shared pointer to a const Token.
Definition: Element.h:48
shared_ptr< GenericElement > GenericElementPtr
A shared pointer to a GenericElement.
Definition: Element.h:61
shared_ptr< const Element > ConstElementPtr
A shared pointer to a const Element.
Definition: Element.h:33
shared_ptr< Element > ElementPtr
A shared pointer to an Element.
Definition: Element.h:31
shared_ptr< ValueElement > ValueElementPtr
A shared pointer to a ValueElement.
Definition: Element.h:41
shared_ptr< const ValueElement > ConstValueElementPtr
A shared pointer to a const ValueElement.
Definition: Element.h:43
shared_ptr< CommentElement > CommentElementPtr
A shared pointer to a CommentElement.
Definition: Element.h:51
shared_ptr< const TypedElement > ConstTypedElementPtr
A shared pointer to a const TypedElement.
Definition: Element.h:38
std::function< bool(ConstElementPtr)> ElementPredicate
A standard function taking an ElementPtr and returning a boolean.
Definition: Element.h:72
shared_ptr< const NewlineElement > ConstNewlineElementPtr
A shared pointer to a const NewlineElement.
Definition: Element.h:58
MX_CORE_API string prettyPrint(ConstElementPtr elem)
Pretty print the given element tree, calling asString recursively on each element in depth-first orde...
Definition: Element.cpp:673
MX_CORE_API bool targetStringsMatch(const string &target1, const string &target2)
Given two target strings, each containing a string array of target names, return true if they have an...
Definition: Element.cpp:657
Import and export declarations for the Core library.
vector< string > StringVec
A vector of strings.
Definition: Library.h:57
std::unordered_map< string, string > StringMap
An unordered map with strings as both keys and values.
Definition: Library.h:59
Utility methods.
Graph traversal classes.
Generic value classes.
shared_ptr< Value > ValuePtr
A shared pointer to a Value.
Definition: Value.h:29
An element representing a block of descriptive text within a document, which will be stored a comment...
Definition: Element.h:1150
A MaterialX document, which represents the top-level element in the MaterialX ownership hierarchy.
Definition: Document.h:32
An edge between two connected Elements, returned during graph traversal.
Definition: Traversal.h:30
The base class for MaterialX elements.
Definition: Element.h:80
const string & getActiveSourceUri() const
Return the source URI that is active at the scope of this element, taking all ancestor elements into ...
Definition: Element.h:713
bool hasNamespace() const
Return true if this element has a namespace string.
Definition: Element.h:324
const string & getAttribute(const string &attrib) const
Return the value string of the given attribute.
Definition: Element.h:504
ConstElementPtr getSelf() const
Return our self pointer.
Definition: Element.h:556
const string & getActiveGeomPrefix() const
Return the geom prefix string that is active at the scope of this element, taking all ancestor elemen...
Definition: Element.h:217
bool isA(const string &category=EMPTY_STRING) const
Return true if this element belongs to the given subclass.
Definition: Element.h:381
void setDocString(const string &doc)
Set the documentation string of this element.
Definition: Element.h:363
bool hasGeomPrefix() const
Return true if the given element has a geom prefix string.
Definition: Element.h:204
shared_ptr< const T > getAncestorOfType() const
Return the first ancestor of the given subclass, or an empty shared pointer if no ancestor of this su...
Definition: Element.h:587
const string & getInheritString() const
Return the inherit string of this element.
Definition: Element.h:282
bool hasSourceUri() const
Return true if this element has a source URI.
Definition: Element.h:700
const string & getColorSpace() const
Return the element's color space string.
Definition: Element.h:246
shared_ptr< T > addChild(const string &name=EMPTY_STRING)
Add a child element of the given subclass and name.
Definition: Element.h:1325
const string & getName() const
Return the element's name string.
Definition: Element.h:138
void setColorSpace(const string &colorSpace)
Set the element's color space string.
Definition: Element.h:234
string getQualifiedName(const string &name) const
Return a qualified version of the given name, taking the namespace at the scope of this element into ...
Definition: Element.h:337
string createValidChildName(string name) const
Using the input name as a starting point, modify it to create a valid, unique name for a child elemen...
Definition: Element.h:746
const string & getGeomPrefix() const
Return the element's geom prefix string.
Definition: Element.h:210
void setFilePrefix(const string &prefix)
Set the element's file prefix string.
Definition: Element.h:162
const StringVec & getAttributeNames() const
Return a vector of stored attribute names, in the order they were set.
Definition: Element.h:511
ElementPtr getChild(const string &name) const
Return the child element, if any, with the given name.
Definition: Element.h:429
const string & getSourceUri() const
Return the element's source URI.
Definition: Element.h:706
bool hasColorSpace() const
Return true if the given element has a color space string.
Definition: Element.h:240
const string & getFilePrefix() const
Return the element's file prefix string.
Definition: Element.h:174
void setTypedAttribute(const string &attrib, const T &data)
Set the value of an implicitly typed attribute.
Definition: Element.h:519
virtual size_t getUpstreamEdgeCount() const
Return the number of queriable upstream edges for this element.
Definition: Element.h:657
bool hasInheritString() const
Return true if this element has an inherit string.
Definition: Element.h:276
const string & getActiveColorSpace() const
Return the color space string that is active at the scope of this element, taking all ancestor elemen...
Definition: Element.h:253
ElementPtr getInheritsFrom() const
Return the element, if any, that this one directly inherits from.
Definition: Element.h:301
T getTypedAttribute(const string &attrib) const
Return the value of an implicitly typed attribute.
Definition: Element.h:527
void setCategory(const string &category)
Set the element's category string.
Definition: Element.h:114
shared_ptr< T > getChildOfType(const string &name) const
Return the child element, if any, with the given name and subclass.
Definition: Element.h:438
void setGeomPrefix(const string &prefix)
Set the element's geom prefix string.
Definition: Element.h:198
void setNamespace(const string &space)
Set the namespace string of this element.
Definition: Element.h:318
ElementPtr getSelf()
Return our self pointer.
Definition: Element.h:550
const vector< ElementPtr > & getChildren() const
Return a constant vector of all child elements.
Definition: Element.h:446
ConstElementPtr getParent() const
Return our parent element.
Definition: Element.h:568
const string & getActiveFilePrefix() const
Return the file prefix string that is active at the scope of this element, taking all ancestor elemen...
Definition: Element.h:181
void setInheritString(const string &inherit)
Set the inherit string of this element.
Definition: Element.h:270
const string & getNamespace() const
Return the namespace string of this element.
Definition: Element.h:330
bool hasAttribute(const string &attrib) const
Return true if the given attribute is present.
Definition: Element.h:497
void removeChildOfType(const string &name)
Remove the child element, if any, with the given name and subclass.
Definition: Element.h:483
void setSourceUri(const string &sourceUri)
Set the element's source URI.
Definition: Element.h:694
string getDocString() const
Return the documentation string of this element.
Definition: Element.h:369
void setInheritsFrom(ConstElementPtr super)
Set the element that this one directly inherits from.
Definition: Element.h:288
ElementPtr getParent()
Return our parent element.
Definition: Element.h:562
bool hasFilePrefix() const
Return true if the given element has a file prefix string.
Definition: Element.h:168
const string & getCategory() const
Return the element's category string.
Definition: Element.h:122
vector< shared_ptr< T > > getChildrenOfType(const string &category=EMPTY_STRING) const
Return a vector of all child elements that are instances of the given subclass, optionally filtered b...
Definition: Element.h:454
The base class for exceptions that are propagated from the MaterialX library to the client applicatio...
Definition: Exception.h:22
An exception that is thrown when an ElementPtr is used after its owning Document has gone out of scop...
Definition: Element.h:1320
An exception that is thrown when a type mismatch is encountered.
Definition: Value.h:38
A generic element subclass, for instantiating elements with unrecognized categories.
Definition: Element.h:1180
An iterator object representing the state of an upstream graph traversal.
Definition: Traversal.h:192
An iterator object representing the current state of an inheritance traversal.
Definition: Traversal.h:334
An element representing a newline within a document.
Definition: Element.h:1165
A helper object for applying string modifiers to data values in the context of a specific element and...
Definition: Element.h:1206
void setFilenameSubstitution(const string &key, const string &value)
Set an arbitrary substring substitution for filename data values.
Definition: Element.h:1260
static bool isResolvedType(const string &type)
Return true if the given type may be resolved by this class.
Definition: Element.h:1299
const string & getGeomPrefix() const
Return the geom prefix for this context.
Definition: Element.h:1242
const string & getFilePrefix() const
Return the file prefix for this context.
Definition: Element.h:1226
const StringMap & getGeomNameSubstitutions() const
Return the map of geometry name substring substitutions.
Definition: Element.h:1285
void setFilePrefix(const string &filePrefix)
Set the file prefix for this context.
Definition: Element.h:1220
void setGeomPrefix(const string &geomPrefix)
Set the geom prefix for this context.
Definition: Element.h:1236
const StringMap & getFilenameSubstitutions() const
Return the map of filename substring substitutions.
Definition: Element.h:1269
void setGeomNameSubstitution(const string &key, const string &value)
Set an arbitrary substring substitution for geometry name data values.
Definition: Element.h:1279
static StringResolverPtr create()
Create a new string resolver.
Definition: Element.h:1209
A token element representing a string value.
Definition: Element.h:1130
An iterator object representing the state of a tree traversal.
Definition: Traversal.h:89
The base class for typed elements.
Definition: Element.h:837
virtual const string & getType() const
Return the element's type string.
Definition: Element.h:867
void setType(const string &type)
Set the element's type string.
Definition: Element.h:855
bool isMultiOutputType() const
Return true if the element is of multi-output type.
Definition: Element.h:873
bool hasType() const
Return true if the given element has a type string.
Definition: Element.h:861
The base class for elements that support typed values.
Definition: Element.h:895
ValuePtr getValue() const
Return the typed value of an element as a generic value object, which may be queried to access its da...
Definition: Element.h:1005
void setUnit(const string &unit)
Set the unit string of an element.
Definition: Element.h:1039
const string & getValueString() const
Get the value string of a element.
Definition: Element.h:921
void setInterfaceName(const string &name)
Set the interface name of an element.
Definition: Element.h:938
ValuePtr getResolvedValue(StringResolverPtr resolver=nullptr) const
Return the resolved value of an element as a generic value object, which may be queried to access its...
Definition: Element.h:1020
const string & getImplementationName() const
Return the implementation name of an element.
Definition: Element.h:972
void setValue(const char *value, const string &type=EMPTY_STRING)
Set the typed value of an element from a C-style string.
Definition: Element.h:989
bool hasUnitType() const
Return true if the given element has a unit type.
Definition: Element.h:1067
void setIsUniform(bool value)
Set the uniform attribute flag on this element.
Definition: Element.h:1083
const string & getUnit() const
Return the unit string of an element.
Definition: Element.h:1051
bool getIsUniform() const
The the uniform attribute flag for this element.
Definition: Element.h:1089
void setValueString(const string &value)
Set the value string of an element.
Definition: Element.h:909
void setValue(const T &value, const string &type=EMPTY_STRING)
Set the typed value of an element.
Definition: Element.h:982
bool hasUnit() const
Return true if the given element has a unit string.
Definition: Element.h:1045
bool hasInterfaceName() const
Return true if the given element has an interface name.
Definition: Element.h:944
void setUnitType(const string &unit)
Set the unit type of an element.
Definition: Element.h:1061
bool hasImplementationName() const
Return true if the given element has an implementation name.
Definition: Element.h:966
void setImplementationName(const string &name)
Set the implementation name of an element.
Definition: Element.h:960
const string & getInterfaceName() const
Return the interface name of an element.
Definition: Element.h:950
bool hasValueString() const
Return true if the given element has a value string.
Definition: Element.h:915
const string & getUnitType() const
Return the unit type of an element.
Definition: Element.h:1073
bool hasValue() const
Return true if the element possesses a typed value.
Definition: Element.h:995
static ValuePtr createValueFromStrings(const string &value, const string &type)
Create a new value instance from value and type strings.
Definition: Value.cpp:216