Standard

The package Standard provides global memory allocator and other basic services used by other OCCT components.

Custom buffer object implementing STL interface std::streambuf for streamed reading from allocated memory block. Implements minimal sub-set of methods for passing buffer to std::istream, including seek support.
This class can be used for creating a seekable input stream in cases, when the source data does not satisfies Reader requirements (non-seekable stream, compressed data) or represents an in-memory resource.
The memory itself is NOT managed by this class - it is up to the caller to ensure that passed memory pointer is not released during Standard_ArrayStreamBuffer lifetime.
Usage example:

constchar*theBuffer; constsize_ttheBufferLength; Standard_ArrayStreamBufferaStreamBuffer(theBuffer,theBufferLength); std::istreamaStream(&aStreamBuffer); TopoDS_ShapeaShape; BRep_BuilderaBuilder; BRepTools::Read(aShape,aStream,aBuilder);

We check _GNU_SOURCE for glibc extensions here and it is always defined by g++ compiler.
This class intended to temporary switch C locale and logically equivalent to setlocale(LC_ALL, "C"). It is intended to format text regardless of user locale settings (for import/export functionality). Thus following calls to Sprintf, atoi and other functions will use "C" locale. Destructor of this class will return original locale.
Notice that this functionality is platform dependent and intended only to workaround alien code that doesn't setup locale correctly.
Internally you should prefer more portable C++ locale interfaces or OCCT wrappers to some C functions like Sprintf, Atof, Strtod.

This is boolean flag intended for communication between threads. One thread sets this flag to TRUE to indicate some event happened and another thread either waits this event or checks periodically its state to perform job.
This class provides interface similar to WinAPI Event objects.

Type for storing a dump value with the stream position.

Forms the root of the entire exception hierarchy. Inherits from std::exception and implements what() interface.

Template defining a class derived from the specified base class and Standard_Transient, and supporting OCCT RTTI.
This provides possibility to use Handes for types not initially intended to be dynamically allocated.
Current limitation is that only copy and constructors with 1-3 arguments are defined, calling those of the argument class (default constructor must be available). It can be improved when perfect forwarding of template arguments is supported by all compilers used for OCCT.
The intent is similar to std::make_shared<> in STL, except that this implementation defines a separate type.

Standard_OutOfMemory exception is defined explicitly and not by macro DEFINE_STANDARD_EXCEPTION, to avoid necessity of dynamic memory allocations during throwing and stack unwinding:

• message string is stored as field, not allocated dynamically (storable message length is limited by buffer size)
  The reason is that in out-of-memory condition any memory allocation can fail, thus use of operator new for allocation of new exception instance is dangerous (can cause recursion until stack overflow, see #24836).

Root of "persistent" classes, a legacy support of object oriented databases, now outdated.

Auxiliary tool for buffered reading from input stream within chunks of constant size.

Auxiliary tool for buffered reading of lines from input stream.

Abstract class which forms the root of the entire Transient class hierarchy.

This class provides legacy interface (type descriptor) to run-time type information (RTTI) for OCCT classes inheriting from Standard_Transient.
In addition to features provided by standard C++ RTTI (type_info), Standard_Type allows passing descriptor as an object and using it for analysis of the type:

• get descriptor of a parent class
• get user-defined name of the class
• get size of the object
  Use static template method Instance() to get descriptor for a given type. Objects supporting OCCT RTTI return their type descriptor by method DynamicType().
  To be usable with OCCT type system, the class should provide:
• typedef base_type to its base class in the hierarchy
• method get_type_name() returning programmer-defined name of the class (as a statically allocated constant C string or string literal)
  Note that user-defined name is used since typeid.name() is usually mangled in compiler-dependent way.
  Only single chain of inheritance is supported, with a root base class Standard_Transient.