C3D Kernel  104598
Classes | Defines | Typedefs | Enumerations | Functions | Variables
Work with Streams
Templates and Serializations Library
Collaboration diagram for Work with Streams:

Classes

class  Cluster
 Cluster. More...
class  FileSpace
 File space. More...
struct  ClusterReference
class  iobuf_Seq
 Stream buffer. More...
class  membuf
 Memory stream buffer. More...
class  ClassDescriptor
 Packed class name. More...
class  TapeBase
 Base class for stream classes. More...
class  TapeClass
 "Wrapper" for one stream class. More...
class  TapeRegistrator
 Array for object registration while reading/writing. More...
class  TapeRegistratorEx
 Array for registration of objects with information about reading/writing position. More...
class  tape
 The base class of the stream for implementation of reading and writing. More...
class  reader
 Stream for reading. More...
class  ScopedReadProgress
 Scoped progress indicator for reader. More...
class  reader_ex
 Stream for reading from several FileSpaces by given positions in clusters. More...
class  writer
 Stream for writing. More...
class  writer_ex
 Stream for writing to several FileSpaces. More...
class  rw
 Stream for reading and writing. More...
class  TapeManager
 Stream manager. More...
struct  TapeClassContainer
 Array of stream classes registration. More...
class  c3d::IModelTreeNode
 Tree node. More...
class  c3d::IModelTree
 Generic tree. More...
class  VersionContainer
 Container of versions. More...
class  c3d::ItemDataBase
class  c3d::ItemDataBool
class  c3d::ItemDataInteger
class  c3d::ItemDataDouble
class  c3d::ItemDataString
class  c3d::ItemAttrBool
class  c3d::ItemAttrInteger
class  c3d::ItemAttrDouble
class  c3d::ItemAttrString
class  c3d::ItemAttrInt64
class  c3d::ItemAttrIdentifier
class  c3d::ItemAttrColor
class  c3d::ItemAttrWidth
class  c3d::ItemAttrStyle
class  c3d::ItemAttrSelected
class  c3d::ItemAttrVisible
class  c3d::ItemAttrChanged
class  c3d::ItemAttrDencity
class  c3d::ItemAttrUpdateStamp
class  c3d::ItemAttrAnchor
class  c3d::UserDataMap
 A container for user data of a tree node. More...
struct  c3d::MbItemData
 Tree node data. More...
class  c3d::MbTreeNode
 Tree node. More...
class  c3d::MbModelTree
 Tree of geometric model. More...

Defines

#define EOF   (-1)
 End of file.
#define DECLARE_PERSISTENT_OPS(Class)
 Friend operators of reading and writing of pointers and references.
#define DECLARE_PERSISTENT_OPS_B(Class)
 Declaration of operators of reading and writing of pointers and references.
#define IMPL_PERSISTENT_OPS(Class)
 Operators of reading and writing of pointers and references.
#define DECLARE_PERSISTENT_RO_OPS(Class)
 Operators of reading pointers and references for a class without writing.
#define DECLARE_PERSISTENT_FUNCS(Class)
 Functions of reading and writing.
#define DECLARE_PERSISTENT_RO_FUNCS(Class)
 Function of reading for class without writing.
#define DECLARE_CLASS_DESC_FUNC(Class)
#define IMP_CLASS_DESC_FUNC(AppID, Class)
#define DECLARE_PERSISTENT_CTOR(Class)
 Constructor for a stream class.
#define IMP_PERSISTENT_CTOR(Class)   Class::Class( TapeInit ) {}
 Constructor for a stream class.
#define IMP_PERSISTENT_CTOR1(Class, Base)   Class::Class( TapeInit ) : Base( tapeInit ) {}
 Constructor for a class with one stream base.
#define IMP_PERSISTENT_CTOR2(Class, Base1, Base2)   Class::Class( TapeInit ) : Base1( tapeInit ), Base2( tapeInit ) {}
 Constructor for a class with two stream bases.
#define IMP_PERSISTENT_REGISTRATION(AppID, Class)
 Construction of a new instance of the class.
#define IMP_PERSISTENT_RO_REGISTRATION(AppID, Class)
 Construction of a new instance of the class for a class without writing.
#define __OVERLOAD_MEMORY_ALLOCATE_FREE_
#define DECLARE_NEW_DELETE_CLASS(Class)
 Declaration of functions new, delete and access operators.
#define IMP_PERSISTENT_NEW_DELETE_CLASS(Class)
 Implementation of functions new, delete and access operators.
#define DECLARE_NEW_DELETE_CLASS_EX(Class)
#define IMP_PERSISTENT_NEW_DELETE_CLASS_EX(Class)
#define DECLARE_PERSISTENT_CLASS(Class)
 Declaration of class Class as a stream one.
#define DECLARE_PERSISTENT_CLASS_NEW_DEL(Class)
 Analog of DECLARE_PERSISTENT_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads.
#define IMP_PERSISTENT_CLASS(AppID, Class)
 Implementation of DECLARE_PERSISTENT_CLASS declaration.
#define IMP_PERSISTENT_CLASS_NEW_DEL(AppID, Class)
 Analog of IMP_PERSISTENT_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads.
#define IMP_PERSISTENT_RO_CLASS_NEW_DEL(AppID, Class)
 Analog of IMP_PERSISTENT_RO_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads.
#define IMP_PERSISTENT_CLASS_FROM_BASE_NEW_DEL(AppID, Class, Base)
 Analog of IMP_PERSISTENT_CLASS_FROM_BASE macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads.
#define IMP_PERSISTENT_CLASS_WD_NEW_DEL(AppID, Class)
 Analog of IMP_PERSISTENT_CLASS_WD macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads.

Typedefs

typedef TapeBase *CALL_DECLARATION BUILD_FUNC (void)
 Template of function of a new instance creation.
typedef void *CALL_DECLARATION CAST_FUNC (const TapeBase *)
 Template of conversion function.
typedef void *typedef void (CALL_DECLARATION *WRITE_FUNC)(writer &out
 Template of instance writing function.

Enumerations

enum  RegistrableRec { noRegistrable, registrable }
 Types of objects registration. More...
enum  TapeInit { tapeInit }
 The objects initialization types. More...
enum  TapePointerType {
  tpt_Null = 0x00, tpt_Indexed16 = 0x01, tpt_Object = 0x02, tpt_Indexed8 = 0x03,
  tpt_Indexed32 = 0x04, tpt_Indexed64 = 0x05, tpt_DetachedObject = 0x06, tpt_ObjectCatalog = 0x07
}
 Methods of writing pointers. More...
enum  c3d::MbeItemDataType {
  idtBool, idtInteger, idtDouble, idtString,
  idtAttrBool, idtAttrInt, idtAttrDouble, idtAttrString,
  idtAttrInt64, idtAttrIdentifier, idtAttrColor, idtAttrWidth,
  idtAttrStyle, idtAttrSelected, idtAttrVisible, idtAttrChanged,
  idtAttrDencity, idtAttrUpdateStamp, idtAttrAnchor, idtAttrVisual,
  idtAttrWireCount, idtAttrName, idtAttrGeom, idtAttrStampRib,
  idtAttrModelInfo, idtAttrPersonOrganizationInfo, idtAttrProductInfo, idtAttrSTEPTextDescription,
  idtAttrSTEPReferenceHolder, idtAttrBinary, idtCount
}

Functions

bool IsEqualSArrayItems (const Cluster &, const Cluster &)
size_t LenCOUNT (VERSION version)
 Length of size_t data in the stream.
size_t SizeOfFileSpace (VERSION version, size_t cnt, bool calcFull)
 Length of FileSpace data in stream of the specified version.
size_t getMemLen (const Cluster &c, VERSION)
 Size of cluster's data.
size_t getMemLen (const FileSpace &s, VERSION version)
 The file data size.
bool IsGoodFile (const FileSpace &file, const iobuf_Seq &owner)
 Check the cluster array of the file.
iobufcreateiobuf (const TCHAR *fileName)
 Read the buffer from the disk.
bool writeiobuftodisk (const TCHAR *fileName, membuf &buf)
 Write the buffer to the disk.
typedef void (CALL_DECLARATION *READ_FUNC)(reader &in
template<class Base >
void ReadBase (reader &in, Base *base)
 Function of reading the base class.
template<class Base >
void WriteBase (writer &out, const Base *base)
 Function of writing the base class.
template<class Base >
void ReadVBase (reader &in, Base *base)
 Function of reading of a virtual base class.
template<class Base >
void WriteVBase (writer &out, const Base *base)
 Function of writing of a virtual base class.
const char * pureName (const char *name)
 Deleting of spaces and records before spaces.
uint16 hash (const char *name)
 Pack the string (class name) into uint16.
writeroperator<< (writer &ps, bool i)
 Writing bool to the stream.
readeroperator>> (reader &ps, bool &i)
 Reading of bool to the stream.
writeroperator<< (writer &ps, signed int i)
 Writing signed int to the stream.
writeroperator<< (writer &ps, unsigned int i)
 Writing unsigned int to the stream.
readeroperator>> (reader &ps, signed int &i)
 Reading signed int to the stream.
readeroperator>> (reader &ps, unsigned int &i)
 Reading unsigned int to the stream.
writeroperator<< (writer &ps, int64 val)
 Writing int32 to the stream.
readeroperator>> (reader &ps, int64 &val)
 Reading int64 to the stream.
readeroperator>> (reader &ps, signed char &ch)
 Reading signed char to the stream.
readeroperator>> (reader &ps, unsigned char &ch)
 Reading unsigned char to the stream.
readeroperator>> (reader &ps, char &ch)
 Reading char to the stream.
readeroperator>> (reader &ps, signed short &sh)
 Reading signed short to the stream.
readeroperator>> (reader &ps, unsigned short &sh)
 Reading unsigned short to the stream.
readeroperator>> (reader &ps, float &f)
 Reading float to the stream.
readeroperator>> (reader &ps, double &d)
 Reading double to the stream.
readeroperator>> (reader &ps, long double &l)
 Reading long double from the stream.
template<class _Class >
readeroperator>> (reader &ps, SPtr< _Class > &sPtr)
 Reading a smart pointer from the stream.
template<class _Class >
writeroperator<< (writer &ps, const SPtr< _Class > &sPtr)
 Writing a smart pointer to the stream.
writeroperator<< (writer &ps, signed char ch)
 Write signed char to the stream.
writeroperator<< (writer &ps, unsigned char ch)
 Write unsigned char to the stream.
writeroperator<< (writer &ps, char ch)
 Write char to the stream.
writeroperator<< (writer &ps, signed short sh)
 Write signed short to the stream.
writeroperator<< (writer &ps, unsigned short sh)
 Write unsigned short to the stream.
writeroperator<< (writer &ps, float f)
 Write float to the stream.
writeroperator<< (writer &ps, const double &d)
 Write double to the stream.
writeroperator<< (writer &ps, const long double &l)
 Write long double to the stream.
void WriteTCHAR (writer &out, const TCHAR *ts, bool directSingleByte=false)
 Write TCHAR string to the stream.
void ReadTCHAR (reader &in, TCHAR *&ts, bool directSingleByte=false)
 Read TCHAR string from the stream.
void WriteWcharT (writer &out, const wchar_t *ts)
 Write wchar_t string to the stream.
void ReadWcharT (reader &in, wchar_t *&ts)
 Read TCHAR string from the stream.
void WriteCOUNT (writer &out, size_t count)
 Write size_t subject to the stream version.
void WriteINT_T (writer &out, ptrdiff_t count)
 Writing ptrdiff_t subject to the stream version.
size_t ReadCOUNT (reader &in, bool uint_val=true)
 Reading size_t subject to the stream version.
ptrdiff_t ReadINT_T (reader &in, bool uint_val=true)
 Reading ptrdiff_t subject to the stream version.
void WriteCOUNT (void *out, VERSION version, size_t count)
 Writing size_t to the memory subject to the stream version.
void WriteCOUNT (void *out, VERSION version, ptrdiff_t count)
 Writing ptrdiff_t to the memory subject to the stream version.
size_t ReadCOUNT (void *in, VERSION version)
 Reading of size_t to the memory subject to the stream version.
void WriteSimpleName (writer &out, const SimpleName &s)
 Writing of a simple name.
SimpleName ReadSimpleName (reader &in)
 Reading of a simple name.
writeroperator<< (writer &out, const StrHash &strHash)
 Operator of writing hash.
readeroperator>> (reader &in, StrHash &strHash)
 Operator of hash reading.
writeroperator<< (writer &ps, const std::string &s)
 Writing a string to the stream.
readeroperator>> (reader &ps, std::string &s)
 Reading a string from the stream.
writeroperator<< (writer &ps, const std::wstring &s)
 Writing a string to the stream.
readeroperator>> (reader &ps, std::wstring &s)
 Reading a string from the stream.
writeroperator<< (writer &ps, const std::wstring *s)
 Writing a string to the stream.
void ReadCluster (reader &in, uint16 clusterSize, Cluster &cl)
 Read the cluster.
void WriteCluster (writer &out, const Cluster &cl)
 Write the cluster.
size_t WriteClusterInfo (void *out, VERSION version, const Cluster &obj)
 Write the information about the cluster.
size_t ReadClusterInfo (void *in, VERSION version, Cluster &obj)
 Read the information about the cluster.
readeroperator>> (reader &, VersionContainer &)
 Operator of version container reading.
writeroperator<< (writer &, const VersionContainer &)
 Operator of version container writing.

Variables

const uint16 DEFCLSIZE = 0x1000
 Cluster size by default.

Define Documentation

#define DECLARE_PERSISTENT_OPS_B (   Class)
Value:
friend inline reader & CALL_DECLARATION operator >> ( reader & in, Class & ref );         \
  friend inline reader & CALL_DECLARATION operator >> ( reader & in, Class *& ptr );        \
  friend inline reader & CALL_DECLARATION operator >> ( reader & in, const Class *& ptr );  \
  friend inline writer & CALL_DECLARATION operator << ( writer & out, const Class & ref );  \
  friend inline writer & CALL_DECLARATION operator << ( writer & out, const Class * ptr );  \
  friend inline writer & CALL_DECLARATION operator << ( writer & out, Class & ref );        \
  friend inline writer & CALL_DECLARATION operator << ( writer& out, Class * ptr );
#define DECLARE_PERSISTENT_RO_OPS (   Class)
Value:
friend inline reader & CALL_DECLARATION operator >> ( reader & in, Class & ref ) {  \
    in.readObject( dynamic_cast<TapeBase *>(&ref) );                                  \
    return in;                                                                        \
  }                                                                                   \
  friend inline reader & CALL_DECLARATION operator >> ( reader & in, Class *& ptr ) { \
    ptr = dynamic_cast<Class *>( in.readObjectPointer() );                            \
    return in;                                                                        \
  }
#define DECLARE_PERSISTENT_FUNCS (   Class)
Value:
public:                                                 \
    static void Read ( reader & in,  Class * obj );       \
    static void Write( writer & out, const Class * obj )
#define DECLARE_PERSISTENT_RO_FUNCS (   Class)
Value:
public:                                         \
    static void Read( reader & in, Class * obj )
#define DECLARE_CLASS_DESC_FUNC (   Class)
Value:
public:                                     \
    virtual ClassDescriptor GetClassDescriptor( const VersionContainer & ) const;
#define IMP_CLASS_DESC_FUNC (   AppID,
  Class 
)
Value:
ClassDescriptor Class::GetClassDescriptor( const VersionContainer & v) const \
    { return ClassDescriptor( GetPureName(v), AppID ); }
#define DECLARE_PERSISTENT_CTOR (   Class)
Value:
public:                                 \
    Class( TapeInit )
#define IMP_PERSISTENT_REGISTRATION (   AppID,
  Class 
)
Value:
TapeBase * CALL_DECLARATION make ## _ ## Class () {                   \
    return new Class(tapeInit);                                         \
  }                                                                     \
  void * CALL_DECLARATION cast ## _ ## Class ( const TapeBase * obj ) { \
    return dynamic_cast<Class *>(const_cast<TapeBase *>(obj) );         \
  }                                                                     \
                                                                        \
  TapeClass  r ## Class(                                                \
    typeid(Class).name(),                                               \
    AppID,                                                              \
    (BUILD_FUNC) make ## _ ## Class,                                    \
    (CAST_FUNC ) cast ## _ ## Class,                                    \
    (READ_FUNC ) Class::Read,                                           \
    (WRITE_FUNC) Class::Write                                           \
  )

Construction of a new instance of the class.
Definition of functions of construction a new instance of the class, function of conversion from a pointer to TapeBase to a pointer to the class and addition of the class (not an instance) to the array of stream classes by creating variable r ## Class of type TapeClass (and in constructor of TapeClass addition to array of stream classes is performed). Symbol ## is a directive for preprocessor about the necessity of "glueing" of the current identifier with the next one.

#define IMP_PERSISTENT_RO_REGISTRATION (   AppID,
  Class 
)
Value:
TapeBase * CALL_DECLARATION make ## _ ## Class () {                     \
    return new Class(tapeInit);                                           \
  }                                                                       \
  void * CALL_DECLARATION cast ## _ ## Class ( const TapeBase * obj ) {   \
    return dynamic_cast<Class*>(const_cast<TapeBase *>(obj) );            \
  }                                                                       \
  TapeClass  r ## Class(                                                  \
    typeid(Class).name(),                                                 \
    AppID,                                                                \
    (BUILD_FUNC) make ## _ ## Class,                                      \
    (CAST_FUNC ) cast ## _ ## Class,                                      \
    (READ_FUNC ) Class::Read,                                             \
    (WRITE_FUNC) 0                                                        \
  )
#define __OVERLOAD_MEMORY_ALLOCATE_FREE_

The variable enables overloading of new/delete operators which provides sequential access to the allocation/deallocation functions from different threads.

#define DECLARE_NEW_DELETE_CLASS_EX (   Class)
Value:
public:                                                               \
    void * operator new       ( size_t );                                 \
    void * operator new       ( size_t, const std::nothrow_t & ) throw(); \
    void * operator new       ( size_t, void * );                         \
    void * operator new []    ( size_t );                                 \
    void * operator new []    ( size_t, const std::nothrow_t & ) throw(); \
    void * operator new []    ( size_t, void * );                         \
    void   operator delete    ( void * );                                 \
    void   operator delete    ( void *, const std::nothrow_t & ) throw(); \
    void   operator delete    ( void *, void* );                          \
    void   operator delete [] ( void * );                                 \
    void   operator delete [] ( void *, const std::nothrow_t & ) throw(); \
    void   operator delete [] ( void *, void * );

Declaration of new and delete operators which provide sequential access to the allocation/deallocation functions from different threads. All standard new and delete operators are overloaded.

#define IMP_PERSISTENT_NEW_DELETE_CLASS_EX (   Class)

Implementation of new and delete operators which provides sequential access to the allocation/deallocation functions from different threads. All standard new and delete operators are overloaded.

#define DECLARE_PERSISTENT_CLASS (   Class)
Value:
DECLARE_PERSISTENT_FUNCS( Class );         \
  DECLARE_PERSISTENT_OPS( Class );           \
  DECLARE_PERSISTENT_CTOR( Class );          \
  DECLARE_NEW_DELETE_CLASS( Class );         \
  DECLARE_CLASS_DESC_FUNC(Class)

Declaration of class Class as a stream one. It is set in the declaration of class in file *.h. Declares operators <<, >> and also functions Read and Write which must be defined in any file *.cpp Class must be inherited from TapeBase. The read constructor must be defined for the class and its solid should be in .cpp file.

#define DECLARE_PERSISTENT_CLASS_NEW_DEL (   Class)
Value:

Analog of DECLARE_PERSISTENT_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads (enabled by defining __OVERLOAD_MEMORY_ALLOCATE_FREE_).

#define IMP_PERSISTENT_CLASS (   AppID,
  Class 
)
Value:
IMP_PERSISTENT_REGISTRATION( AppID, Class ); \
  IMP_PERSISTENT_NEW_DELETE_CLASS( Class );    \
  IMP_CLASS_DESC_FUNC( AppID, Class )

Implementation of DECLARE_PERSISTENT_CLASS declaration. Describes the necessary operations for a stream class. It is set into any .cpp file. Class must be inherited from TapeBase. Function Read of reading and function Write of writing should be implemented.

#define IMP_PERSISTENT_CLASS_NEW_DEL (   AppID,
  Class 
)
Value:

Analog of IMP_PERSISTENT_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads (enabled by defining __OVERLOAD_MEMORY_ALLOCATE_FREE_).

#define IMP_PERSISTENT_RO_CLASS_NEW_DEL (   AppID,
  Class 
)
Value:
IMP_PERSISTENT_RO_CLASS( AppID, Class );              \
  IMP_PERSISTENT_NEW_DELETE_CLASS_EX( Class )

Analog of IMP_PERSISTENT_RO_CLASS macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads (enabled by defining __OVERLOAD_MEMORY_ALLOCATE_FREE_).

#define IMP_PERSISTENT_CLASS_FROM_BASE_NEW_DEL (   AppID,
  Class,
  Base 
)
Value:
IMP_PERSISTENT_CLASS_FROM_BASE( AppID, Class, Base )             \
  IMP_PERSISTENT_NEW_DELETE_CLASS_EX( Class )

Analog of IMP_PERSISTENT_CLASS_FROM_BASE macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads (enabled by defining __OVERLOAD_MEMORY_ALLOCATE_FREE_).

#define IMP_PERSISTENT_CLASS_WD_NEW_DEL (   AppID,
  Class 
)
Value:
IMP_PERSISTENT_CLASS_WD( AppID, Class );              \
  IMP_PERSISTENT_NEW_DELETE_CLASS_EX( Class )

Analog of IMP_PERSISTENT_CLASS_WD macro with support of new/delete operators overloading which provides sequential access to the allocation/deallocation functions from different threads (enabled by defining __OVERLOAD_MEMORY_ALLOCATE_FREE_).


Typedef Documentation

typedef void* CALL_DECLARATION CAST_FUNC(const TapeBase *)

Template of function of conversion from a pointer to TapeBase to a pointer to the class.


Enumeration Type Documentation

Types of stream objects registration.

Enumerator:
noRegistrable 

Unregistrable object.

registrable 

Registrable object.

enum TapeInit

Types of stream objects registration.

Enumerator:
tapeInit 

By default.

Methods of writing pointers.

Enumerator:
tpt_Null 

Null pointer.

tpt_Indexed16 

Pointer index in the registration array (2 bytes).

tpt_Object 

The object solid.

tpt_Indexed8 

Index of pointer in the registration array (1 byte).

tpt_Indexed32 

Pointer index in the registration array (4 bytes).

tpt_Indexed64 

Index of pointer in the registration array (8 byte).

tpt_DetachedObject 

The object solid in separated FileSpace.

tpt_ObjectCatalog 

The object catalog in separated FileSpace.

A type of user data of the model tree node.


Function Documentation

bool IsEqualSArrayItems ( const Cluster ,
const Cluster  
) [inline]

Compare two clusters.

size_t getMemLen ( const Cluster c,
VERSION   
) [inline]

Size of cluster data in the stream of the specified version.

size_t getMemLen ( const FileSpace s,
VERSION  version 
) [inline]

The file space data size in the stream of the specified version.

bool IsGoodFile ( const FileSpace file,
const iobuf_Seq owner 
) [inline]

Check array of clusters this file consists of.

typedef void ( CALL_DECLARATION *  READ_FUNC)

Template of instance reading function.

writer& operator<< ( writer ps,
int64  val 
) [inline]

Writing uint32 to the stream. Reading int32 to the stream. Reading uint32 to the stream. Writing int64 to the stream.

writer& operator<< ( writer out,
const StrHash strHash 
) [inline]

Write operator.

reader& operator>> ( reader in,
StrHash strHash 
) [inline]

Read operator.

void ReadCluster ( reader in,
uint16  clusterSize,
Cluster cl 
) [inline]

Write the cluster.

void WriteCluster ( writer out,
const Cluster cl 
) [inline]

Read the cluster.

reader& operator>> ( reader ,
VersionContainer  
)

Read operator.

writer& operator<< ( writer ,
const VersionContainer  
)

Write operator.

 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines