schema.h
1 //
2 // Copyright 2016 Pixar
3 //
4 // Licensed under the Apache License, Version 2.0 (the "Apache License")
5 // with the following modification; you may not use this file except in
6 // compliance with the Apache License and the following modification to it:
7 // Section 6. Trademarks. is deleted and replaced with:
8 //
9 // 6. Trademarks. This License does not grant permission to use the trade
10 // names, trademarks, service marks, or product names of the Licensor
11 // and its affiliates, except as required to comply with Section 4(c) of
12 // the License and to reproduce the content of the NOTICE file.
13 //
14 // You may obtain a copy of the Apache License at
15 //
16 // http://www.apache.org/licenses/LICENSE-2.0
17 //
18 // Unless required by applicable law or agreed to in writing, software
19 // distributed under the Apache License with the above modification is
20 // distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
21 // KIND, either express or implied. See the Apache License for the specific
22 // language governing permissions and limitations under the Apache License.
23 //
24 #ifndef PXR_USD_SDF_SCHEMA_H
25 #define PXR_USD_SDF_SCHEMA_H
26 
27 #include "pxr/pxr.h"
28 #include "pxr/usd/sdf/api.h"
29 #include "pxr/usd/sdf/allowed.h"
30 #include "pxr/usd/sdf/types.h"
31 #include "pxr/usd/sdf/valueTypeName.h"
32 
33 #include "pxr/base/plug/notice.h"
34 #include "pxr/base/tf/hash.h"
35 #include "pxr/base/tf/hashmap.h"
36 #include "pxr/base/tf/singleton.h"
38 #include "pxr/base/tf/token.h"
39 #include "pxr/base/tf/type.h"
40 #include "pxr/base/tf/weakBase.h"
41 #include "pxr/base/vt/value.h"
42 
43 #include <memory>
44 #include <string>
45 #include <vector>
46 
47 PXR_NAMESPACE_OPEN_SCOPE
48 
49 class JsValue;
50 class SdfPath;
51 class SdfPayload;
52 class SdfReference;
53 class Sdf_ValueTypeRegistry;
54 
56 
62 class SdfSchemaBase : public TfWeakBase, public boost::noncopyable {
63 
64 protected:
65  class _SpecDefiner;
66 
67 public:
73  public:
75  const SdfSchemaBase& schema,
76  const TfToken& name,
77  const VtValue& fallbackValue);
78 
79  typedef std::vector< std::pair<TfToken, JsValue> > InfoVec;
80 
81  SDF_API const TfToken& GetName() const;
82  SDF_API const VtValue& GetFallbackValue() const;
83  SDF_API const InfoVec& GetInfo() const;
84 
85  SDF_API bool IsPlugin() const;
86  SDF_API bool IsReadOnly() const;
87  SDF_API bool HoldsChildren() const;
88 
92 
93  template <class T>
94  SdfAllowed IsValidValue(const T& value) const
95  {
96  return (_valueValidator ?
97  _valueValidator(_schema, VtValue(value)) :
98  SdfAllowed(true));
99  }
100 
101  template <class T>
102  SdfAllowed IsValidListValue(const T& value) const
103  {
104  return (_listValueValidator ?
105  _listValueValidator(_schema, VtValue(value)) :
106  SdfAllowed(true));
107  }
108 
109  template <class T>
110  SdfAllowed IsValidMapKey(const T& value) const
111  {
112  return (_mapKeyValidator ?
113  _mapKeyValidator(_schema, VtValue(value)) :
114  SdfAllowed(true));
115  }
116 
117  template <class T>
118  SdfAllowed IsValidMapValue(const T& value) const
119  {
120  return (_mapValueValidator ?
121  _mapValueValidator(_schema, VtValue(value)) :
122  SdfAllowed(true));
123  }
124 
126 
129 
130  FieldDefinition& FallbackValue(const VtValue& v);
131 
132  FieldDefinition& Plugin();
133  FieldDefinition& Children();
134  FieldDefinition& ReadOnly();
135  FieldDefinition& AddInfo(const TfToken& tok, const JsValue& val);
136 
137  using Validator =
138  SdfAllowed (*) (const SdfSchemaBase&, const VtValue&);
139  FieldDefinition& ValueValidator(Validator v);
140  FieldDefinition& ListValueValidator(Validator v);
141  FieldDefinition& MapKeyValidator(Validator v);
142  FieldDefinition& MapValueValidator(Validator v);
143 
145 
146  private:
147  const SdfSchemaBase& _schema;
148  TfToken _name;
149  VtValue _fallbackValue;
150  InfoVec _info;
151 
152  bool _isPlugin;
153  bool _isReadOnly;
154  bool _holdsChildren;
155 
156  Validator _valueValidator;
157  Validator _listValueValidator;
158  Validator _mapKeyValidator;
159  Validator _mapValueValidator;
160  };
161 
162  // Structure containing information about a field as it pertains to the
163  // spec this object defines.
164  struct _FieldInfo {
165  _FieldInfo(): required(false), metadata(false) { }
166  bool required;
167  bool metadata;
168  TfToken metadataDisplayGroup;
169  };
170 
171  class SpecDefinition;
172 
178  public:
180  SDF_API TfTokenVector GetFields() const;
181 
184  return _requiredFields;
185  }
186 
188  SDF_API TfTokenVector GetMetadataFields() const;
189 
191  SDF_API bool IsValidField(const TfToken& name) const;
192 
194  SDF_API bool IsMetadataField(const TfToken& name) const;
195 
199  SDF_API
200  TfToken GetMetadataFieldDisplayGroup(const TfToken& name) const;
201 
203  SDF_API bool IsRequiredField(const TfToken& name) const;
204 
205 
206  private:
207  typedef TfHashMap<TfToken, _FieldInfo, TfToken::HashFunctor>
208  _FieldMap;
209  _FieldMap _fields;
210 
211  // A separate vector of required field names from _fields. Access to
212  // these is in a hot path, so we cache them separately.
213  TfTokenVector _requiredFields;
214 
215  private:
216  friend class _SpecDefiner;
217  void _AddField(const TfToken& name, const _FieldInfo& fieldInfo);
218  };
219 
222  SDF_API
223  const FieldDefinition* GetFieldDefinition(const TfToken &fieldKey) const;
224 
227  inline const SpecDefinition* GetSpecDefinition(SdfSpecType specType) const {
228  return _specDefinitions[specType].second ?
229  &_specDefinitions[specType].first : nullptr;
230  }
231 
234 
237  SDF_API
238  bool IsRegistered(const TfToken &fieldKey, VtValue *fallback=NULL) const;
239 
242  SDF_API
243  bool HoldsChildren(const TfToken &fieldKey) const;
244 
247  SDF_API
248  const VtValue& GetFallback(const TfToken &fieldKey) const;
249 
251  SDF_API
252  VtValue CastToTypeOf(const TfToken &fieldKey, const VtValue &value) const;
253 
255  SDF_API
256  bool IsValidFieldForSpec(const TfToken &fieldKey, SdfSpecType specType) const;
257 
259  SDF_API TfTokenVector GetFields(SdfSpecType specType) const;
260 
262  SDF_API TfTokenVector GetMetadataFields(SdfSpecType specType) const;
263 
267  SDF_API
269  TfToken const &metadataField) const;
270 
272  SDF_API const TfTokenVector &GetRequiredFields(SdfSpecType specType) const;
273 
278  inline bool IsRequiredFieldName(const TfToken &fieldName) const {
279  for (TfToken const &fname: _requiredFieldNames) {
280  if (fname == fieldName) {
281  return true;
282  }
283  }
284  return false;
285  }
286 
288 
293 
295  static SdfAllowed IsValidIdentifier(const std::string& name);
296  static SdfAllowed IsValidNamespacedIdentifier(const std::string& name);
297  static SdfAllowed IsValidInheritPath(const SdfPath& path);
298  static SdfAllowed IsValidPayload(const SdfPayload& payload);
299  static SdfAllowed IsValidReference(const SdfReference& ref);
300  static SdfAllowed IsValidRelationshipTargetPath(const SdfPath& path);
301  static SdfAllowed IsValidRelocatesPath(const SdfPath& path);
302  static SdfAllowed IsValidSpecializesPath(const SdfPath& path);
303  static SdfAllowed IsValidSubLayer(const std::string& sublayer);
304  static SdfAllowed IsValidVariantIdentifier(const std::string& name);
305 
307 
310 
316  SDF_API
317  SdfAllowed IsValidValue(const VtValue& value) const;
318 
320  SDF_API
321  std::vector<SdfValueTypeName> GetAllTypes() const;
322 
324  SDF_API
325  SdfValueTypeName FindType(const TfToken& typeName) const;
327  SDF_API
328  SdfValueTypeName FindType(const char *typeName) const;
330  SDF_API
331  SdfValueTypeName FindType(std::string const &typeName) const;
332 
334  SDF_API
335  SdfValueTypeName FindType(const TfType& type,
336  const TfToken& role = TfToken()) const;
337 
339  SDF_API
340  SdfValueTypeName FindType(const VtValue& value,
341  const TfToken& role = TfToken()) const;
342 
346  SDF_API
347  SdfValueTypeName FindOrCreateType(const TfToken& typeName) const;
348 
350 
351 protected:
356  class _SpecDefiner {
357  public:
360 
362  const TfToken& name, bool required = false);
363  _SpecDefiner& MetadataField(
364  const TfToken& name, bool required = false);
365  _SpecDefiner& MetadataField(
366  const TfToken& name, const TfToken& displayGroup,
367  bool required = false);
368 
369  _SpecDefiner &CopyFrom(const SpecDefinition &other);
370 
372  private:
373  friend class SdfSchemaBase;
374  explicit _SpecDefiner(SdfSchemaBase *schema, SpecDefinition *definition)
375  : _schema(schema)
376  , _definition(definition)
377  {}
378  SdfSchemaBase *_schema;
379  SpecDefinition *_definition;
380  };
381 
384  public:
385  explicit _ValueTypeRegistrar(Sdf_ValueTypeRegistry*);
386 
387  class Type
388  {
389  public:
390  ~Type();
391 
392  // Specify a type with the given name, default value, and default
393  // array value of VtArray<T>.
394  template <class T>
395  Type(const TfToken& name, const T& defaultValue)
396  : Type(name, VtValue(defaultValue), VtValue(VtArray<T>()))
397  { }
398  template <class T>
399  Type(char const *name, const T& defaultValue)
400  : Type(TfToken(name),
401  VtValue(defaultValue), VtValue(VtArray<T>()))
402  { }
403 
404  // Specify a type with the given name and underlying C++ type.
405  // No default value or array value will be registered.
406  Type(const TfToken& name, const TfType& type);
407 
408  // Set C++ type name string for this type. Defaults to type name
409  // from TfType.
410  Type& CPPTypeName(const std::string& cppTypeName);
411 
412  // Set shape for this type. Defaults to shapeless.
413  Type& Dimensions(const SdfTupleDimensions& dims);
414 
415  // Set default unit for this type. Defaults to dimensionless unit.
416  Type& DefaultUnit(TfEnum unit);
417 
418  // Set role for this type. Defaults to no role.
419  Type& Role(const TfToken& role);
420 
421  // Indicate that arrays of this type are not supported.
422  Type& NoArrays();
423 
424  private:
425  Type(const TfToken& name,
426  const VtValue& defaultValue,
427  const VtValue& defaultArrayValue);
428 
429  class _Impl;
430  std::unique_ptr<_Impl> _impl;
431 
432  friend class _ValueTypeRegistrar;
433  };
434 
436  void AddType(const Type& type);
437 
438  private:
439  Sdf_ValueTypeRegistry* _registry;
440  };
441 
442  SdfSchemaBase();
443 
446  class EmptyTag {};
448 
449  virtual ~SdfSchemaBase();
450 
458  template <class T>
460  const TfToken &fieldKey, const T &fallback, bool plugin = false)
461  {
462  return _CreateField(fieldKey, VtValue(fallback), plugin);
463  }
464 
468  // Mark the definition as valid and return a pointer to it.
469  _specDefinitions[type].second = true;
470  return _SpecDefiner(this, &_specDefinitions[type].first);
471  }
472 
475  _SpecDefiner _ExtendSpecDefinition(SdfSpecType specType);
476 
479 
482  void _RegisterPluginFields();
483 
485  void _RegisterStandardTypes();
486 
488  void _RegisterLegacyTypes();
489 
491  _ValueTypeRegistrar _GetTypeRegistrar() const;
492 
496  typedef std::function<VtValue(const std::string&, const JsValue&)>
498 
501  const std::vector<const SdfSchemaBase::FieldDefinition *>
502  _UpdateMetadataFromPlugins(const PlugPluginPtrVector& plugins,
503  const std::string& metadataTag =
504  std::string(),
505  const _DefaultValueFactoryFn& defFactory =
507 
508 private:
509  friend class _SpecDefiner;
510 
511  void _OnDidRegisterPlugins(const PlugNotice::DidRegisterPlugins& n);
512 
513  // Return a _SpecDefiner for an existing spec definition, \p local.
515  return _SpecDefiner(this, local);
516  }
517 
518  void _AddRequiredFieldName(const TfToken &name);
519 
520  const SpecDefinition* _CheckAndGetSpecDefinition(SdfSpecType type) const;
521 
522  friend struct Sdf_SchemaFieldTypeRegistrar;
523  FieldDefinition& _CreateField(
524  const TfToken &fieldKey, const VtValue &fallback, bool plugin = false);
525 
526  template <class T>
527  FieldDefinition& _DoRegisterField(const TfToken &fieldKey, const T &fallback)
528  {
529  return _DoRegisterField(fieldKey, VtValue(fallback));
530  }
531 
532  FieldDefinition& _DoRegisterField(
533  const TfToken &fieldKey, const VtValue &fallback);
534 
535 private:
536  typedef TfHashMap<TfToken, SdfSchemaBase::FieldDefinition,
538  _FieldDefinitionMap;
539  _FieldDefinitionMap _fieldDefinitions;
540 
541  // Pair of definition and flag indicating validity.
542  std::pair<SdfSchemaBase::SpecDefinition, bool>
543  _specDefinitions[SdfNumSpecTypes];
544 
545  std::unique_ptr<Sdf_ValueTypeRegistry> _valueTypeRegistry;
546  TfTokenVector _requiredFieldNames;
547 };
548 
554 class SdfSchema : public SdfSchemaBase {
555 public:
556  SDF_API
557  static const SdfSchema& GetInstance()
558  {
560  }
561 
562 private:
563  friend class TfSingleton<SdfSchema>;
564  SdfSchema();
565  virtual ~SdfSchema();
566 };
567 
568 SDF_API_TEMPLATE_CLASS(TfSingleton<SdfSchema>);
569 
573 #define SDF_FIELD_KEYS \
574  ((Active, "active")) \
575  ((AllowedTokens, "allowedTokens")) \
576  ((AssetInfo, "assetInfo")) \
577  ((ColorConfiguration, "colorConfiguration")) \
578  ((ColorManagementSystem, "colorManagementSystem")) \
579  ((ColorSpace, "colorSpace")) \
580  ((Comment, "comment")) \
581  ((ConnectionPaths, "connectionPaths")) \
582  ((Custom, "custom")) \
583  ((CustomData, "customData")) \
584  ((CustomLayerData, "customLayerData")) \
585  ((Default, "default")) \
586  ((DefaultPrim, "defaultPrim")) \
587  ((DisplayGroup, "displayGroup")) \
588  ((DisplayGroupOrder, "displayGroupOrder")) \
589  ((DisplayName, "displayName")) \
590  ((DisplayUnit, "displayUnit")) \
591  ((Documentation, "documentation")) \
592  ((EndTimeCode, "endTimeCode")) \
593  ((FramePrecision, "framePrecision")) \
594  ((FramesPerSecond, "framesPerSecond")) \
595  ((Hidden, "hidden")) \
596  ((HasOwnedSubLayers, "hasOwnedSubLayers")) \
597  ((InheritPaths, "inheritPaths")) \
598  ((Instanceable, "instanceable")) \
599  ((Kind, "kind")) \
600  ((PrimOrder, "primOrder")) \
601  ((NoLoadHint, "noLoadHint")) \
602  ((Owner, "owner")) \
603  ((Payload, "payload")) \
604  ((Permission, "permission")) \
605  ((Prefix, "prefix")) \
606  ((PrefixSubstitutions, "prefixSubstitutions")) \
607  ((PropertyOrder, "propertyOrder")) \
608  ((References, "references")) \
609  ((Relocates, "relocates")) \
610  ((SessionOwner, "sessionOwner")) \
611  ((Specializes, "specializes")) \
612  ((Specifier, "specifier")) \
613  ((StartTimeCode, "startTimeCode")) \
614  ((SubLayers, "subLayers")) \
615  ((SubLayerOffsets, "subLayerOffsets")) \
616  ((Suffix, "suffix")) \
617  ((SuffixSubstitutions, "suffixSubstitutions")) \
618  ((SymmetricPeer, "symmetricPeer")) \
619  ((SymmetryArgs, "symmetryArgs")) \
620  ((SymmetryArguments, "symmetryArguments")) \
621  ((SymmetryFunction, "symmetryFunction")) \
622  ((TargetPaths, "targetPaths")) \
623  ((TimeSamples, "timeSamples")) \
624  ((TimeCodesPerSecond, "timeCodesPerSecond")) \
625  ((TypeName, "typeName")) \
626  ((VariantSelection, "variantSelection")) \
627  ((Variability, "variability")) \
628  ((VariantSetNames, "variantSetNames")) \
629  \
630  /* XXX: These fields should move into Sd. See bug 123508. */ \
631  ((EndFrame, "endFrame")) \
632  ((StartFrame, "startFrame"))
633 
634 #define SDF_CHILDREN_KEYS \
635  ((ConnectionChildren, "connectionChildren")) \
636  ((ExpressionChildren, "expressionChildren")) \
637  ((MapperArgChildren, "mapperArgChildren")) \
638  ((MapperChildren, "mapperChildren")) \
639  ((PrimChildren, "primChildren")) \
640  ((PropertyChildren, "properties")) \
641  ((RelationshipTargetChildren, "targetChildren")) \
642  ((VariantChildren, "variantChildren")) \
643  ((VariantSetChildren, "variantSetChildren"))
644 
645 TF_DECLARE_PUBLIC_TOKENS(SdfFieldKeys, SDF_API, SDF_FIELD_KEYS);
646 TF_DECLARE_PUBLIC_TOKENS(SdfChildrenKeys, SDF_API, SDF_CHILDREN_KEYS);
647 
648 PXR_NAMESPACE_CLOSE_SCOPE
649 
650 #endif // PXR_USD_SDF_SCHEMA_H
SDF_API bool IsRegistered(const TfToken &fieldKey, VtValue *fallback=NULL) const
Convenience functions for accessing specific field information.
SDF_API TfTokenVector GetMetadataFields(SdfSpecType specType) const
Returns all metadata fields registered for the given spec type.
SDF_API TfTokenVector GetFields(SdfSpecType specType) const
Returns all fields registered for the given spec type.
Manage a single instance of an object.
void _RegisterPluginFields()
Registers plugin fields and sets up handling so that fields will be added when additional plugins are...
std::function< VtValue(const std::string &, const JsValue &)> _DefaultValueFactoryFn
Factory function for creating a default value for a metadata field.
Definition: schema.h:497
Manage a single instance of an object (see.
Definition: singleton.h:119
SDF_API const FieldDefinition * GetFieldDefinition(const TfToken &fieldKey) const
Returns the field definition for the given field.
bool IsRequiredFieldName(const TfToken &fieldName) const
Return true if fieldName is a required field name for at least one spec type, return false otherwise.
Definition: schema.h:278
SDF_API VtValue CastToTypeOf(const TfToken &fieldKey, const VtValue &value) const
Coerce value to the correct type for the specified field.
#define TF_DECLARE_WEAK_PTRS(type)
Define standard weak pointer types.
Definition: declarePtrs.h:62
SDF_API bool HoldsChildren(const TfToken &fieldKey) const
Returns whether the given field is a 'children' field – that is, it indexes certain children beneath ...
SDF_API TfToken GetMetadataFieldDisplayGroup(SdfSpecType specType, TfToken const &metadataField) const
Return the metadata field display group for metadata metadataField on specType.
TfTokenVector const & GetRequiredFields() const
Returns all value fields marked as required for this spec.
Definition: schema.h:183
void _RegisterLegacyTypes()
Registers legacy attribute value types.
_ValueTypeRegistrar _GetTypeRegistrar() const
Returns a type registrar.
Generic class that provides information about scene description fields but doesn't actually provide a...
Definition: schema.h:62
SDF_API bool IsValidField(const TfToken &name) const
Returns whether the given field is valid for this spec.
Class that defines fields for a spec type.
Definition: schema.h:356
An enum class that records both enum type and enum value.
Definition: enum.h:139
Functor to use for hash maps from tokens to other things.
Definition: token.h:166
_SpecDefiner & Field(const TfToken &name, bool required=false)
Functions for setting spec attributes during registration.
Represents a value type name, i.e.
Definition: valueTypeName.h:87
Basic Sdf data types.
Token for efficient comparison, assignment, and hashing of known strings.
Definition: token.h:87
FieldDefinition & _RegisterField(const TfToken &fieldKey, const T &fallback, bool plugin=false)
Creates and registers a new field named fieldKey with the fallback value fallback.
Definition: schema.h:459
Class defining various attributes for a field.
Definition: schema.h:72
SDF_API TfToken GetMetadataFieldDisplayGroup(const TfToken &name) const
Returns the display group for this metadata field.
Indicates if an operation is allowed and, if not, why not.
Definition: allowed.h:47
A discriminated union type for JSON values.
Definition: value.h:61
_SpecDefiner _ExtendSpecDefinition(SdfSpecType specType)
Returns a _SpecDefiner for the previously-defined spec type for specifying additional fields.
#define TF_DECLARE_PUBLIC_TOKENS(...)
Macro to define public tokens.
Definition: staticTokens.h:118
Represents a payload and all its meta data.
Definition: payload.h:60
SDF_API SdfAllowed IsValidValue(const VtValue &value) const
Scene description value types.
std::vector< TfToken > TfTokenVector
Convenience types.
Definition: token.h:442
Class representing fields and other information for a spec type.
Definition: schema.h:177
Represents an arbitrary dimensional rectangular container class.
Definition: array.h:228
A path value used to locate objects in layers or scenegraphs.
Definition: path.h:290
static T & GetInstance()
Return a reference to an object of type T, creating it if necessary.
Definition: singleton.h:134
void AddType(const Type &type)
Register a value type and its corresponding array value type.
SDF_API bool IsValidFieldForSpec(const TfToken &fieldKey, SdfSpecType specType) const
Return whether the given field is valid for the given spec type.
SDF_API TfTokenVector GetMetadataFields() const
Returns all value fields marked as metadata for this spec.
A helper for registering value types.
Definition: schema.h:383
void _RegisterStandardTypes()
Registers standard attribute value types.
static SdfAllowed IsValidAttributeConnectionPath(const SdfPath &path)
Specific validation functions for various fields.
Represents a reference and all its meta data.
Definition: reference.h:76
SDF_API const VtValue & GetFallback(const TfToken &fieldKey) const
Return the fallback value for the specified fieldKey or the empty value if fieldKey is not registered...
Defines an interface to registered plugins.
Definition: plugin.h:58
SdfAllowed IsValidValue(const T &value) const
Validation functions that return true if a given value passes the registered validator or if no valid...
Definition: schema.h:94
SDF_API TfTokenVector GetFields() const
Returns all fields for this spec.
This file defines some macros that are useful for declaring and using static TfTokens.
void _RegisterStandardFields()
Registers the standard fields.
SdfSpecType
An enum that specifies the type of an object.
Definition: types.h:91
SDF_API bool IsMetadataField(const TfToken &name) const
Returns whether the given field is metadata for this spec.
SDF_API bool IsRequiredField(const TfToken &name) const
Returns whether the given field is required for this spec.
Notice sent after new plugins have been registered with the Plug registry.
Definition: notice.h:50
FieldDefinition & FallbackValue(const VtValue &v)
Functions for setting field attributes during registration.
_SpecDefiner _Define(SdfSpecType type)
Registers the given spec type with this schema and return a _SpecDefiner for specifying additional fi...
Definition: schema.h:467
const SpecDefinition * GetSpecDefinition(SdfSpecType specType) const
Returns the spec definition for the given spec type.
Definition: schema.h:227
const std::vector< const SdfSchemaBase::FieldDefinition * > _UpdateMetadataFromPlugins(const PlugPluginPtrVector &plugins, const std::string &metadataTag=std::string(), const _DefaultValueFactoryFn &defFactory=_DefaultValueFactoryFn())
Registers all metadata fields specified in the given plugins under the given metadata tag.
TfType represents a dynamic runtime type.
Definition: type.h:64
Represents the shape of a value type (or that of an element in an array).
Definition: valueTypeName.h:46
Class that provides information about the various scene description fields.
Definition: schema.h:554
SDF_API std::vector< SdfValueTypeName > GetAllTypes() const
Returns all registered type names.
SDF_API const TfTokenVector & GetRequiredFields(SdfSpecType specType) const
Returns all required fields registered for the given spec type.
SDF_API SdfValueTypeName FindOrCreateType(const TfToken &typeName) const
Return the type name object for the given type name string if it exists otherwise create a temporary ...
Enable a concrete base class for use with TfWeakPtr.
Definition: weakBase.h:141
Provides a container which may hold any type, and provides introspection and iteration over array typ...
Definition: value.h:166
SDF_API SdfValueTypeName FindType(const TfToken &typeName) const
Return the type name object for the given type name token.
TfToken class for efficient string referencing and hashing, plus conversions to and from stl string c...
Construct an SdfSchemaBase but does not populate it with standard fields and types.
Definition: schema.h:446