def Execute(result):
   result["CallContext"].__doc__ = """"""
   result["Debug"].__doc__ = """
Enum-based debugging messages.

The ``TfDebug`` class encapsulates a simple enum-based conditional
debugging message system. It is meant as a tool for developers, and
*NOT* as a means of issuing diagnostic messages to end-users. (This is
not strictly true. The TfDebug class is extremely useful and has many
properties that make its use attractive for issuing messages to end-
users. However, for this purpose, please use the ``TF_INFO`` macro
which more clearly indicates its intent.)

The features of ``TfDebug`` are:

   - Debugging messages/calls for an entire enum group can be compiled
     out-of-existence.

   - The cost of checking if a specific message should be printed at
     runtime (assuming the enum group of the message has not been compile-
     time disabled) is a single inline array lookup, with a compile-time
     index into a global array.
     The use of the facility is simple:

.. code-block:: text

  // header file
  #include "pxr/base/tf/debug.h"
  TF_DEBUG_CODES(MY_E1, MY_E2, MY_E3);
  
  // source file
  TF_DEBUG(MY_E2).Msg("something about e2\n");
  
  TF_DEBUG(MY_E3).Msg("val = %d\n", value);

The code in the header file declares the debug symbols to use. Under
the hood, this creates an enum with the values given in the argument
to TF_DEBUG_CODES, along with a first and last sentinel values and
passes that to TF_DEBUG_RANGE.

If you need to obtain the enum type name, use
decltype(SOME_ENUM_VALUE).

In the source file, the indicated debugging messages are printed only
if the debugging symbols are enabled. Effectively, the construct

.. code-block:: text

  TF_DEBUG(MY_E1).Msg(msgExpr)

 is translated to

.. code-block:: text

  if (symbol-MY_E1-is-enabled)
      output(msgExpr)

The implications are that ``msgExpr`` is only evaluated if symbol
``MY_E1`` symbol is enabled.

To totally disable TF_DEBUG output for a set of codes at compile time,
declare the codes using
TF_CONDITIONALLY_COMPILE_TIME_ENABLED_DEBUG_CODES(condition,
\\.\\.\\.) where \\.\\.\\. is all the debug codes. If'condition'is
false at compile time then all TF_DEBUG() .Msg()s for these codes are
elminated at compile time, so they have zero cost.

Most commonly debug symbols are inactive by default, but can be turned
on either by an environment variable ``TF_DEBUG`` , or interactively
once a program has started.

.. code-block:: text

  TfDebug::DisableAll<MyDebugCodes>();     // disable everything
  
  TfDebug::Enable(MY_E1);                  // enable just MY_E1

Description strings may be associated with debug codes as follows:

.. code-block:: text

  // source file xyz/debugCodes.cpp
  
  #include "proj/my/debugCodes.h"
  #include "pxr/base/tf/debug.h"
  #include "pxr/base/tf/registryManager.h"
  
  TF_REGISTRY_FUNCTION(TfDebug) {
      TF_DEBUG_ENVIRONMENT_SYMBOL(MY_E1, "loading of blah-blah files");
      TF_DEBUG_ENVIRONMENT_SYMBOL(MY_E2, "parsing of mdl code");
      // etc.
  }


"""
   result["Debug"].SetDebugSymbolsByName.func_doc = """**classmethod** SetDebugSymbolsByName(pattern, value) -> list[str]


Set registered debug symbols matching ``pattern`` to ``value`` .


All registered debug symbols matching ``pattern`` are set to ``value``
. The only matching is an exact match with ``pattern`` , or if
``pattern`` ends with an'\\*'as is otherwise a prefix of a debug
symbols. The names of all debug symbols set by this call are returned
as a vector.


Parameters
----------
pattern : str

value : bool


"""
   result["Debug"].IsDebugSymbolNameEnabled.func_doc = """**classmethod** IsDebugSymbolNameEnabled(name) -> bool


True if the specified debug symbol is set.


Parameters
----------
name : str


"""
   result["Debug"].GetDebugSymbolDescriptions.func_doc = """**classmethod** GetDebugSymbolDescriptions() -> str


Get a description of all debug symbols and their purpose.


A single string describing all registered debug symbols along with
short descriptions is returned.



"""
   result["Debug"].GetDebugSymbolNames.func_doc = """**classmethod** GetDebugSymbolNames() -> list[str]


Get a listing of all debug symbols.



"""
   result["Debug"].GetDebugSymbolDescription.func_doc = """**classmethod** GetDebugSymbolDescription(name) -> str


Get a description for the specified debug symbol.


A short description of the debug symbol is returned. This is the same
description string that is embedded in the return value of
GetDebugSymbolDescriptions.


Parameters
----------
name : str


"""
   result["Debug"].SetOutputFile.func_doc = """**classmethod** SetOutputFile(file) -> None


Direct debug output to *either* stdout or stderr.


Note that *file* MUST be either stdout or stderr. If not, issue an
error and do nothing. Debug output is issued to stdout by default. If
the environment variable TF_DEBUG_OUTPUT_FILE is set to'stderr', then
output is issued to stderr by default.


Parameters
----------
file : FILE


"""
   result["Enum"].__doc__ = """
An enum class that records both enum type and enum value.

"""
   result["Enum"].GetValueFromFullName.func_doc = """**classmethod** GetValueFromFullName(fullname, foundIt) -> Enum


Returns the enumerated value for a fully-qualified name.


This takes a fully-qualified enumerated value name (e.g.,
``"Season::WINTER"`` ) and returns the associated value. If there is
no such name, this returns -1. Since -1 can sometimes be a valid
value, the ``foundIt`` flag pointer, if not ``None`` , is set to
``true`` if the name was found and ``false`` otherwise. Also, since
this is not a templated function, it has to return a generic value
type, so we use ``TfEnum`` .


Parameters
----------
fullname : str

foundIt : bool


"""
   result["Error"].__doc__ = """
Represents an object that contains error information.

See Guide To Diagnostic Facilities in the C++ API reference for a
detailed description of the error issuing API. For a example of how to
post an error, see ``TF_ERROR()`` , also in the C++ API reference.

In the Python API, you can raise several different types of errors,
including coding errors (Tf.RaiseCodingError), run time errors
(Tf.RaiseRuntimeError), fatal errors (Tf.Fatal).

"""
   result["MallocTag"].__doc__ = """
Top-down memory tagging system.

See The TfMallocTag Memory Tagging System for a detailed description.

"""
   result["MallocTag"].Initialize.func_doc = """**classmethod** Initialize(errMsg) -> bool


Initialize the memory tagging system.


This function returns ``true`` if the memory tagging system can be
successfully initialized or it has already been initialized.
Otherwise, ``\\*errMsg`` is set with an explanation for the failure.

Until the system is initialized, the various memory reporting calls
will indicate that no memory has been allocated. Note also that memory
allocated prior to calling ``Initialize()`` is not tracked i.e. all
data refers to allocations that happen subsequent to calling
``Initialize()`` .


Parameters
----------
errMsg : str


"""
   result["MallocTag"].IsInitialized.func_doc = """**classmethod** IsInitialized() -> bool


Return true if the tagging system is active.


If ``Initialize()`` has been successfully called, this function
returns ``true`` .



"""
   result["MallocTag"].GetTotalBytes.func_doc = """**classmethod** GetTotalBytes() -> int


Return total number of allocated bytes.


The current total memory that has been allocated and not freed is
returned. Memory allocated before calling ``Initialize()`` is not
accounted for.



"""
   result["MallocTag"].GetMaxTotalBytes.func_doc = """**classmethod** GetMaxTotalBytes() -> int


Return the maximum total number of bytes that have ever been allocated
at one time.


This is simply the maximum value of GetTotalBytes() since Initialize()
was called.



"""
   result["MallocTag"].GetCallTree.func_doc = """**classmethod** GetCallTree(tree, skipRepeated) -> bool


Return a snapshot of memory usage.


Returns a snapshot by writing into ``\\*tree`` . See the ``C`` \\*tree
structure for documentation. If ``Initialize()`` has not been called,
\ \\*tree is set to a rather blank structure (empty vectors, empty
strings, zero in all integral fields) and ``false`` is returned;
otherwise, ``\\*tree`` is set with the contents of the current memory
snapshot and ``true`` is returned. It is fine to call this function on
the same ``\\*tree`` instance; each call simply overwrites the data
from the last call. If /p skipRepeated is ``true`` , then any repeated
callsite is skipped. See the ``CallTree`` documentation for more
details.


Parameters
----------
tree : CallTree

skipRepeated : bool


"""
   result["MallocTag"].SetDebugMatchList.func_doc = """**classmethod** SetDebugMatchList(matchList) -> None


Sets the tags to trap in the debugger.


When memory is allocated or freed for any tag that matches
``matchList`` the debugger trap is invoked. If a debugger is attached
the program will stop in the debugger, otherwise the program will
continue to run. See ``ArchDebuggerTrap()`` and ``ArchDebuggerWait()``
.

``matchList`` is a comma, tab or newline separated list of malloc tag
names. The names can have internal spaces but leading and trailing
spaces are stripped. If a name ends in'\\*'then the suffix is
wildcarded. A name can have a leading'-'or'+'to prevent or allow a
match. Each name is considered in order and later matches override
earlier matches. For example,'Csd\\*, -CsdScene::_Populate\\*,
+CsdScene::_PopulatePrimCacheLocal'matches any malloc tag starting
with'Csd'but nothing starting
with'CsdScene::_Populate'except'CsdScene::_PopulatePrimCacheLocal'.
Use the empty string to disable debugging traps.


Parameters
----------
matchList : str


"""
   result["MallocTag"].SetCapturedMallocStacksMatchList.func_doc = """**classmethod** SetCapturedMallocStacksMatchList(matchList) -> None


Sets the tags to trace.


When memory is allocated for any tag that matches ``matchList`` a
stack trace is recorded. When that memory is released the stack trace
is discarded. Clients can call ``GetCapturedMallocStacks()`` to get a
list of all recorded stack traces. This is useful for finding leaks.

Traces recorded for any tag that will no longer be matched are
discarded by this call. Traces recorded for tags that continue to be
matched are retained.

``matchList`` is a comma, tab or newline separated list of malloc tag
names. The names can have internal spaces but leading and trailing
spaces are stripped. If a name ends in'\\*'then the suffix is
wildcarded. A name can have a leading'-'or'+'to prevent or allow a
match. Each name is considered in order and later matches override
earlier matches. For example,'Csd\\*, -CsdScene::_Populate\\*,
+CsdScene::_PopulatePrimCacheLocal'matches any malloc tag starting
with'Csd'but nothing starting
with'CsdScene::_Populate'except'CsdScene::_PopulatePrimCacheLocal'.
Use the empty string to disable stack capturing.


Parameters
----------
matchList : str


"""
   result["Notice"].__doc__ = """
The base class for objects used to notify interested parties
(listeners) when events have occurred. The TfNotice class also serves
as a container for various dispatching routines such as Register() and
Send() .

See The TfNotice Notification System in the C++ API reference for a
detailed description of the notification system.

Python Example: Registering For and Sending
===========================================

Notices The following code provides examples of how to set up a Notice
listener connection (represented in Python by the Listener class),
including creating and sending notices, registering to receive
notices, and breaking a listener connection.

.. code-block:: text

  # To create a new notice type:
  class APythonClass(Tf.Notice):
      '''TfNotice sent when APythonClass does something of interest.'''
      pass
  Tf.Type.Define(APythonClass)
  
  # An interested listener can register to receive notices from all
  # senders, or from a particular type of sender.
  
  # To send a notice to all registered listeners:;
  APythonClass().SendGlobally()
  
  # To send a notice to listeners who register with a specific sender:
  APythonClass().Send(self)
  
  # To register for the notice from any sender:
  my_listener = Tf.Notice.RegisterGlobally(APythonClass, self._HandleNotice)
  
  # To register for the notice from a specific sender
  my_listener = Tf.Notice.Register(APythonClass, self._HandleNotice, sender)
  
  def _HandleNotice(self, notice, sender):
     '''callback function for handling a notice'''
     # do something when the notice arrives
  
  # To revoke interest in a notice
  my_listener.Revoke()

For more on using notices in Python, see the Editor With Notices
tutorial.

"""
   result["PyModuleWasLoaded"].__doc__ = """
A *TfNotice* that is sent when a script module is loaded. Since many
modules may be loaded at once, listeners are encouraged to defer work
triggered by this notice to the end of an application iteration. This,
of course, is good practice in general.

"""
   result["RefPtrTracker"].__doc__ = """
Provides tracking of ``TfRefPtr`` objects to particular objects.

Clients can enable, at compile time, tracking of ``TfRefPtr`` objects
that point to particular instances of classes derived from
``TfRefBase`` . This is useful if you have a ref counted object with a
ref count that should've gone to zero but didn't. This tracker can
tell you every ``TfRefPtr`` that's holding the ``TfRefBase`` and a
stack trace where it was created or last assigned to.

Clients can get a report of all watched instances and how many
``TfRefPtr`` objects are holding them using
``ReportAllWatchedCounts()`` (in python use ``Tf.RefPtrTracker()``
.GetAllWatchedCountsReport()). You can see all of the stack traces
using ``ReportAllTraces()`` (in python use ``Tf.RefPtrTracker()``
.GetAllTracesReport()).

Clients will typically enable tracking using code like this:

.. code-block:: text

  #include "pxr/base/tf/refPtrTracker.h"
  
  class MyRefBaseType;
  typedef TfRefPtr<MyRefBaseType> MyRefBaseTypeRefPtr;
  
  TF_DECLARE_REFPTR_TRACK(MyRefBaseType);
  
  class MyRefBaseType {
  \\.\\.\\.
  public:
      static bool _ShouldWatch(const MyRefBaseType\\*);
  \\.\\.\\.
  };
  
  TF_DEFINE_REFPTR_TRACK(MyRefBaseType, MyRefBaseType::_ShouldWatch);

Note that the ``TF_DECLARE_REFPTR_TRACK()`` macro must be invoked
before any use of the ``MyRefBaseTypeRefPtr`` type.

The ``MyRefBaseType::_ShouldWatch()`` function returns ``true`` if the
given instance of ``MyRefBaseType`` should be tracked. You can also
use ``TfRefPtrTracker::WatchAll()`` to watch every instance (but that
might use a lot of memory and time).

If you have a base type, ``B`` , and a derived type, ``D`` , and you
hold instances of ``D`` in a ``TfRefPtr < ``B>```` (i.e. a pointer to
the base) then you must track both type ``B`` and type ``D`` . But you
can use ``TfRefPtrTracker::WatchNone()`` when tracking ``B`` if you're
not interested in instances of ``B`` .

"""
   result["RefPtrTracker"].__init__.func_doc = """__init__()



"""
   result["ScopeDescription"].__doc__ = """
This class is used to provide high-level descriptions about scopes of
execution that could possibly block, or to provide relevant
information about high-level action that would be useful in a crash
report.

This class is reasonably fast to use, especially if the message
strings are not dynamically created, however it should not be used in
very highly performance sensitive contexts. The cost to push & pop is
essentially a TLS lookup plus a couple of atomic operations.

"""
   result["ScopeDescription"].__init__.func_doc = """__init__()




----------------------------------------------------------------------

__init__(arg1)


Parameters
----------
arg1 : ScopeDescription



----------------------------------------------------------------------

__init__(description, context)


Construct with a description.


Push *description* on the stack of descriptions for this thread.
Caller guarantees that the string ``description`` lives at least as
long as this TfScopeDescription object.


Parameters
----------
description : str

context : CallContext



----------------------------------------------------------------------

__init__(description, context)


Construct with a description.


Push *description* on the stack of descriptions for this thread. This
object adopts ownership of the rvalue ``description`` .


Parameters
----------
description : str

context : CallContext



----------------------------------------------------------------------

__init__(description, context)


Construct with a description.


Push *description* on the stack of descriptions for this thread.
Caller guarantees that the string ``description`` lives at least as
long as this TfScopeDescription object.


Parameters
----------
description : char

context : CallContext


"""
   result["ScopeDescription"].SetDescription.func_doc = """SetDescription(description) -> None


Replace the description stack entry for this scope description.


Caller guarantees that the string ``description`` lives at least as
long as this TfScopeDescription object.


Parameters
----------
description : str



----------------------------------------------------------------------

SetDescription(description) -> None


Replace the description stack entry for this scope description.


This object adopts ownership of the rvalue ``description`` .


Parameters
----------
description : str



----------------------------------------------------------------------

SetDescription(description) -> None


Replace the description stack entry for this scope description.


Caller guarantees that the string ``description`` lives at least as
long as this TfScopeDescription object.


Parameters
----------
description : char


"""
   result["ScriptModuleLoader"].__doc__ = """
Provides low-level facilities for shared modules with script
bindings to register themselves with their dependences, and provides a
mechanism whereby those script modules will be loaded when necessary.
Currently, this is when one of our script modules is loaded, when
TfPyInitialize is called, and when Plug opens shared modules.

Generally, user code will not make use of this.

"""
   result["ScriptModuleLoader"].GetModuleNames.func_doc = """GetModuleNames() -> list[str]


Return a list of all currently known modules in a valid dependency
order.



"""
   result["ScriptModuleLoader"].GetModulesDict.func_doc = """GetModulesDict() -> python.dict


Return a python dict containing all currently known modules under
their canonical names.



"""
   result["ScriptModuleLoader"].WriteDotFile.func_doc = """WriteDotFile(file) -> None


Write a graphviz dot-file for the dependency graph of all.


currently known modules/modules to *file*.


Parameters
----------
file : str


"""
   result["ScriptModuleLoader"].__init__.func_doc = """__init__()



"""
   result["Singleton"].__doc__ = """
Manage a single instance of an object (see

Typical Use for a canonical example).

"""
   result["Stopwatch"].__doc__ = """
Low-cost, high-resolution timer datatype.

A ``TfStopwatch`` can be used to perform very precise timings at
runtime, even in very tight loops. The cost of"starting"or"stopping"a
``TfStopwatch`` is very small: approximately 40 nanoseconds on a 900
Mhz Pentium III Linux box, 300 nanoseconds on a 400 Mhz Sun, and 200
nanoseconds on a 250 Mhz SGI.

Note that this class is not thread-safe: if you need to take timings
in a multi-threaded region of a process, let each thread have its own
``TfStopwatch`` and then combine results using the ``AddFrom()``
member function.

"""
   result["Stopwatch"].Start.func_doc = """Start() -> None


Record the current time for use by the next ``Stop()`` call.


The ``Start()`` function records the current time. A subsequent call
to ``Start()`` before a call to ``Stop()`` simply records a later
current time, but does not change the accumulated time of the
``TfStopwatch`` .



"""
   result["Stopwatch"].Stop.func_doc = """Stop() -> None


Increases the accumulated time stored in the ``TfStopwatch`` .


The ``Stop()`` function increases the accumulated time by the duration
between the current time and the last time recorded by a ``Start()``
call. A subsequent call to ``Stop()`` before another call to
``Start()`` will therefore double-count time and throw off the
results.

A ``TfStopwatch`` also counts the number of samples it has taken.
The"sample count"is simply the number of times that ``Stop()`` has
been called.



"""
   result["Stopwatch"].Reset.func_doc = """Reset() -> None


Resets the accumulated time and the sample count to zero.



"""
   result["Stopwatch"].AddFrom.func_doc = """AddFrom(t) -> None


Adds the accumulated time and sample count from ``t`` into the
``TfStopwatch`` .


If you have several timers taking measurements, and you wish to
combine them together, you can add one timer's results into another;
for example, ``t2.AddFrom(t1)`` will add ``t1`` 's time and sample
count into ``t2`` .


Parameters
----------
t : Stopwatch


"""
   result["TemplateString"].__doc__ = """
TfTemplateString provides simple string substitutions based on named
placeholders. Instead of the''-based substitutions used by printf,
template strings use'$'-based substitutions, using the following
rules:

   - "$$"is replaced with a single"$"

   - "$identifier"names a substitution placeholder matching a mapping
     key of"identifier". The first non-identifier character after
     the"$"character terminates the placeholder specification.

   - "${identifier}"is equivalent to"$identifier". It is required when
     valid identifier characters follow the placeholder but are not part of
     the placeholder, such as"${noun}ification".

   - An identifier is a sequence of characters"[A-Z][a-z][0-9]_".
     *TfTemplateString* is immutable: once one is created it may not be
     modified. *TfTemplateString* is fast to copy, since it shares state
     internally between copies. *TfTemplateString* is thread-safe. It may
     be read freely by multiple threads concurrently.

"""
   result["TemplateString"].__init__.func_doc = """__init__()


Constructs a new template string.




----------------------------------------------------------------------

__init__(template_)


Constructs a new template string.


Parameters
----------
template_ : str


"""
   result["TemplateString"].Substitute.func_doc = """Substitute(arg1) -> str


Performs the template substitution, returning a new string.


The mapping contains keys which match the placeholders in the
template. If a placeholder is found for which no mapping is present, a
coding error is raised.


Parameters
----------
arg1 : Mapping


"""
   result["TemplateString"].SafeSubstitute.func_doc = """SafeSubstitute(arg1) -> str


Like Substitute() , except that if placeholders are missing from the
mapping, instead of raising a coding error, the original placeholder
will appear in the resulting string intact.


Parameters
----------
arg1 : Mapping


"""
   result["TemplateString"].GetEmptyMapping.func_doc = """GetEmptyMapping() -> Mapping


Returns an empty mapping for the current template.


This method first calls IsValid to ensure that the template is valid.



"""
   result["TemplateString"].GetParseErrors.func_doc = """GetParseErrors() -> list[str]


Returns any error messages generated during template parsing.



"""
   result["Type"].__doc__ = """
TfType represents a dynamic runtime type.

TfTypes are created and discovered at runtime, rather than compile
time.

Features:

   - unique typename

   - safe across DSO boundaries

   - can represent C++ types, pure Python types, or Python subclasses
     of wrapped C++ types

   - lightweight value semantics  you can copy and default construct
     TfType, unlike ``std::type_info`` .

   - totally ordered  can use as a ``std::map`` key


"""
   result["Type"].FindDerivedByName.func_doc = """**classmethod** FindDerivedByName(name) -> Type


Retrieve the ``TfType`` that derives from this type and has the given
alias or typename.



AddAlias


Parameters
----------
name : str



----------------------------------------------------------------------

FindDerivedByName(name) -> Type


Retrieve the ``TfType`` that derives from BASE and has the given alias
or typename.


This is a convenience method, and is equivalent to:

.. code-block:: text

  TfType::Find<BASE>().FindDerivedByName(name)



Parameters
----------
name : str


"""
   result["Type"].Find.func_doc = """**classmethod** Find() -> Type


Retrieve the ``TfType`` corresponding to type ``T`` .


The type ``T`` must have been declared or defined in the type system
or the ``TfType`` corresponding to an unknown type is returned.

IsUnknown()




----------------------------------------------------------------------

Find(obj) -> Type


Retrieve the ``TfType`` corresponding to ``obj`` .


The ``TfType`` corresponding to the actual object represented by
``obj`` is returned; this may not be the object returned by
``TfType::Find<T>()`` if ``T`` is a polymorphic type.

This works for Python subclasses of the C++ type ``T`` as well, as
long as ``T`` has been wrapped using TfPyPolymorphic.

Of course, the object's type must have been declared or defined in the
type system or the ``TfType`` corresponding to an unknown type is
returned.

IsUnknown()


Parameters
----------
obj : T



----------------------------------------------------------------------

Find(t) -> Type


Retrieve the ``TfType`` corresponding to an obj with the given
``type_info`` .


Parameters
----------
t : type_info


"""
   result["Type"].FindByName.func_doc = """**classmethod** FindByName(name) -> Type


Retrieve the ``TfType`` corresponding to the given ``name`` .


Every type defined in the TfType system has a unique, implementation
independent name. In addition, aliases can be added to identify a type
underneath a specific base type; see TfType::AddAlias() . The given
name will first be tried as an alias under the root type, and
subsequently as a typename.

This method is equivalent to:

.. code-block:: text

  TfType::GetRoot().FindDerivedByName(name)

For any object ``obj`` ,

.. code-block:: text

  Find(obj) == FindByName( Find(obj).GetTypeName() )



Parameters
----------
name : str


"""
   result["Type"].GetAliases.func_doc = """GetAliases(derivedType) -> list[str]


Returns a vector of the aliases registered for the derivedType under
this, the base type.



AddAlias()


Parameters
----------
derivedType : Type


"""
   result["Type"].GetAllDerivedTypes.func_doc = """GetAllDerivedTypes(result) -> None


Return the set of all types derived (directly or indirectly) from this
type.


Parameters
----------
result : set[Type]


"""
   result["Type"].GetAllAncestorTypes.func_doc = """GetAllAncestorTypes(result) -> None


Build a vector of all ancestor types inherited by this type.


The starting type is itself included, as the first element of the
results vector.

Types are given in"C3"resolution order, as used for new-style classes
starting in Python 2.3. This algorithm is more complicated than a
simple depth-first traversal of base classes, in order to prevent some
subtle errors with multiple-inheritance. See the references below for
more background.

This can be expensive; consider caching the results. TfType does not
cache this itself since it is not needed internally.

Guido van Rossum."Unifying types and classes in Python 2.2: Method
resolution order."
http://www.python.org/download/releases/2.2.2/descrintro/#mro

Barrett, Cassels, Haahr, Moon, Playford, Withington."A Monotonic
Superclass Linearization for Dylan."OOPSLA 96.
http://www.webcom.com/haahr/dylan/linearization-oopsla96.html


Parameters
----------
result : list[Type]


"""
   result["Type"].IsA.func_doc = """IsA(queryType) -> bool


Return true if this type is the same as or derived from ``queryType``
.


If ``queryType`` is unknown, this always returns ``false`` .


Parameters
----------
queryType : Type



----------------------------------------------------------------------

IsA() -> bool


Return true if this type is the same as or derived from T.


This is equivalent to:

.. code-block:: text

  IsA(Find<T>())




"""
   result["Type"].GetRoot.func_doc = """**classmethod** GetRoot() -> Type


Return the root type of the type hierarchy.


All known types derive (directly or indirectly) from the root. If a
type is specified with no bases, it is implicitly considered to derive
from the root type.



"""
   result["Type"].AddAlias.func_doc = """**classmethod** AddAlias(base, name) -> None


Add an alias name for this type under the given base type.


Aliases are similar to typedefs in C++: they provide an alternate name
for a type. The alias is defined with respect to the given ``base``
type. Aliases must be unique with respect to both other aliases
beneath that base type and names of derived types of that base.


Parameters
----------
base : Type

name : str



----------------------------------------------------------------------

AddAlias(name) -> None


Add an alias for DERIVED beneath BASE.


This is a convenience method, that declares both DERIVED and BASE as
TfTypes before adding the alias.


Parameters
----------
name : str


"""
   result["Type"].Define.func_doc = """**classmethod** Define() -> Type


Define a TfType with the given C++ type T and C++ base types B.


Each of the base types will be declared (but not defined) as TfTypes
if they have not already been.

The typeName of the created TfType will be the canonical demangled
RTTI type name, as defined by GetCanonicalTypeName() .

It is an error to attempt to define a type that has already been
defined.




----------------------------------------------------------------------

Define() -> Type


Define a TfType with the given C++ type T and no bases.


See the other Define() template for more details.

C++ does not allow default template arguments for function templates,
so we provide this separate definition for the case of no bases.



"""
   result["Type"].__init__.func_doc = """__init__()


Construct an TfType representing an unknown type.


To actually register a new type with the TfType system, see
TfType::Declare() .

Note that this always holds true:

.. code-block:: text

  TfType().IsUnknown() == true





----------------------------------------------------------------------

__init__(info)


Parameters
----------
info : _TypeInfo


"""
   result["Warning"].__doc__ = """
Represents an object that contains information about a warning.

See Guide To Diagnostic Facilities in the C++ API reference for a
detailed description of the warning issuing API. For a example of how
to post a warning, see ``TF_WARN()`` , also in the C++ API reference.

In the Python API, you can issue a warning with Tf.Warn().

"""
   result["Notice"].__doc__ = """"""
   result["ReportActiveErrorMarks"].func_doc = """ReportActiveErrorMarks() -> None


Report current TfErrorMark instances and the stack traces that created
them to stdout for debugging purposes.


To call this function, set _enableTfErrorMarkStackTraces in
errorMark.cpp and enable the TF_ERROR_MARK_TRACKING TfDebug code.



"""
   result["Error"].__doc__ = """"""
   result["Warning"].__doc__ = """"""
   result["InstallTerminateAndCrashHandlers"].func_doc = """InstallTerminateAndCrashHandlers() -> None


(Re)install Tf's crash handler.


This should not generally need to be called since Tf does this itself
when loaded. However, when run in 3rd party environments that install
their own signal handlers, possibly overriding Tf's, this provides a
way to reinstall them, in hopes that they'll stick.

This calls std::set_terminate() and installs signal handlers for
SIGSEGV, SIGBUS, SIGFPE, and SIGABRT.



"""
   result["MallocTag"].__doc__ = """"""
   result["Singleton"].__doc__ = """"""
   result["Enum"].__doc__ = """"""
   result["Debug"].__doc__ = """"""
   result["TemplateString"].__doc__ = """"""
   result["StringToDouble"].func_doc = """StringToDouble(txt) -> float


Converts text string to double.


This method converts strings to floating point numbers. It is similar
to libc's atof(), but performs the conversion much more quickly.

It expects somewhat valid input: it will continue parsing the input
until it hits an unrecognized character, as described by the regexp
below, and at that point will return the results up to that point.

(-?[0-9]+(.[0-9]\\*)?|-?.[0-9]+)([eE][-+]?[0-9]+)?

It will not check to see if there is any input at all, or whitespace
after the digits. Ie: TfStringToDouble("") == 0.0
TfStringToDouble("blah") == 0.0 TfStringToDouble("-") == -0.0
TfStringToDouble("1.2foo") == 1.2

``TfStringToDouble`` is a wrapper around the extern-c TfStringToDouble


Parameters
----------
txt : str



----------------------------------------------------------------------

StringToDouble(text) -> float


This is an overloaded member function, provided for convenience. It
differs from the above function only in what argument(s) it accepts.


Parameters
----------
text : str



----------------------------------------------------------------------

StringToDouble(text, len) -> float


This is an overloaded member function, provided for convenience. It
differs from the above function only in what argument(s) it accepts.


Parameters
----------
text : str

len : int


"""
   result["StringToLong"].func_doc = """StringToLong(txt, outOfRange) -> long


Convert a sequence of digits in ``txt`` to a long int value.


Caller is responsible for ensuring that ``txt`` has content matching:

.. code-block:: text

  -?[0-9]+

If the digit sequence's value is out of range, set ``\\*outOfRange``
to true (if ``outOfRange`` is not None) and return either
std::numeric_limits<long>::min() or max(), whichever is closest to the
true value.


Parameters
----------
txt : str

outOfRange : bool



----------------------------------------------------------------------

StringToLong(txt, outOfRange) -> long


This is an overloaded member function, provided for convenience. It
differs from the above function only in what argument(s) it accepts.


Parameters
----------
txt : str

outOfRange : bool


"""
   result["StringToULong"].func_doc = """StringToULong(txt, outOfRange) -> int


Convert a sequence of digits in ``txt`` to an unsigned long value.


Caller is responsible for ensuring that ``txt`` has content matching:

.. code-block:: text

  [0-9]+

If the digit sequence's value is out of range, set ``\\*outOfRange``
to true (if ``outOfRange`` is not None) and return
std::numeric_limits<unsignedlong>::max().


Parameters
----------
txt : str

outOfRange : bool



----------------------------------------------------------------------

StringToULong(txt, outOfRange) -> int


This is an overloaded member function, provided for convenience. It
differs from the above function only in what argument(s) it accepts.


Parameters
----------
txt : str

outOfRange : bool


"""
   result["StringSplit"].func_doc = """StringSplit(src, separator) -> list[str]


Breaks the given string apart, returning a vector of strings.


The string ``source`` is broken apart into individual words, where a
word is delimited by the string ``separator`` . This function behaves
like pythons string split method.


Parameters
----------
src : str

separator : str


"""
   result["IsValidIdentifier"].func_doc = """IsValidIdentifier(identifier) -> bool


Test whether *identifier* is valid.


An identifier is valid if it follows the C/Python identifier
convention; that is, it must be at least one character long, must
start with a letter or underscore, and must contain only letters,
underscores, and numerals.


Parameters
----------
identifier : str


"""
   result["MakeValidIdentifier"].func_doc = """MakeValidIdentifier(in) -> str


Produce a valid identifier (see TfIsValidIdentifier) from ``in`` by
replacing invalid characters with'_'.


If ``in`` is empty, return"_".


Parameters
----------
in : str


"""
   result["Stopwatch"].__doc__ = """"""
   result["CallContext"].file = property(result["CallContext"].file.fget, result["CallContext"].file.fset, result["CallContext"].file.fdel, """type : char

""")
   result["CallContext"].function = property(result["CallContext"].function.fget, result["CallContext"].function.fset, result["CallContext"].function.fdel, """type : char

""")
   result["CallContext"].line = property(result["CallContext"].line.fget, result["CallContext"].line.fset, result["CallContext"].line.fdel, """type : int

""")
   result["CallContext"].prettyFunction = property(result["CallContext"].prettyFunction.fget, result["CallContext"].prettyFunction.fset, result["CallContext"].prettyFunction.fdel, """type : char

""")
   result["PyModuleWasLoaded"].name.func_doc = """name() -> str


Return the name of the module that was loaded.



"""
   result["Stopwatch"].nanoseconds = property(result["Stopwatch"].nanoseconds.fget, result["Stopwatch"].nanoseconds.fset, result["Stopwatch"].nanoseconds.fdel, """type : int


Return the accumulated time in nanoseconds.


Note that this number can easily overflow a 32-bit counter, so take
care to save the result in an ``int64_t`` , and not a regular ``int``
or ``long`` .

""")
   result["Stopwatch"].microseconds = property(result["Stopwatch"].microseconds.fget, result["Stopwatch"].microseconds.fset, result["Stopwatch"].microseconds.fdel, """type : int


Return the accumulated time in microseconds.


Note that 45 minutes will overflow a 32-bit counter, so take care to
save the result in an ``int64_t`` , and not a regular ``int`` or
``long`` .

""")
   result["Stopwatch"].milliseconds = property(result["Stopwatch"].milliseconds.fget, result["Stopwatch"].milliseconds.fset, result["Stopwatch"].milliseconds.fdel, """type : int


Return the accumulated time in milliseconds.

""")
   result["Stopwatch"].sampleCount = property(result["Stopwatch"].sampleCount.fget, result["Stopwatch"].sampleCount.fset, result["Stopwatch"].sampleCount.fdel, """type : int


Return the current sample count.


The sample count, which is simply the number of calls to ``Stop()``
since creation or a call to ``Reset()`` , is useful for computing
average running times of a repeated task.

""")
   result["Stopwatch"].seconds = property(result["Stopwatch"].seconds.fget, result["Stopwatch"].seconds.fset, result["Stopwatch"].seconds.fdel, """type : float


Return the accumulated time in seconds as a ``double`` .

""")
   result["TemplateString"].template = property(result["TemplateString"].template.fget, result["TemplateString"].template.fset, result["TemplateString"].template.fdel, """type : str


Returns the template source string supplied to the constructor.

""")
   result["TemplateString"].valid = property(result["TemplateString"].valid.fget, result["TemplateString"].valid.fset, result["TemplateString"].valid.fdel, """type : bool


Returns true if the current template is well formed.


Empty templates are valid.

""")
   result["Type"].typeName = property(result["Type"].typeName.fget, result["Type"].typeName.fset, result["Type"].typeName.fdel, """type : str


Return the machine-independent name for this type.


This name is specified when the TfType is declared.

Declare()

""")
   result["Type"].pythonClass = property(result["Type"].pythonClass.fget, result["Type"].pythonClass.fset, result["Type"].pythonClass.fdel, """type : TfPyObjWrapper


Return the Python class object for this type.


If this type is unknown or has not yet had a Python class defined,
this will return ``None`` , as an empty ``TfPyObjWrapper``

DefinePythonClass()

""")
   result["Type"].baseTypes = property(result["Type"].baseTypes.fget, result["Type"].baseTypes.fset, result["Type"].baseTypes.fdel, """type : list[Type]


Return a vector of types from which this type was derived.

""")
   result["Type"].isUnknown = property(result["Type"].isUnknown.fget, result["Type"].isUnknown.fset, result["Type"].isUnknown.fdel, """type : bool


Return true if this is the unknown type, representing a type unknown
to the TfType system.


The unknown type does not derive from the root type, or any other
type.

""")
   result["Type"].isEnumType = property(result["Type"].isEnumType.fget, result["Type"].isEnumType.fset, result["Type"].isEnumType.fdel, """type : bool


Return true if this is an enum type.

""")
   result["Type"].isPlainOldDataType = property(result["Type"].isPlainOldDataType.fget, result["Type"].isPlainOldDataType.fset, result["Type"].isPlainOldDataType.fdel, """type : bool


Return true if this is a plain old data type, as defined by C++.

""")
   result["Type"].sizeof = property(result["Type"].sizeof.fget, result["Type"].sizeof.fset, result["Type"].sizeof.fdel, """type : int


Return the size required to hold an instance of this type on the stack
(does not include any heap allocated memory the instance uses).


This is what the C++ sizeof operator returns for the type, so this
value is not very useful for Python types (it will always be
sizeof(boost::python::object)).

""")