ROOT logo
// @(#)root/reflex:$Id: Type.h 35734 2010-09-25 13:20:17Z axel $
// Author: Stefan Roiser 2004

// Copyright CERN, CH-1211 Geneva 23, 2004-2010, All rights reserved.
//
// Permission to use, copy, modify, and distribute this software for any
// purpose is hereby granted without fee, provided that this copyright and
// permissions notice appear in all copies and derivatives.
//
// This software is provided "as is" without express or implied warranty.

#ifndef Reflex_Type
#define Reflex_Type

// Include files
#include "Reflex/Kernel.h"
#include <vector>
#include <string>
#include <typeinfo>
#include <utility>


namespace Reflex {
// forward declarations
class Base;
class Member;
class Object;
class PropertyList;
class Scope;
class TypeBase;
class TypeName;
class MemberTemplate;
class TypeTemplate;
class DictionaryGenerator;

/**
 * @class Type Type.h Reflex/Type.h
 * @author Stefan Roiser
 * @date 05/11/2004
 * @ingroup Ref
 */
class RFLX_API Type {
public:
   enum TYPE_MODIFICATION {
      REPLACE = 0,
      APPEND = 1,
      MASK = 2
   };

   /** default constructor */
   Type(const TypeName * typName = 0,
        unsigned int modifiers = 0);


   /** copy constructor */
   Type(const Type &rh);


   /**
    * copy constructor applying qualification
    * @param rh the right hand type
    * @param modifiers to be applied
    * @param operation, the default is to replace the modifiers, you can also APPEND or MASK them.  MASK removes the modifiers specified in the 2nd argument
    */
   Type(const Type &rh,
        unsigned int modifiers,
        TYPE_MODIFICATION operation = REPLACE);


   /** destructor */
   ~Type();


   /**
    * assignment operator
    */
   Type& operator =(const Type& rh);


   /**
    * equal operator
    */
   bool operator ==(const Type& rh) const;


   /**
    * not equal operator
    */
   bool operator !=(const Type& rh) const;


   /**
    * lesser than operator
    */
   bool operator <(const Type& rh) const;


   /**
    * operator Scope will return the corresponding scope of this type if
    * applicable (i.e. if the Type is also a Scope e.g. Class, Union, Enum)
    */
   operator Scope() const;


   /**
    * the bool operator returns true if the Type is resolved (implemented)
    * @return true if Type is implemented
    */
   operator bool() const;

#if defined(REFLEX_CINT_MERGE)
   // To prevent any un-authorized use as the old type
   bool
   operator !() const { return !operator bool(); }

   bool
   operator &&(bool right) const { return operator bool() && right; }

   bool
   operator &&(int right) const { return operator bool() && right; }

   bool
   operator &&(long right) const { return operator bool() && right; }

   bool
   operator &&(void* right) const { return operator bool() && right; }

   bool operator &&(const Scope& right) const;
   bool operator &&(const Type& right) const;
   bool operator &&(const Member& right) const;
   bool
   operator ||(bool right) const { return operator bool() || right; }

   bool
   operator ||(int right) const { return operator bool() || right; }

   bool
   operator ||(long right) const { return operator bool() || right; }

   bool
   operator ||(void* right) const { return operator bool() || right; }

   bool operator ||(const Scope& right) const;
   bool operator ||(const Type& right) const;
   bool operator ||(const Member& right) const;

private:
   operator int() const;

public:
#endif


   /**
    * Allocate will reserve memory for the size of the object
    * @return pointer to allocated memory
    */
   void* Allocate() const;


   /**
    * ArrayLength returns the size of the array (if the type represents one)
    * @return size of array
    */
   size_t ArrayLength() const;


   /**
    * BaseAt will return the nth base class information
    * @param  nth base class
    * @return pointer to base class information
    */
   Base BaseAt(size_t nth) const;


   /**
    * BaseSize will return the number of base classes
    * @return number of base classes
    */
   size_t BaseSize() const;


   /**
    * Base_Begin returns the begin of the container of bases
    * @return begin of container of bases
    */
   Base_Iterator Base_Begin() const;


   /**
    * Base_End returns the end of the container of bases
    * @return end of container of bases
    */
   Base_Iterator Base_End() const;


   /**
    * Base_RBegin returns the reverse begin of the container of bases
    * @return reverse begin of container of bases
    */
   Reverse_Base_Iterator Base_RBegin() const;


   /**
    * Base_REnd returns the reverse end of the container of bases
    * @return reverse end of container of bases
    */
   Reverse_Base_Iterator Base_REnd() const;


   /**
    * ByName will look for a type given as a string and return it's
    * reflection type information
    * @param  key fully qualified name of the type as string
    * @return reflection type information
    */
   static Type ByName(const std::string& key);


   /**
    * ByTypeInfo will look for a type given as a
    * std::type_info and return its reflection information
    * @param  tid std::type_info to look for
    * @return reflection information of type
    */
   static Type ByTypeInfo(const std::type_info& tid);


   /**
    * CastObject an object from this class type to another one
    * @param  to is the class type to cast into
    * @param  obj the memory address of the object to be casted
    */
   Object CastObject(const Type& to,
                     const Object& obj) const;


   /**
    * Construct will call the constructor of a given type and allocate
    * the memory for it
    * @param  signature of the constructor
    * @param  values for parameters of the constructor
    * @param  mem place in memory for implicit construction
    * @return new object
    */

   /*
      Object Construct( const Type & signature,
      const std::vector < Object > & values,
      void * mem = 0 ) const;
    */
   Object Construct(const Type& signature = Type(0, 0),
                    const std::vector<void*>& values = std::vector<void*>(),
                    void* mem = 0) const;


   /**
    * DataMemberAt will return the nth data member of the type
    * @param  nth the nth data member
    * @return nth data member
    */
   Member DataMemberAt(size_t nth,
                       EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * DataMemberByName will lookup a data member by name
    * @param  name of data member
    * @return data member
    */
   Member DataMemberByName(const std::string& nam,
                           EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * DataMemberSize will return the number of data members of this type
    * @return number of data members
    */
   size_t DataMemberSize(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_Begin returns the begin of the container of members
    * @return begin of container of members
    */
   Member_Iterator DataMember_Begin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_End returns the end of the container of members
    * @return end of container of members
    */
   Member_Iterator DataMember_End(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_RBegin returns the reverse begin of the container of members
    * @return reverse begin of container of members
    */
   Reverse_Member_Iterator DataMember_RBegin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_REnd returns the reverse end of the container of members
    * @return reverse end of container of members
    */
   Reverse_Member_Iterator DataMember_REnd(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Deallocate will deallocate the memory for a given object
    * @param  instance of the type in memory
    */
   void Deallocate(void* instance) const;


   /**
    * DeclaringScope will return the declaring socpe of this type
    * @return declaring scope of this type
    */
   Scope DeclaringScope() const;


   /**
    * Destruct will call the destructor of a type and remove its memory
    * allocation if desired
    * @param  instance of the type in memory
    * @param  dealloc for also deallacoting the memory
    */
   void Destruct(void* instance,
                 bool dealloc = true) const;


   /**
    * DynamicType is used to discover the dynamic type (useful in
    * case of polymorphism)
    * @param  mem is the memory address of the object to checked
    * @return the actual class of the object
    */
   Type DynamicType(const Object& obj) const;


   /**
    * FinalType will return the type without typedefs
    * @return type with all typedef info removed
    */
   Type FinalType() const;


   /**
    * FunctionMemberAt will return the nth function member of the type
    * @param  nth function member
    * @return reflection information of nth function member
    */
   Member FunctionMemberAt(size_t nth,
                           EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionMemberByName will return the member with the name,
    * optionally the signature of the function may be given as a type
    * @param  name of function member
    * @param  signature of the member function
    * @return reflection information of the function member
    */
   Member FunctionMemberByName(const std::string& nam,
                               const Type& signature = Type(0, 0),
                               unsigned int modifiers_mask = 0,
                               EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT,
                               EDELAYEDLOADSETTING allowDelayedLoad = DELAYEDLOAD_ON) const;


   /**
    * FunctionMemberSize will return the number of function members of
    * this type
    * @return number of function members
    */
   size_t FunctionMemberSize(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionMember_Begin returns the begin of the container of function members
    * @return begin of container of function members
    */
   Member_Iterator FunctionMember_Begin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionMember_End returns the end of the container of function members
    * @return end of container of function members
    */
   Member_Iterator FunctionMember_End(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionMember_RBegin returns the reverse begin of the container of function members
    * @return reverse begin of container of function members
    */
   Reverse_Member_Iterator FunctionMember_RBegin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionMember_REnd returns the reverse end of the container of function members
    * @return reverse end of container of function members
    */
   Reverse_Member_Iterator FunctionMember_REnd(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * FunctionParameterAt returns the nth function parameter
    * @param  nth function parameter
    * @return reflection information of nth function parameter
    */
   Type FunctionParameterAt(size_t nth) const;


   /**
    * FunctionParameterSize will return the number of parameters of this function
    * @return number of parameters
    */
   size_t FunctionParameterSize() const;


   /**
    * FunctionParameter_Begin returns the begin of the container of function parameters
    * @return begin of container of function parameters
    */
   Type_Iterator FunctionParameter_Begin() const;


   /**
    * FunctionParameter_End returns the end of the container of function parameters
    * @return end of container of function parameters
    */
   Type_Iterator FunctionParameter_End() const;


   /**
    * FunctionParameter_RBegin returns the reverse begin of the container of function parameters
    * @return reverse begin of container of function parameters
    */
   Reverse_Type_Iterator FunctionParameter_RBegin() const;


   /**
    * FunctionParameter_REnd returns the reverse end of the container of function parameters
    * @return reverse end of container of function parameters
    */
   Reverse_Type_Iterator FunctionParameter_REnd() const;


   /**
    * GenerateDict will produce the dictionary information of this type
    * @param generator a reference to the dictionary generator instance
    */
   void GenerateDict(DictionaryGenerator& generator) const;


   /**
    * HasBase will check whether this class has a base class given
    * as argument
    * @param  cl the base-class to check for
    * @return the Base info if it is found, an empty base otherwise (can be tested for bool)
    */
   bool HasBase(const Type& cl) const;


   /**
    * Id returns a unique identifier of the type in the system
    * @return unique identifier
    */
   void* Id() const;


   /**
    * IsAbstract will return true if the the class is abstract
    * @return true if the class is abstract
    */
   bool IsAbstract() const;


   /**
    * IsArray returns true if the type represents a array
    * @return true if type represents a array
    */
   bool IsArray() const;


   /**
    * IsClass returns true if the type represents a class
    * @return true if type represents a class
    */
   bool IsClass() const;


   /**
    * IsComplete will return true if all classes and base classes of this
    * class are resolved and fully known in the system
    */
   bool IsComplete() const;


   /**
    * IsConst returns true if the type represents a const type
    * @return true if type represents a const type
    */
   bool IsConst() const;


   /**
    * IsConstVolatile returns true if the type represents a const volatile type
    * @return true if type represents a const volatile type
    */
   bool IsConstVolatile() const;


   /**
    * IsEnum returns true if the type represents a enum
    * @return true if type represents a enum
    */
   bool IsEnum() const;


   /**
    * IsEquivalentTo returns true if the two types are equivalent
    * @param type to compare to
    * @modifiers_mask do not compare the listed modifiers
    * @return true if two types are equivalent
    */
   bool IsEquivalentTo(const Type& typ,
                       unsigned int modifiers_mask = 0) const;


   /**
    * IsSignatureEquivalentTo returns true if the two types are equivalent,
    * ignoring the return type for functions
    * @param type to compare to
    * @modifiers_mask do not compare the listed modifiers
    * @return true if two types are equivalent
    */
   bool IsSignatureEquivalentTo(const Type& typ,
                                unsigned int modifiers_mask = 0) const;


   /**
    * IsFunction returns true if the type represents a function
    * @return true if type represents a function
    */
   bool IsFunction() const;


   /**
    * IsFundamental returns true if the type represents a fundamental
    * @return true if type represents a fundamental
    */
   bool IsFundamental() const;


   /**
    * IsPrivate will check if the scope access is private
    * @return true if scope access is private
    */
   bool IsPrivate() const;


   /**
    * IsProtected will check if the scope access is protected
    * @return true if scope access is protected
    */
   bool IsProtected() const;


   /**
    * IsPublic will check if the scope access is public
    * @return true if scope access is public
    */
   bool IsPublic() const;


   /**
    * IsPointer returns true if the type represents a pointer
    * @return true if type represents a pointer
    */
   bool IsPointer() const;


   /**
    * IsPointerToMember returns true if the type represents a pointer to member
    * @return true if type represents a pointer to member
    */
   bool IsPointerToMember() const;


   /**
    * IsReference returns true if the type represents a reference
    * @return true if type represents a reference
    */
   bool IsReference() const;


   /**
    * IsStruct will return true if the type represents a struct (not a class)
    * @return true if type represents a struct
    */
   bool IsStruct() const;


   /**
    * IsTemplateInstance will return true if the the class is templated
    * @return true if the class is templated
    */
   bool IsTemplateInstance() const;


   /**
    * IsTypedef returns true if the type represents a typedef
    * @return true if type represents a typedef
    */
   bool IsTypedef() const;


   /**
    * IsUnion returns true if the type represents a union
    * @return true if type represents a union
    */
   bool IsUnion() const;


   /**
    * IsUnqualified returns true if the type represents an unqualified type
    * @return true if type represents an unqualified type
    */
   bool IsUnqualified() const;


   /**
    * IsVirtual will return true if the class contains a virtual table
    * @return true if the class contains a virtual table
    */
   bool IsVirtual() const;


   /**
    * IsVolatile returns true if the type represents a volatile type
    * @return true if type represents a volatile type
    */
   bool IsVolatile() const;


   /**
    * MemberAt will return the nth member of the type
    * @param  nth member
    * @return reflection information nth member
    */
   Member MemberAt(size_t nth,
                   EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * MemberByName will return the first member with a given Name
    * @param  member name
    * @param  signature of the (function) member
    * @return reflection information of the member
    */
   Member MemberByName(const std::string& nam,
                       const Type& signature = Type(0, 0),
                       EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * MemberSize will return the number of members
    * @return number of members
    */
   size_t MemberSize(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_Begin returns the begin of the container of members
    * @return begin of container of members
    */
   Member_Iterator Member_Begin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_End returns the end of the container of members
    * @return end of container of members
    */
   Member_Iterator Member_End(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_RBegin returns the reverse begin of the container of members
    * @return reverse begin of container of members
    */
   Reverse_Member_Iterator Member_RBegin(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * Member_REnd returns the reverse end of the container of members
    * @return reverse end of container of members
    */
   Reverse_Member_Iterator Member_REnd(EMEMBERQUERY inh = INHERITEDMEMBERS_DEFAULT) const;


   /**
    * MemberTemplateAt will return the nth member template of this type
    * @param nth member template
    * @return nth member template
    */
   MemberTemplate MemberTemplateAt(size_t nth) const;


   /**
    * MemberTemplateSize will return the number of member templates in this scope
    * @return number of defined member templates
    */
   size_t MemberTemplateSize() const;


   /**
    * MemberTemplate_Begin returns the begin of the container of member templates
    * @return begin of container of member templates
    */
   MemberTemplate_Iterator MemberTemplate_Begin() const;


   /**
    * MemberTemplate_End returns the end of the container of member templates
    * @return end of container of member templates
    */
   MemberTemplate_Iterator MemberTemplate_End() const;


   /**
    * MemberTemplate_RBegin returns the reverse begin of the container of member templates
    * @return reverse begin of container of member templates
    */
   Reverse_MemberTemplate_Iterator MemberTemplate_RBegin() const;


   /**
    * MemberTemplate_REnd returns the reverse end of the container of member templates
    * @return reverse end of container of member templates
    */
   Reverse_MemberTemplate_Iterator MemberTemplate_REnd() const;


   /**
    * Name returns the name of the type
    * @param  mod qualifiers can be or'ed
    *   FINAL     - resolve typedefs
    *   SCOPED    - fully scoped name
    *   QUALIFIED - cv, reference qualification
    * @return name of the type
    */
   std::string Name(unsigned int mod = 0) const;


   /**
    * Name_c_str returns a char* pointer to the unqualified type name
    * @return c string to unqualified type name
    */
   const char* Name_c_str() const;


   /**
    * PointerToMemberScope will return the scope of the pointer to member type
    * @return scope of the pointer to member type
    */
   Scope PointerToMemberScope() const;


   /**
    * Properties will return a PropertyList attached to this item
    * @return PropertyList of this type
    */
   PropertyList Properties() const;


   /**
    * RawType will return the underlying type of a type removing all information
    * of pointers, arrays, typedefs
    * @return the raw type representation
    */
   Type RawType() const;


   /**
    * ReturnType will return the type of the return type
    * @return reflection information of the return type
    */
   Type ReturnType() const;


   /**
    * sizeof will return the size of the type
    * @return size of the type as int
    */
   size_t SizeOf() const;


   /**
    * SubScopeAt will return a pointer to a sub scopes
    * @param  nth sub scope
    * @return reflection information of nth sub scope
    */
   Scope SubScopeAt(size_t nth) const;


   /**
    * SubScopeSize will return the number of sub scopes
    * @return number of sub scopes
    */
   size_t SubScopeSize() const;


   /**
    * SubScope_Begin returns the begin of the container of sub scopes
    * @return begin of container of sub scopes
    */
   Scope_Iterator SubScope_Begin() const;


   /**
    * SubScope_End returns the end of the container of sub scopes
    * @return end of container of sub scopes
    */
   Scope_Iterator SubScope_End() const;


   /**
    * SubScope_RBegin returns the reverse begin of the container of sub scopes
    * @return reverse begin of container of sub scopes
    */
   Reverse_Scope_Iterator SubScope_RBegin() const;


   /**
    * SubScope_REnd returns the reverse end of the container of sub scopes
    * @return reverse end of container of sub scopes
    */
   Reverse_Scope_Iterator SubScope_REnd() const;


   /**
    * SubTypeAt will return the nth sub type
    * @param  nth sub type
    * @return reflection information of nth sub type
    */
   Type SubTypeAt(size_t nth) const;


   /**
    * SubTypeSize will return he number of sub types
    * @return number of sub types
    */
   size_t SubTypeSize() const;


   /**
    * SubType_Begin returns the begin of the container of sub types
    * @return begin of container of sub types
    */
   Type_Iterator SubType_Begin() const;


   /**
    * SubType_End returns the end of the container of sub types
    * @return end of container of sub types
    */
   Type_Iterator SubType_End() const;


   /**
    * SubType_RBegin returns the reverse begin of the container of sub types
    * @return reverse begin of container of sub types
    */
   Reverse_Type_Iterator SubType_RBegin() const;


   /**
    * SubType_REnd returns the reverse end of the container of sub types
    * @return reverse end of container of sub types
    */
   Reverse_Type_Iterator SubType_REnd() const;


   /**
    * SubTypeTemplateAt will return the nth type template of this type
    * @param nth type template
    * @return nth type template
    */
   TypeTemplate SubTypeTemplateAt(size_t nth) const;


   /**
    * SubTypeTemplateSize will return the number of type templates in this scope
    * @return number of defined type templates
    */
   size_t SubTypeTemplateSize() const;


   /**
    * SubTypeTemplate_Begin returns the begin of the container of sub type templates
    * @return begin of container of sub type templates
    */
   TypeTemplate_Iterator SubTypeTemplate_Begin() const;


   /**
    * SubTypeTemplate_End returns the end of the container of sub type templates
    * @return end of container of sub type templates
    */
   TypeTemplate_Iterator SubTypeTemplate_End() const;


   /**
    * SubTypeTemplate_RBegin returns the reverse begin of the container of sub type templates
    * @return reverse begin of container of sub type templates
    */
   Reverse_TypeTemplate_Iterator SubTypeTemplate_RBegin() const;


   /**
    * SubTypeTemplate_REnd returns the reverse end of the container of sub type templates
    * @return reverse end of container of sub type templates
    */
   Reverse_TypeTemplate_Iterator SubTypeTemplate_REnd() const;


   /**
    * TemplateArgumentAt will return a pointer to the nth template argument
    * @param  nth nth template argument
    * @return reflection information of nth template argument
    */
   Type TemplateArgumentAt(size_t nth) const;


   /**
    * TemplateArgumentSize will return the number of template arguments
    * @return number of template arguments
    */
   size_t TemplateArgumentSize() const;


   /**
    * TemplateArgument_Begin returns the begin of the container of template arguments
    * @return begin of container of template arguments
    */
   Type_Iterator TemplateArgument_Begin() const;


   /**
    * TemplateArgument_End returns the end of the container of template arguments
    * @return end of container of template arguments
    */
   Type_Iterator TemplateArgument_End() const;


   /**
    * TemplateArgument_RBegin returns the reverse begin of the container of template arguments
    * @return reverse begin of container of template arguments
    */
   Reverse_Type_Iterator TemplateArgument_RBegin() const;


   /**
    * TemplateArgument_REnd returns the reverse end of the container of template arguments
    * @return reverse end of container of template arguments
    */
   Reverse_Type_Iterator TemplateArgument_REnd() const;


   /**
    * TemplateFamily returns the corresponding TypeTemplate if any
    * @return corresponding TypeTemplate
    */
   TypeTemplate TemplateFamily() const;


   /**
    * ToType will return an underlying type if possible (e.g. typedef, pointer..)
    * @return reflection information of underlying type
    */
   Type ToType() const;


   /**
    * TypeAt will return the nth Type in the system
    * @param  nth number of type to return
    * @return reflection information of nth type in the system
    */
   static Type TypeAt(size_t nth);


   /**
    * TypeSize will return the number of currently defined types in
    * the system
    * @return number of currently defined types
    */
   static size_t TypeSize();


   /**
    * Type_Begin returns the begin of the container of types in the system
    * @return begin of container of types in the system
    */
   static Type_Iterator Type_Begin();


   /**
    * Type_End returns the end of the container of types in the system
    * @return end of container of types in the system
    */
   static Type_Iterator Type_End();


   /**
    * Type_RBegin returns the reverse begin of the container of types in the system
    * @return reverse begin of container of types in the system
    */
   static Reverse_Type_Iterator Type_RBegin();


   /**
    * Type_REnd returns the reverse end of the container of types in the system
    * @return reverse end of container of types in the system
    */
   static Reverse_Type_Iterator Type_REnd();


   /**
    * TypeInfo will return the c++ type_info object of this type
    * @return type_info object of this type
    */
   const std::type_info& TypeInfo() const;


   /**
    * TypeType will return the enum information about this type
    * @return enum information of this type
    */
   TYPE TypeType() const;


   /**
    * TypeTypeAsString will return the string representation of the ENUM
    * representing the real type of the Type (e.g. "CLASS")
    * @return string representation of the TYPE enum of the Type
    */
   std::string TypeTypeAsString() const;


   /**
    * Unload will unload the dictionary information of a type from the system
    */
   void Unload() const;


   /**
    * UpdateMembers will update the list of Function/Data/Members with all
    * members of base classes currently availabe in the system
    */
   void UpdateMembers() const;

public:
   /**
    * AddBase will add information about a Base class
    * @param base type of the base class
    * @param offsFP pointer to a function stub for calculating the base class offset
    * @param modifiers the modifiers of the base class
    */
   void AddBase(const Type& bas,
                OffsetFunction offsFP,
                unsigned int modifiers = 0) const;


   /**
    * AddBase will add the information about a Base class
    * @param b pointer to the base class
    */
   void AddBase(const Base& b) const;


   /**
    * AddDataMember will add the information about a data member
    * @param dm data member to add
    */
   void AddDataMember(const Member& dm) const;


   /**
    * AddDataMember will add the information about a data member
    * @param nam the name of the data member
    * @param typ the type of the data member
    * @param offs the offset of the data member relative to the beginning of the scope
    * @param modifiers of the data member
    */
   Member AddDataMember(const char* nam,
                        const Type& typ,
                        size_t offs,
                        unsigned int modifiers = 0,
                        char* interpreterOffset = 0) const;


   /**
    * AddFunctionMember will add the information about a function member
    * @param fm function member to add
    */
   void AddFunctionMember(const Member& fm) const;


   /**
    * AddFunctionMember will add the information about a function member
    * @param nam the name of the function member
    * @param typ the type of the function member
    * @param stubFP a pointer to the stub function
    * @param stubCtx a pointer to the context of the function member
    * @param params a semi colon separated list of parameters
    * @param modifiers of the function member
    */
   Member AddFunctionMember(const char* nam,
                            const Type& typ,
                            StubFunction stubFP,
                            void* stubCtx = 0,
                            const char* params = 0,
                            unsigned int modifiers = 0) const;


   /**
    * AddSubScope will add a sub scope to this one
    * @param sc sub scope to add
    */
   void AddSubScope(const Scope& sc) const;


   /**
    * AddSubScope will add a sub scope to this one
    * @param scop the name of the sub scope
    * @param scopeType enum value of the scope type
    */
   void AddSubScope(const char* scop,
                    TYPE scopeTyp = NAMESPACE) const;


   /**
    * AddSubType will add a sub type to this type
    * @param ty sub type to add
    */
   void AddSubType(const Type& ty) const;


   /**
    * AddSubType will add a sub type to this type
    * @param typ the name of the sub type
    * @param size the sizeof of the sub type
    * @param typeType the enum specifying the sub type
    * @param ti the type_info of the sub type
    * @param modifiers of the sub type
    */
   void AddSubType(const char* typ,
                   size_t size,
                   TYPE typeTyp,
                   const std::type_info& ti,
                   unsigned int modifiers = 0) const;


   /**
    * RemoveDataMember will remove the information about a data member
    * @param dm data member to remove
    */
   void RemoveDataMember(const Member& dm) const;


   /**
    * RemoveFunctionMember will remove the information about a function member
    * @param fm function member to remove
    */
   void RemoveFunctionMember(const Member& fm) const;


   /**
    * RemoveSubScope will remove a sub scope from this type
    * @param sc sub scope to remove
    */
   void RemoveSubScope(const Scope& sc) const;


   /**
    * RemoveSubType will remove a sub type from this type
    * @param sc sub type to remove
    */
   void RemoveSubType(const Type& ty) const;


   /**
    * SetSize will set the size of the type. This function shall
    * be used with care. It will change the reflection information
    * of this type.
    */
   void SetSize(size_t s) const;


   /**
    * SetTypeInfo will set the type_info object of this type.
    * Attention: This will change the reflection information
    * of this type.
    */
   void SetTypeInfo(const std::type_info& ti) const;


   /** */
   const TypeBase* ToTypeBase() const;

   REPRESTYPE RepresType() const;

private:
   /**
    * pointer to the TypeName
    * @link aggregation
    * @supplierCardinality 1
    * @clientCardinality 1..
    **/
   const TypeName* fTypeName;


   /** modifiers */
   unsigned int fModifiers;

};    // class Type

} //namespace Reflex

#include "Reflex/internal/TypeName.h"
#include "Reflex/internal/TypeBase.h"
#include "Reflex/PropertyList.h"

inline Reflex::REPRESTYPE
Reflex::Type::RepresType() const {
   if (*this) {
      return fTypeName->fTypeBase->RepresType();
   }
   return REPRES_NOTYPE;
}


//-------------------------------------------------------------------------------
inline Reflex::Type&
Reflex::Type::operator =(const Type& rh) {
//-------------------------------------------------------------------------------
   fTypeName = rh.fTypeName;
   fModifiers = rh.fModifiers;
   return *this;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::operator ==(const Type& rh) const {
//-------------------------------------------------------------------------------
   return fTypeName == rh.fTypeName && fModifiers == rh.fModifiers;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::operator !=(const Type& rh) const {
//-------------------------------------------------------------------------------
   return fTypeName != rh.fTypeName || fModifiers != rh.fModifiers;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::operator <(const Type& rh) const {
//-------------------------------------------------------------------------------
   return Id() < rh.Id();
}


//-------------------------------------------------------------------------------
inline
Reflex::Type::operator bool() const {
//-------------------------------------------------------------------------------
   if (this->fTypeName && this->fTypeName->fTypeBase) {
      return true;
   }
   //throw RuntimeError("Type is not implemented");
   return false;
}


//-------------------------------------------------------------------------------
inline Reflex::Type::Type(const TypeName* typName,
                          unsigned int modifiers)
//-------------------------------------------------------------------------------
   : fTypeName(typName),
   fModifiers(modifiers) {
}


//-------------------------------------------------------------------------------
inline Reflex::Type::Type(const Type& rh)
//-------------------------------------------------------------------------------
   : fTypeName(rh.fTypeName),
   fModifiers(rh.fModifiers) {
}


//-------------------------------------------------------------------------------
inline Reflex::Type::Type(const Type& rh,
                          unsigned int modifiers,
                          TYPE_MODIFICATION operation)
//-------------------------------------------------------------------------------
   : fTypeName(rh.fTypeName),
   fModifiers(operation == APPEND ? rh.fModifiers | modifiers:
                 (operation == MASK ? rh.fModifiers & (~modifiers): modifiers)) {
}


//-------------------------------------------------------------------------------
inline Reflex::Type::~Type() {
//-------------------------------------------------------------------------------
}


//-------------------------------------------------------------------------------
inline void*
Reflex::Type::Allocate() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->Allocate();
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::BaseSize() const {
//-------------------------------------------------------------------------------
   return operator Scope().BaseSize();
}


//-------------------------------------------------------------------------------
inline Reflex::Base_Iterator
Reflex::Type::Base_Begin() const {
//-------------------------------------------------------------------------------
   return operator Scope().Base_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Base_Iterator
Reflex::Type::Base_End() const {
//-------------------------------------------------------------------------------
   return operator Scope().Base_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Base_Iterator
Reflex::Type::Base_RBegin() const {
//-------------------------------------------------------------------------------
   return operator Scope().Base_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Base_Iterator
Reflex::Type::Base_REnd() const {
//-------------------------------------------------------------------------------
   return operator Scope().Base_REnd();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::DataMemberSize(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().DataMemberSize(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::DataMember_Begin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().DataMember_Begin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::DataMember_End(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().DataMember_End(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::DataMember_RBegin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().DataMember_RBegin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::DataMember_REnd(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().DataMember_REnd(inh);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::Deallocate(void* instance) const {
//-------------------------------------------------------------------------------
   if (*this) {
      fTypeName->fTypeBase->Deallocate(instance);
   }
}


//-------------------------------------------------------------------------------
inline Reflex::Scope
Reflex::Type::DeclaringScope() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->DeclaringScope();
   }
   return Dummy::Scope();
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::Destruct(void* instance,
                       bool dealloc) const {
//-------------------------------------------------------------------------------
   if (*this) {
      fTypeName->fTypeBase->Destruct(instance, dealloc);
   }
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::FunctionMemberSize(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().FunctionMemberSize(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::FunctionMember_Begin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().FunctionMember_Begin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::FunctionMember_End(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().FunctionMember_End(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::FunctionMember_RBegin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().FunctionMember_RBegin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::FunctionMember_REnd(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().FunctionMember_REnd(inh);
}


//-------------------------------------------------------------------------------
inline void*
Reflex::Type::Id() const {
//-------------------------------------------------------------------------------
   return (void*) fTypeName;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsAbstract() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsAbstract();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsArray() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsArray();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsClass() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsClass();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsComplete() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsComplete();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsConst() const {
//-------------------------------------------------------------------------------
   return 0 != (fModifiers & CONST);
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsConstVolatile() const {
//-------------------------------------------------------------------------------
   return (fModifiers & CONST) && (fModifiers & VOLATILE);
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsEnum() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsEnum();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsFunction() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsFunction();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsFundamental() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsFundamental();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsPointer() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsPointer();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsPointerToMember() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsPointerToMember();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsPrivate() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsPrivate();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsProtected() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsProtected();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsPublic() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsPublic();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsReference() const {
//-------------------------------------------------------------------------------
   return 0 != (fModifiers & REFERENCE);
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsStruct() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsStruct();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsTemplateInstance() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsTemplateInstance();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsTypedef() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsTypedef();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsUnion() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsUnion();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsUnqualified() const {
//-------------------------------------------------------------------------------
   return 0 == fModifiers;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsVirtual() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->IsVirtual();
   }
   return false;
}


//-------------------------------------------------------------------------------
inline bool
Reflex::Type::IsVolatile() const {
//-------------------------------------------------------------------------------
   return 0 != (fModifiers & VOLATILE);
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::ArrayLength() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->ArrayLength();
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::FinalType() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return Reflex::Type(fTypeName->fTypeBase->FinalType(), fModifiers, APPEND);
   }
   return *this;
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::MemberTemplateSize() const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberTemplateSize();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::MemberSize(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberSize(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::Member_Begin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().Member_Begin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Member_Iterator
Reflex::Type::Member_End(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().Member_End(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::Member_RBegin(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().Member_RBegin(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Member_Iterator
Reflex::Type::Member_REnd(EMEMBERQUERY inh) const {
//-------------------------------------------------------------------------------
   return operator Scope().Member_REnd(inh);
}


//-------------------------------------------------------------------------------
inline Reflex::MemberTemplate_Iterator
Reflex::Type::MemberTemplate_Begin() const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberTemplate_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::MemberTemplate_Iterator
Reflex::Type::MemberTemplate_End() const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberTemplate_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_MemberTemplate_Iterator
Reflex::Type::MemberTemplate_RBegin() const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberTemplate_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_MemberTemplate_Iterator
Reflex::Type::MemberTemplate_REnd() const {
//-------------------------------------------------------------------------------
   return operator Scope().MemberTemplate_REnd();
}


//-------------------------------------------------------------------------------
inline const char*
Reflex::Type::Name_c_str() const {
//-------------------------------------------------------------------------------
   if (fTypeName) {
      return fTypeName->Name();
   }
   return "";
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::FunctionParameterAt(size_t nth) const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameterAt(nth);
   }
   return Dummy::Type();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::FunctionParameterSize() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameterSize();
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::FunctionParameter_Begin() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameter_Begin();
   }
   return Dummy::TypeCont().begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::FunctionParameter_End() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameter_End();
   }
   return Dummy::TypeCont().end();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::FunctionParameter_RBegin() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameter_RBegin();
   }
   return Dummy::TypeCont().rbegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::FunctionParameter_REnd() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->FunctionParameter_REnd();
   }
   return Dummy::TypeCont().rend();
}


//-------------------------------------------------------------------------------
inline Reflex::PropertyList
Reflex::Type::Properties() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->Properties();
   }
   return Dummy::PropertyList();
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::RawType() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->RawType();
   }
   return Dummy::Type();
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::ReturnType() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->ReturnType();
   }
   return Dummy::Type();
}


//-------------------------------------------------------------------------------
inline Reflex::Scope_Iterator
Reflex::Type::SubScope_Begin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubScope_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Scope_Iterator
Reflex::Type::SubScope_End() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubScope_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Scope_Iterator
Reflex::Type::SubScope_RBegin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubScope_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Scope_Iterator
Reflex::Type::SubScope_REnd() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubScope_REnd();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::SizeOf() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->SizeOf();
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::SubScopeSize() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubScopeSize();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::SubTypeSize() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeSize();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::SubType_Begin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubType_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::SubType_End() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubType_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::SubType_RBegin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubType_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::SubType_REnd() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubType_REnd();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::TemplateArgument_Begin() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgument_Begin();
   }
   return Dummy::TypeCont().begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::TemplateArgument_End() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgument_End();
   }
   return Dummy::TypeCont().end();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::TemplateArgument_RBegin() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgument_RBegin();
   }
   return Dummy::TypeCont().rbegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::TemplateArgument_REnd() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgument_REnd();
   }
   return Dummy::TypeCont().rend();
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::ToType() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->ToType();
   }
   return Dummy::Type();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::Type_Begin() {
//-------------------------------------------------------------------------------
   return TypeName::Type_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::Type_Iterator
Reflex::Type::Type_End() {
//-------------------------------------------------------------------------------
   return TypeName::Type_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::Type_RBegin() {
//-------------------------------------------------------------------------------
   return TypeName::Type_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_Type_Iterator
Reflex::Type::Type_REnd() {
//-------------------------------------------------------------------------------
   return TypeName::Type_REnd();
}


//-------------------------------------------------------------------------------
inline const std::type_info&
Reflex::Type::TypeInfo() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TypeInfo();
   }
   return typeid(void);
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::SubTypeTemplateSize() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeTemplateSize();
}


//-------------------------------------------------------------------------------
inline Reflex::TypeTemplate_Iterator
Reflex::Type::SubTypeTemplate_Begin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeTemplate_Begin();
}


//-------------------------------------------------------------------------------
inline Reflex::TypeTemplate_Iterator
Reflex::Type::SubTypeTemplate_End() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeTemplate_End();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_TypeTemplate_Iterator
Reflex::Type::SubTypeTemplate_RBegin() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeTemplate_RBegin();
}


//-------------------------------------------------------------------------------
inline Reflex::Reverse_TypeTemplate_Iterator
Reflex::Type::SubTypeTemplate_REnd() const {
//-------------------------------------------------------------------------------
   return operator Scope().SubTypeTemplate_REnd();
}


//-------------------------------------------------------------------------------
inline Reflex::TYPE
Reflex::Type::TypeType() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TypeType();
   }
   return UNRESOLVED;
}


//-------------------------------------------------------------------------------
inline std::string
Reflex::Type::TypeTypeAsString() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TypeTypeAsString();
   }
   return "UNRESOLVED";
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::UpdateMembers() const {
//-------------------------------------------------------------------------------
   operator Scope().UpdateMembers();
}


//-------------------------------------------------------------------------------
inline Reflex::Type
Reflex::Type::TemplateArgumentAt(size_t nth) const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgumentAt(nth);
   }
   return Dummy::Type();
}


//-------------------------------------------------------------------------------
inline size_t
Reflex::Type::TemplateArgumentSize() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateArgumentSize();
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline Reflex::TypeTemplate
Reflex::Type::TemplateFamily() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase->TemplateFamily();
   }
   return Dummy::TypeTemplate();
}


//-------------------------------------------------------------------------------
inline const Reflex::TypeBase*
Reflex::Type::ToTypeBase() const {
//-------------------------------------------------------------------------------
   if (*this) {
      return fTypeName->fTypeBase;
   }
   return 0;
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddBase(const Type& bas,
                      OffsetFunction offsFP,
                      unsigned int modifiers /* = 0 */) const {
//-------------------------------------------------------------------------------
   operator Scope().AddBase(bas, offsFP, modifiers);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddBase(const Base& b) const {
//-------------------------------------------------------------------------------
   operator Scope().AddBase(b);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddDataMember(const Member& dm) const {
//-------------------------------------------------------------------------------
   operator Scope().AddDataMember(dm);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddFunctionMember(const Member& fm) const {
//-------------------------------------------------------------------------------
   operator Scope().AddFunctionMember(fm);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddSubScope(const Scope& sc) const {
//-------------------------------------------------------------------------------
   return operator Scope().AddSubScope(sc);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddSubScope(const char* scop,
                          TYPE scopeTyp) const {
//-------------------------------------------------------------------------------
   return operator Scope().AddSubScope(scop, scopeTyp);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddSubType(const Type& ty) const {
//-------------------------------------------------------------------------------
   return operator Scope().AddSubType(ty);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::AddSubType(const char* typ,
                         size_t size,
                         TYPE typeTyp,
                         const std::type_info& ti,
                         unsigned int modifiers) const {
//-------------------------------------------------------------------------------
   return operator Scope().AddSubType(typ, size, typeTyp, ti, modifiers);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::RemoveDataMember(const Member& dm) const {
//-------------------------------------------------------------------------------
   return operator Scope().RemoveDataMember(dm);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::RemoveFunctionMember(const Member& fm) const {
//-------------------------------------------------------------------------------
   return operator Scope().RemoveFunctionMember(fm);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::RemoveSubScope(const Scope& sc) const {
//-------------------------------------------------------------------------------
   return operator Scope().RemoveSubScope(sc);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::RemoveSubType(const Type& ty) const {
//-------------------------------------------------------------------------------
   return operator Scope().RemoveSubType(ty);
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::SetSize(size_t s) const {
//-------------------------------------------------------------------------------
   if (*this) {
      fTypeName->fTypeBase->SetSize(s);
   }
}


//-------------------------------------------------------------------------------
inline void
Reflex::Type::SetTypeInfo(const std::type_info& ti) const {
//-------------------------------------------------------------------------------
   if (*this) {
      fTypeName->fTypeBase->SetTypeInfo(ti);
   }
}


#ifdef REFLEX_CINT_MERGE
inline bool
operator &&(bool b,
            const Reflex::Type& rh) {
   return b && rh.operator bool();
}


inline bool
operator &&(int i,
            const Reflex::Type& rh) {
   return i && rh.operator bool();
}


inline bool
operator ||(bool b,
            const Reflex::Type& rh) {
   return b || rh.operator bool();
}


inline bool
operator ||(int i,
            const Reflex::Type& rh) {
   return i || rh.operator bool();
}


inline bool
operator &&(const char* c,
            const Reflex::Type& rh) {
   return c && rh.operator bool();
}


inline bool
operator ||(const char* c,
            const Reflex::Type& rh) {
   return c || rh.operator bool();
}


inline bool
operator &&(char* c,
            const Reflex::Type& rh) {
   return c && rh.operator bool();
}


inline bool
operator ||(char* c,
            const Reflex::Type& rh) {
   return c || rh.operator bool();
}


#endif
#endif // Reflex_Type
 Type.h:1
 Type.h:2
 Type.h:3
 Type.h:4
 Type.h:5
 Type.h:6
 Type.h:7
 Type.h:8
 Type.h:9
 Type.h:10
 Type.h:11
 Type.h:12
 Type.h:13
 Type.h:14
 Type.h:15
 Type.h:16
 Type.h:17
 Type.h:18
 Type.h:19
 Type.h:20
 Type.h:21
 Type.h:22
 Type.h:23
 Type.h:24
 Type.h:25
 Type.h:26
 Type.h:27
 Type.h:28
 Type.h:29
 Type.h:30
 Type.h:31
 Type.h:32
 Type.h:33
 Type.h:34
 Type.h:35
 Type.h:36
 Type.h:37
 Type.h:38
 Type.h:39
 Type.h:40
 Type.h:41
 Type.h:42
 Type.h:43
 Type.h:44
 Type.h:45
 Type.h:46
 Type.h:47
 Type.h:48
 Type.h:49
 Type.h:50
 Type.h:51
 Type.h:52
 Type.h:53
 Type.h:54
 Type.h:55
 Type.h:56
 Type.h:57
 Type.h:58
 Type.h:59
 Type.h:60
 Type.h:61
 Type.h:62
 Type.h:63
 Type.h:64
 Type.h:65
 Type.h:66
 Type.h:67
 Type.h:68
 Type.h:69
 Type.h:70
 Type.h:71
 Type.h:72
 Type.h:73
 Type.h:74
 Type.h:75
 Type.h:76
 Type.h:77
 Type.h:78
 Type.h:79
 Type.h:80
 Type.h:81
 Type.h:82
 Type.h:83
 Type.h:84
 Type.h:85
 Type.h:86
 Type.h:87
 Type.h:88
 Type.h:89
 Type.h:90
 Type.h:91
 Type.h:92
 Type.h:93
 Type.h:94
 Type.h:95
 Type.h:96
 Type.h:97
 Type.h:98
 Type.h:99
 Type.h:100
 Type.h:101
 Type.h:102
 Type.h:103
 Type.h:104
 Type.h:105
 Type.h:106
 Type.h:107
 Type.h:108
 Type.h:109
 Type.h:110
 Type.h:111
 Type.h:112
 Type.h:113
 Type.h:114
 Type.h:115
 Type.h:116
 Type.h:117
 Type.h:118
 Type.h:119
 Type.h:120
 Type.h:121
 Type.h:122
 Type.h:123
 Type.h:124
 Type.h:125
 Type.h:126
 Type.h:127
 Type.h:128
 Type.h:129
 Type.h:130
 Type.h:131
 Type.h:132
 Type.h:133
 Type.h:134
 Type.h:135
 Type.h:136
 Type.h:137
 Type.h:138
 Type.h:139
 Type.h:140
 Type.h:141
 Type.h:142
 Type.h:143
 Type.h:144
 Type.h:145
 Type.h:146
 Type.h:147
 Type.h:148
 Type.h:149
 Type.h:150
 Type.h:151
 Type.h:152
 Type.h:153
 Type.h:154
 Type.h:155
 Type.h:156
 Type.h:157
 Type.h:158
 Type.h:159
 Type.h:160
 Type.h:161
 Type.h:162
 Type.h:163
 Type.h:164
 Type.h:165
 Type.h:166
 Type.h:167
 Type.h:168
 Type.h:169
 Type.h:170
 Type.h:171
 Type.h:172
 Type.h:173
 Type.h:174
 Type.h:175
 Type.h:176
 Type.h:177
 Type.h:178
 Type.h:179
 Type.h:180
 Type.h:181
 Type.h:182
 Type.h:183
 Type.h:184
 Type.h:185
 Type.h:186
 Type.h:187
 Type.h:188
 Type.h:189
 Type.h:190
 Type.h:191
 Type.h:192
 Type.h:193
 Type.h:194
 Type.h:195
 Type.h:196
 Type.h:197
 Type.h:198
 Type.h:199
 Type.h:200
 Type.h:201
 Type.h:202
 Type.h:203
 Type.h:204
 Type.h:205
 Type.h:206
 Type.h:207
 Type.h:208
 Type.h:209
 Type.h:210
 Type.h:211
 Type.h:212
 Type.h:213
 Type.h:214
 Type.h:215
 Type.h:216
 Type.h:217
 Type.h:218
 Type.h:219
 Type.h:220
 Type.h:221
 Type.h:222
 Type.h:223
 Type.h:224
 Type.h:225
 Type.h:226
 Type.h:227
 Type.h:228
 Type.h:229
 Type.h:230
 Type.h:231
 Type.h:232
 Type.h:233
 Type.h:234
 Type.h:235
 Type.h:236
 Type.h:237
 Type.h:238
 Type.h:239
 Type.h:240
 Type.h:241
 Type.h:242
 Type.h:243
 Type.h:244
 Type.h:245
 Type.h:246
 Type.h:247
 Type.h:248
 Type.h:249
 Type.h:250
 Type.h:251
 Type.h:252
 Type.h:253
 Type.h:254
 Type.h:255
 Type.h:256
 Type.h:257
 Type.h:258
 Type.h:259
 Type.h:260
 Type.h:261
 Type.h:262
 Type.h:263
 Type.h:264
 Type.h:265
 Type.h:266
 Type.h:267
 Type.h:268
 Type.h:269
 Type.h:270
 Type.h:271
 Type.h:272
 Type.h:273
 Type.h:274
 Type.h:275
 Type.h:276
 Type.h:277
 Type.h:278
 Type.h:279
 Type.h:280
 Type.h:281
 Type.h:282
 Type.h:283
 Type.h:284
 Type.h:285
 Type.h:286
 Type.h:287
 Type.h:288
 Type.h:289
 Type.h:290
 Type.h:291
 Type.h:292
 Type.h:293
 Type.h:294
 Type.h:295
 Type.h:296
 Type.h:297
 Type.h:298
 Type.h:299
 Type.h:300
 Type.h:301
 Type.h:302
 Type.h:303
 Type.h:304
 Type.h:305
 Type.h:306
 Type.h:307
 Type.h:308
 Type.h:309
 Type.h:310
 Type.h:311
 Type.h:312
 Type.h:313
 Type.h:314
 Type.h:315
 Type.h:316
 Type.h:317
 Type.h:318
 Type.h:319
 Type.h:320
 Type.h:321
 Type.h:322
 Type.h:323
 Type.h:324
 Type.h:325
 Type.h:326
 Type.h:327
 Type.h:328
 Type.h:329
 Type.h:330
 Type.h:331
 Type.h:332
 Type.h:333
 Type.h:334
 Type.h:335
 Type.h:336
 Type.h:337
 Type.h:338
 Type.h:339
 Type.h:340
 Type.h:341
 Type.h:342
 Type.h:343
 Type.h:344
 Type.h:345
 Type.h:346
 Type.h:347
 Type.h:348
 Type.h:349
 Type.h:350
 Type.h:351
 Type.h:352
 Type.h:353
 Type.h:354
 Type.h:355
 Type.h:356
 Type.h:357
 Type.h:358
 Type.h:359
 Type.h:360
 Type.h:361
 Type.h:362
 Type.h:363
 Type.h:364
 Type.h:365
 Type.h:366
 Type.h:367
 Type.h:368
 Type.h:369
 Type.h:370
 Type.h:371
 Type.h:372
 Type.h:373
 Type.h:374
 Type.h:375
 Type.h:376
 Type.h:377
 Type.h:378
 Type.h:379
 Type.h:380
 Type.h:381
 Type.h:382
 Type.h:383
 Type.h:384
 Type.h:385
 Type.h:386
 Type.h:387
 Type.h:388
 Type.h:389
 Type.h:390
 Type.h:391
 Type.h:392
 Type.h:393
 Type.h:394
 Type.h:395
 Type.h:396
 Type.h:397
 Type.h:398
 Type.h:399
 Type.h:400
 Type.h:401
 Type.h:402
 Type.h:403
 Type.h:404
 Type.h:405
 Type.h:406
 Type.h:407
 Type.h:408
 Type.h:409
 Type.h:410
 Type.h:411
 Type.h:412
 Type.h:413
 Type.h:414
 Type.h:415
 Type.h:416
 Type.h:417
 Type.h:418
 Type.h:419
 Type.h:420
 Type.h:421
 Type.h:422
 Type.h:423
 Type.h:424
 Type.h:425
 Type.h:426
 Type.h:427
 Type.h:428
 Type.h:429
 Type.h:430
 Type.h:431
 Type.h:432
 Type.h:433
 Type.h:434
 Type.h:435
 Type.h:436
 Type.h:437
 Type.h:438
 Type.h:439
 Type.h:440
 Type.h:441
 Type.h:442
 Type.h:443
 Type.h:444
 Type.h:445
 Type.h:446
 Type.h:447
 Type.h:448
 Type.h:449
 Type.h:450
 Type.h:451
 Type.h:452
 Type.h:453
 Type.h:454
 Type.h:455
 Type.h:456
 Type.h:457
 Type.h:458
 Type.h:459
 Type.h:460
 Type.h:461
 Type.h:462
 Type.h:463
 Type.h:464
 Type.h:465
 Type.h:466
 Type.h:467
 Type.h:468
 Type.h:469
 Type.h:470
 Type.h:471
 Type.h:472
 Type.h:473
 Type.h:474
 Type.h:475
 Type.h:476
 Type.h:477
 Type.h:478
 Type.h:479
 Type.h:480
 Type.h:481
 Type.h:482
 Type.h:483
 Type.h:484
 Type.h:485
 Type.h:486
 Type.h:487
 Type.h:488
 Type.h:489
 Type.h:490
 Type.h:491
 Type.h:492
 Type.h:493
 Type.h:494
 Type.h:495
 Type.h:496
 Type.h:497
 Type.h:498
 Type.h:499
 Type.h:500
 Type.h:501
 Type.h:502
 Type.h:503
 Type.h:504
 Type.h:505
 Type.h:506
 Type.h:507
 Type.h:508
 Type.h:509
 Type.h:510
 Type.h:511
 Type.h:512
 Type.h:513
 Type.h:514
 Type.h:515
 Type.h:516
 Type.h:517
 Type.h:518
 Type.h:519
 Type.h:520
 Type.h:521
 Type.h:522
 Type.h:523
 Type.h:524
 Type.h:525
 Type.h:526
 Type.h:527
 Type.h:528
 Type.h:529
 Type.h:530
 Type.h:531
 Type.h:532
 Type.h:533
 Type.h:534
 Type.h:535
 Type.h:536
 Type.h:537
 Type.h:538
 Type.h:539
 Type.h:540
 Type.h:541
 Type.h:542
 Type.h:543
 Type.h:544
 Type.h:545
 Type.h:546
 Type.h:547
 Type.h:548
 Type.h:549
 Type.h:550
 Type.h:551
 Type.h:552
 Type.h:553
 Type.h:554
 Type.h:555
 Type.h:556
 Type.h:557
 Type.h:558
 Type.h:559
 Type.h:560
 Type.h:561
 Type.h:562
 Type.h:563
 Type.h:564
 Type.h:565
 Type.h:566
 Type.h:567
 Type.h:568
 Type.h:569
 Type.h:570
 Type.h:571
 Type.h:572
 Type.h:573
 Type.h:574
 Type.h:575
 Type.h:576
 Type.h:577
 Type.h:578
 Type.h:579
 Type.h:580
 Type.h:581
 Type.h:582
 Type.h:583
 Type.h:584
 Type.h:585
 Type.h:586
 Type.h:587
 Type.h:588
 Type.h:589
 Type.h:590
 Type.h:591
 Type.h:592
 Type.h:593
 Type.h:594
 Type.h:595
 Type.h:596
 Type.h:597
 Type.h:598
 Type.h:599
 Type.h:600
 Type.h:601
 Type.h:602
 Type.h:603
 Type.h:604
 Type.h:605
 Type.h:606
 Type.h:607
 Type.h:608
 Type.h:609
 Type.h:610
 Type.h:611
 Type.h:612
 Type.h:613
 Type.h:614
 Type.h:615
 Type.h:616
 Type.h:617
 Type.h:618
 Type.h:619
 Type.h:620
 Type.h:621
 Type.h:622
 Type.h:623
 Type.h:624
 Type.h:625
 Type.h:626
 Type.h:627
 Type.h:628
 Type.h:629
 Type.h:630
 Type.h:631
 Type.h:632
 Type.h:633
 Type.h:634
 Type.h:635
 Type.h:636
 Type.h:637
 Type.h:638
 Type.h:639
 Type.h:640
 Type.h:641
 Type.h:642
 Type.h:643
 Type.h:644
 Type.h:645
 Type.h:646
 Type.h:647
 Type.h:648
 Type.h:649
 Type.h:650
 Type.h:651
 Type.h:652
 Type.h:653
 Type.h:654
 Type.h:655
 Type.h:656
 Type.h:657
 Type.h:658
 Type.h:659
 Type.h:660
 Type.h:661
 Type.h:662
 Type.h:663
 Type.h:664
 Type.h:665
 Type.h:666
 Type.h:667
 Type.h:668
 Type.h:669
 Type.h:670
 Type.h:671
 Type.h:672
 Type.h:673
 Type.h:674
 Type.h:675
 Type.h:676
 Type.h:677
 Type.h:678
 Type.h:679
 Type.h:680
 Type.h:681
 Type.h:682
 Type.h:683
 Type.h:684
 Type.h:685
 Type.h:686
 Type.h:687
 Type.h:688
 Type.h:689
 Type.h:690
 Type.h:691
 Type.h:692
 Type.h:693
 Type.h:694
 Type.h:695
 Type.h:696
 Type.h:697
 Type.h:698
 Type.h:699
 Type.h:700
 Type.h:701
 Type.h:702
 Type.h:703
 Type.h:704
 Type.h:705
 Type.h:706
 Type.h:707
 Type.h:708
 Type.h:709
 Type.h:710
 Type.h:711
 Type.h:712
 Type.h:713
 Type.h:714
 Type.h:715
 Type.h:716
 Type.h:717
 Type.h:718
 Type.h:719
 Type.h:720
 Type.h:721
 Type.h:722
 Type.h:723
 Type.h:724
 Type.h:725
 Type.h:726
 Type.h:727
 Type.h:728
 Type.h:729
 Type.h:730
 Type.h:731
 Type.h:732
 Type.h:733
 Type.h:734
 Type.h:735
 Type.h:736
 Type.h:737
 Type.h:738
 Type.h:739
 Type.h:740
 Type.h:741
 Type.h:742
 Type.h:743
 Type.h:744
 Type.h:745
 Type.h:746
 Type.h:747
 Type.h:748
 Type.h:749
 Type.h:750
 Type.h:751
 Type.h:752
 Type.h:753
 Type.h:754
 Type.h:755
 Type.h:756
 Type.h:757
 Type.h:758
 Type.h:759
 Type.h:760
 Type.h:761
 Type.h:762
 Type.h:763
 Type.h:764
 Type.h:765
 Type.h:766
 Type.h:767
 Type.h:768
 Type.h:769
 Type.h:770
 Type.h:771
 Type.h:772
 Type.h:773
 Type.h:774
 Type.h:775
 Type.h:776
 Type.h:777
 Type.h:778
 Type.h:779
 Type.h:780
 Type.h:781
 Type.h:782
 Type.h:783
 Type.h:784
 Type.h:785
 Type.h:786
 Type.h:787
 Type.h:788
 Type.h:789
 Type.h:790
 Type.h:791
 Type.h:792
 Type.h:793
 Type.h:794
 Type.h:795
 Type.h:796
 Type.h:797
 Type.h:798
 Type.h:799
 Type.h:800
 Type.h:801
 Type.h:802
 Type.h:803
 Type.h:804
 Type.h:805
 Type.h:806
 Type.h:807
 Type.h:808
 Type.h:809
 Type.h:810
 Type.h:811
 Type.h:812
 Type.h:813
 Type.h:814
 Type.h:815
 Type.h:816
 Type.h:817
 Type.h:818
 Type.h:819
 Type.h:820
 Type.h:821
 Type.h:822
 Type.h:823
 Type.h:824
 Type.h:825
 Type.h:826
 Type.h:827
 Type.h:828
 Type.h:829
 Type.h:830
 Type.h:831
 Type.h:832
 Type.h:833
 Type.h:834
 Type.h:835
 Type.h:836
 Type.h:837
 Type.h:838
 Type.h:839
 Type.h:840
 Type.h:841
 Type.h:842
 Type.h:843
 Type.h:844
 Type.h:845
 Type.h:846
 Type.h:847
 Type.h:848
 Type.h:849
 Type.h:850
 Type.h:851
 Type.h:852
 Type.h:853
 Type.h:854
 Type.h:855
 Type.h:856
 Type.h:857
 Type.h:858
 Type.h:859
 Type.h:860
 Type.h:861
 Type.h:862
 Type.h:863
 Type.h:864
 Type.h:865
 Type.h:866
 Type.h:867
 Type.h:868
 Type.h:869
 Type.h:870
 Type.h:871
 Type.h:872
 Type.h:873
 Type.h:874
 Type.h:875
 Type.h:876
 Type.h:877
 Type.h:878
 Type.h:879
 Type.h:880
 Type.h:881
 Type.h:882
 Type.h:883
 Type.h:884
 Type.h:885
 Type.h:886
 Type.h:887
 Type.h:888
 Type.h:889
 Type.h:890
 Type.h:891
 Type.h:892
 Type.h:893
 Type.h:894
 Type.h:895
 Type.h:896
 Type.h:897
 Type.h:898
 Type.h:899
 Type.h:900
 Type.h:901
 Type.h:902
 Type.h:903
 Type.h:904
 Type.h:905
 Type.h:906
 Type.h:907
 Type.h:908
 Type.h:909
 Type.h:910
 Type.h:911
 Type.h:912
 Type.h:913
 Type.h:914
 Type.h:915
 Type.h:916
 Type.h:917
 Type.h:918
 Type.h:919
 Type.h:920
 Type.h:921
 Type.h:922
 Type.h:923
 Type.h:924
 Type.h:925
 Type.h:926
 Type.h:927
 Type.h:928
 Type.h:929
 Type.h:930
 Type.h:931
 Type.h:932
 Type.h:933
 Type.h:934
 Type.h:935
 Type.h:936
 Type.h:937
 Type.h:938
 Type.h:939
 Type.h:940
 Type.h:941
 Type.h:942
 Type.h:943
 Type.h:944
 Type.h:945
 Type.h:946
 Type.h:947
 Type.h:948
 Type.h:949
 Type.h:950
 Type.h:951
 Type.h:952
 Type.h:953
 Type.h:954
 Type.h:955
 Type.h:956
 Type.h:957
 Type.h:958
 Type.h:959
 Type.h:960
 Type.h:961
 Type.h:962
 Type.h:963
 Type.h:964
 Type.h:965
 Type.h:966
 Type.h:967
 Type.h:968
 Type.h:969
 Type.h:970
 Type.h:971
 Type.h:972
 Type.h:973
 Type.h:974
 Type.h:975
 Type.h:976
 Type.h:977
 Type.h:978
 Type.h:979
 Type.h:980
 Type.h:981
 Type.h:982
 Type.h:983
 Type.h:984
 Type.h:985
 Type.h:986
 Type.h:987
 Type.h:988
 Type.h:989
 Type.h:990
 Type.h:991
 Type.h:992
 Type.h:993
 Type.h:994
 Type.h:995
 Type.h:996
 Type.h:997
 Type.h:998
 Type.h:999
 Type.h:1000
 Type.h:1001
 Type.h:1002
 Type.h:1003
 Type.h:1004
 Type.h:1005
 Type.h:1006
 Type.h:1007
 Type.h:1008
 Type.h:1009
 Type.h:1010
 Type.h:1011
 Type.h:1012
 Type.h:1013
 Type.h:1014
 Type.h:1015
 Type.h:1016
 Type.h:1017
 Type.h:1018
 Type.h:1019
 Type.h:1020
 Type.h:1021
 Type.h:1022
 Type.h:1023
 Type.h:1024
 Type.h:1025
 Type.h:1026
 Type.h:1027
 Type.h:1028
 Type.h:1029
 Type.h:1030
 Type.h:1031
 Type.h:1032
 Type.h:1033
 Type.h:1034
 Type.h:1035
 Type.h:1036
 Type.h:1037
 Type.h:1038
 Type.h:1039
 Type.h:1040
 Type.h:1041
 Type.h:1042
 Type.h:1043
 Type.h:1044
 Type.h:1045
 Type.h:1046
 Type.h:1047
 Type.h:1048
 Type.h:1049
 Type.h:1050
 Type.h:1051
 Type.h:1052
 Type.h:1053
 Type.h:1054
 Type.h:1055
 Type.h:1056
 Type.h:1057
 Type.h:1058
 Type.h:1059
 Type.h:1060
 Type.h:1061
 Type.h:1062
 Type.h:1063
 Type.h:1064
 Type.h:1065
 Type.h:1066
 Type.h:1067
 Type.h:1068
 Type.h:1069
 Type.h:1070
 Type.h:1071
 Type.h:1072
 Type.h:1073
 Type.h:1074
 Type.h:1075
 Type.h:1076
 Type.h:1077
 Type.h:1078
 Type.h:1079
 Type.h:1080
 Type.h:1081
 Type.h:1082
 Type.h:1083
 Type.h:1084
 Type.h:1085
 Type.h:1086
 Type.h:1087
 Type.h:1088
 Type.h:1089
 Type.h:1090
 Type.h:1091
 Type.h:1092
 Type.h:1093
 Type.h:1094
 Type.h:1095
 Type.h:1096
 Type.h:1097
 Type.h:1098
 Type.h:1099
 Type.h:1100
 Type.h:1101
 Type.h:1102
 Type.h:1103
 Type.h:1104
 Type.h:1105
 Type.h:1106
 Type.h:1107
 Type.h:1108
 Type.h:1109
 Type.h:1110
 Type.h:1111
 Type.h:1112
 Type.h:1113
 Type.h:1114
 Type.h:1115
 Type.h:1116
 Type.h:1117
 Type.h:1118
 Type.h:1119
 Type.h:1120
 Type.h:1121
 Type.h:1122
 Type.h:1123
 Type.h:1124
 Type.h:1125
 Type.h:1126
 Type.h:1127
 Type.h:1128
 Type.h:1129
 Type.h:1130
 Type.h:1131
 Type.h:1132
 Type.h:1133
 Type.h:1134
 Type.h:1135
 Type.h:1136
 Type.h:1137
 Type.h:1138
 Type.h:1139
 Type.h:1140
 Type.h:1141
 Type.h:1142
 Type.h:1143
 Type.h:1144
 Type.h:1145
 Type.h:1146
 Type.h:1147
 Type.h:1148
 Type.h:1149
 Type.h:1150
 Type.h:1151
 Type.h:1152
 Type.h:1153
 Type.h:1154
 Type.h:1155
 Type.h:1156
 Type.h:1157
 Type.h:1158
 Type.h:1159
 Type.h:1160
 Type.h:1161
 Type.h:1162
 Type.h:1163
 Type.h:1164
 Type.h:1165
 Type.h:1166
 Type.h:1167
 Type.h:1168
 Type.h:1169
 Type.h:1170
 Type.h:1171
 Type.h:1172
 Type.h:1173
 Type.h:1174
 Type.h:1175
 Type.h:1176
 Type.h:1177
 Type.h:1178
 Type.h:1179
 Type.h:1180
 Type.h:1181
 Type.h:1182
 Type.h:1183
 Type.h:1184
 Type.h:1185
 Type.h:1186
 Type.h:1187
 Type.h:1188
 Type.h:1189
 Type.h:1190
 Type.h:1191
 Type.h:1192
 Type.h:1193
 Type.h:1194
 Type.h:1195
 Type.h:1196
 Type.h:1197
 Type.h:1198
 Type.h:1199
 Type.h:1200
 Type.h:1201
 Type.h:1202
 Type.h:1203
 Type.h:1204
 Type.h:1205
 Type.h:1206
 Type.h:1207
 Type.h:1208
 Type.h:1209
 Type.h:1210
 Type.h:1211
 Type.h:1212
 Type.h:1213
 Type.h:1214
 Type.h:1215
 Type.h:1216
 Type.h:1217
 Type.h:1218
 Type.h:1219
 Type.h:1220
 Type.h:1221
 Type.h:1222
 Type.h:1223
 Type.h:1224
 Type.h:1225
 Type.h:1226
 Type.h:1227
 Type.h:1228
 Type.h:1229
 Type.h:1230
 Type.h:1231
 Type.h:1232
 Type.h:1233
 Type.h:1234
 Type.h:1235
 Type.h:1236
 Type.h:1237
 Type.h:1238
 Type.h:1239
 Type.h:1240
 Type.h:1241
 Type.h:1242
 Type.h:1243
 Type.h:1244
 Type.h:1245
 Type.h:1246
 Type.h:1247
 Type.h:1248
 Type.h:1249
 Type.h:1250
 Type.h:1251
 Type.h:1252
 Type.h:1253
 Type.h:1254
 Type.h:1255
 Type.h:1256
 Type.h:1257
 Type.h:1258
 Type.h:1259
 Type.h:1260
 Type.h:1261
 Type.h:1262
 Type.h:1263
 Type.h:1264
 Type.h:1265
 Type.h:1266
 Type.h:1267
 Type.h:1268
 Type.h:1269
 Type.h:1270
 Type.h:1271
 Type.h:1272
 Type.h:1273
 Type.h:1274
 Type.h:1275
 Type.h:1276
 Type.h:1277
 Type.h:1278
 Type.h:1279
 Type.h:1280
 Type.h:1281
 Type.h:1282
 Type.h:1283
 Type.h:1284
 Type.h:1285
 Type.h:1286
 Type.h:1287
 Type.h:1288
 Type.h:1289
 Type.h:1290
 Type.h:1291
 Type.h:1292
 Type.h:1293
 Type.h:1294
 Type.h:1295
 Type.h:1296
 Type.h:1297
 Type.h:1298
 Type.h:1299
 Type.h:1300
 Type.h:1301
 Type.h:1302
 Type.h:1303
 Type.h:1304
 Type.h:1305
 Type.h:1306
 Type.h:1307
 Type.h:1308
 Type.h:1309
 Type.h:1310
 Type.h:1311
 Type.h:1312
 Type.h:1313
 Type.h:1314
 Type.h:1315
 Type.h:1316
 Type.h:1317
 Type.h:1318
 Type.h:1319
 Type.h:1320
 Type.h:1321
 Type.h:1322
 Type.h:1323
 Type.h:1324
 Type.h:1325
 Type.h:1326
 Type.h:1327
 Type.h:1328
 Type.h:1329
 Type.h:1330
 Type.h:1331
 Type.h:1332
 Type.h:1333
 Type.h:1334
 Type.h:1335
 Type.h:1336
 Type.h:1337
 Type.h:1338
 Type.h:1339
 Type.h:1340
 Type.h:1341
 Type.h:1342
 Type.h:1343
 Type.h:1344
 Type.h:1345
 Type.h:1346
 Type.h:1347
 Type.h:1348
 Type.h:1349
 Type.h:1350
 Type.h:1351
 Type.h:1352
 Type.h:1353
 Type.h:1354
 Type.h:1355
 Type.h:1356
 Type.h:1357
 Type.h:1358
 Type.h:1359
 Type.h:1360
 Type.h:1361
 Type.h:1362
 Type.h:1363
 Type.h:1364
 Type.h:1365
 Type.h:1366
 Type.h:1367
 Type.h:1368
 Type.h:1369
 Type.h:1370
 Type.h:1371
 Type.h:1372
 Type.h:1373
 Type.h:1374
 Type.h:1375
 Type.h:1376
 Type.h:1377
 Type.h:1378
 Type.h:1379
 Type.h:1380
 Type.h:1381
 Type.h:1382
 Type.h:1383
 Type.h:1384
 Type.h:1385
 Type.h:1386
 Type.h:1387
 Type.h:1388
 Type.h:1389
 Type.h:1390
 Type.h:1391
 Type.h:1392
 Type.h:1393
 Type.h:1394
 Type.h:1395
 Type.h:1396
 Type.h:1397
 Type.h:1398
 Type.h:1399
 Type.h:1400
 Type.h:1401
 Type.h:1402
 Type.h:1403
 Type.h:1404
 Type.h:1405
 Type.h:1406
 Type.h:1407
 Type.h:1408
 Type.h:1409
 Type.h:1410
 Type.h:1411
 Type.h:1412
 Type.h:1413
 Type.h:1414
 Type.h:1415
 Type.h:1416
 Type.h:1417
 Type.h:1418
 Type.h:1419
 Type.h:1420
 Type.h:1421
 Type.h:1422
 Type.h:1423
 Type.h:1424
 Type.h:1425
 Type.h:1426
 Type.h:1427
 Type.h:1428
 Type.h:1429
 Type.h:1430
 Type.h:1431
 Type.h:1432
 Type.h:1433
 Type.h:1434
 Type.h:1435
 Type.h:1436
 Type.h:1437
 Type.h:1438
 Type.h:1439
 Type.h:1440
 Type.h:1441
 Type.h:1442
 Type.h:1443
 Type.h:1444
 Type.h:1445
 Type.h:1446
 Type.h:1447
 Type.h:1448
 Type.h:1449
 Type.h:1450
 Type.h:1451
 Type.h:1452
 Type.h:1453
 Type.h:1454
 Type.h:1455
 Type.h:1456
 Type.h:1457
 Type.h:1458
 Type.h:1459
 Type.h:1460
 Type.h:1461
 Type.h:1462
 Type.h:1463
 Type.h:1464
 Type.h:1465
 Type.h:1466
 Type.h:1467
 Type.h:1468
 Type.h:1469
 Type.h:1470
 Type.h:1471
 Type.h:1472
 Type.h:1473
 Type.h:1474
 Type.h:1475
 Type.h:1476
 Type.h:1477
 Type.h:1478
 Type.h:1479
 Type.h:1480
 Type.h:1481
 Type.h:1482
 Type.h:1483
 Type.h:1484
 Type.h:1485
 Type.h:1486
 Type.h:1487
 Type.h:1488
 Type.h:1489
 Type.h:1490
 Type.h:1491
 Type.h:1492
 Type.h:1493
 Type.h:1494
 Type.h:1495
 Type.h:1496
 Type.h:1497
 Type.h:1498
 Type.h:1499
 Type.h:1500
 Type.h:1501
 Type.h:1502
 Type.h:1503
 Type.h:1504
 Type.h:1505
 Type.h:1506
 Type.h:1507
 Type.h:1508
 Type.h:1509
 Type.h:1510
 Type.h:1511
 Type.h:1512
 Type.h:1513
 Type.h:1514
 Type.h:1515
 Type.h:1516
 Type.h:1517
 Type.h:1518
 Type.h:1519
 Type.h:1520
 Type.h:1521
 Type.h:1522
 Type.h:1523
 Type.h:1524
 Type.h:1525
 Type.h:1526
 Type.h:1527
 Type.h:1528
 Type.h:1529
 Type.h:1530
 Type.h:1531
 Type.h:1532
 Type.h:1533
 Type.h:1534
 Type.h:1535
 Type.h:1536
 Type.h:1537
 Type.h:1538
 Type.h:1539
 Type.h:1540
 Type.h:1541
 Type.h:1542
 Type.h:1543
 Type.h:1544
 Type.h:1545
 Type.h:1546
 Type.h:1547
 Type.h:1548
 Type.h:1549
 Type.h:1550
 Type.h:1551
 Type.h:1552
 Type.h:1553
 Type.h:1554
 Type.h:1555
 Type.h:1556
 Type.h:1557
 Type.h:1558
 Type.h:1559
 Type.h:1560
 Type.h:1561
 Type.h:1562
 Type.h:1563
 Type.h:1564
 Type.h:1565
 Type.h:1566
 Type.h:1567
 Type.h:1568
 Type.h:1569
 Type.h:1570
 Type.h:1571
 Type.h:1572
 Type.h:1573
 Type.h:1574
 Type.h:1575
 Type.h:1576
 Type.h:1577
 Type.h:1578
 Type.h:1579
 Type.h:1580
 Type.h:1581
 Type.h:1582
 Type.h:1583
 Type.h:1584
 Type.h:1585
 Type.h:1586
 Type.h:1587
 Type.h:1588
 Type.h:1589
 Type.h:1590
 Type.h:1591
 Type.h:1592
 Type.h:1593
 Type.h:1594
 Type.h:1595
 Type.h:1596
 Type.h:1597
 Type.h:1598
 Type.h:1599
 Type.h:1600
 Type.h:1601
 Type.h:1602
 Type.h:1603
 Type.h:1604
 Type.h:1605
 Type.h:1606
 Type.h:1607
 Type.h:1608
 Type.h:1609
 Type.h:1610
 Type.h:1611
 Type.h:1612
 Type.h:1613
 Type.h:1614
 Type.h:1615
 Type.h:1616
 Type.h:1617
 Type.h:1618
 Type.h:1619
 Type.h:1620
 Type.h:1621
 Type.h:1622
 Type.h:1623
 Type.h:1624
 Type.h:1625
 Type.h:1626
 Type.h:1627
 Type.h:1628
 Type.h:1629
 Type.h:1630
 Type.h:1631
 Type.h:1632
 Type.h:1633
 Type.h:1634
 Type.h:1635
 Type.h:1636
 Type.h:1637
 Type.h:1638
 Type.h:1639
 Type.h:1640
 Type.h:1641
 Type.h:1642
 Type.h:1643
 Type.h:1644
 Type.h:1645
 Type.h:1646
 Type.h:1647
 Type.h:1648
 Type.h:1649
 Type.h:1650
 Type.h:1651
 Type.h:1652
 Type.h:1653
 Type.h:1654
 Type.h:1655
 Type.h:1656
 Type.h:1657
 Type.h:1658
 Type.h:1659
 Type.h:1660
 Type.h:1661
 Type.h:1662
 Type.h:1663
 Type.h:1664
 Type.h:1665
 Type.h:1666
 Type.h:1667
 Type.h:1668
 Type.h:1669
 Type.h:1670
 Type.h:1671
 Type.h:1672
 Type.h:1673
 Type.h:1674
 Type.h:1675
 Type.h:1676
 Type.h:1677
 Type.h:1678
 Type.h:1679
 Type.h:1680
 Type.h:1681
 Type.h:1682
 Type.h:1683
 Type.h:1684
 Type.h:1685
 Type.h:1686
 Type.h:1687
 Type.h:1688
 Type.h:1689
 Type.h:1690
 Type.h:1691
 Type.h:1692
 Type.h:1693
 Type.h:1694
 Type.h:1695
 Type.h:1696
 Type.h:1697
 Type.h:1698
 Type.h:1699
 Type.h:1700
 Type.h:1701
 Type.h:1702
 Type.h:1703
 Type.h:1704
 Type.h:1705
 Type.h:1706
 Type.h:1707
 Type.h:1708
 Type.h:1709
 Type.h:1710
 Type.h:1711
 Type.h:1712
 Type.h:1713
 Type.h:1714
 Type.h:1715
 Type.h:1716
 Type.h:1717
 Type.h:1718
 Type.h:1719
 Type.h:1720
 Type.h:1721
 Type.h:1722
 Type.h:1723
 Type.h:1724
 Type.h:1725
 Type.h:1726
 Type.h:1727
 Type.h:1728
 Type.h:1729
 Type.h:1730
 Type.h:1731
 Type.h:1732
 Type.h:1733
 Type.h:1734
 Type.h:1735
 Type.h:1736
 Type.h:1737
 Type.h:1738
 Type.h:1739
 Type.h:1740
 Type.h:1741
 Type.h:1742
 Type.h:1743
 Type.h:1744
 Type.h:1745
 Type.h:1746
 Type.h:1747
 Type.h:1748
 Type.h:1749
 Type.h:1750
 Type.h:1751
 Type.h:1752
 Type.h:1753
 Type.h:1754
 Type.h:1755
 Type.h:1756
 Type.h:1757
 Type.h:1758
 Type.h:1759
 Type.h:1760
 Type.h:1761
 Type.h:1762
 Type.h:1763
 Type.h:1764
 Type.h:1765
 Type.h:1766
 Type.h:1767
 Type.h:1768
 Type.h:1769
 Type.h:1770
 Type.h:1771
 Type.h:1772
 Type.h:1773
 Type.h:1774
 Type.h:1775
 Type.h:1776
 Type.h:1777
 Type.h:1778
 Type.h:1779
 Type.h:1780
 Type.h:1781
 Type.h:1782
 Type.h:1783
 Type.h:1784
 Type.h:1785
 Type.h:1786
 Type.h:1787
 Type.h:1788
 Type.h:1789
 Type.h:1790
 Type.h:1791
 Type.h:1792
 Type.h:1793
 Type.h:1794
 Type.h:1795
 Type.h:1796
 Type.h:1797
 Type.h:1798
 Type.h:1799
 Type.h:1800
 Type.h:1801
 Type.h:1802
 Type.h:1803
 Type.h:1804
 Type.h:1805
 Type.h:1806
 Type.h:1807
 Type.h:1808
 Type.h:1809
 Type.h:1810
 Type.h:1811
 Type.h:1812
 Type.h:1813
 Type.h:1814
 Type.h:1815
 Type.h:1816
 Type.h:1817
 Type.h:1818
 Type.h:1819
 Type.h:1820
 Type.h:1821
 Type.h:1822
 Type.h:1823
 Type.h:1824
 Type.h:1825
 Type.h:1826
 Type.h:1827
 Type.h:1828
 Type.h:1829
 Type.h:1830
 Type.h:1831
 Type.h:1832
 Type.h:1833
 Type.h:1834
 Type.h:1835
 Type.h:1836
 Type.h:1837
 Type.h:1838
 Type.h:1839
 Type.h:1840
 Type.h:1841
 Type.h:1842
 Type.h:1843
 Type.h:1844
 Type.h:1845
 Type.h:1846
 Type.h:1847
 Type.h:1848
 Type.h:1849
 Type.h:1850
 Type.h:1851
 Type.h:1852
 Type.h:1853
 Type.h:1854
 Type.h:1855
 Type.h:1856
 Type.h:1857
 Type.h:1858
 Type.h:1859
 Type.h:1860
 Type.h:1861
 Type.h:1862
 Type.h:1863
 Type.h:1864
 Type.h:1865
 Type.h:1866
 Type.h:1867
 Type.h:1868
 Type.h:1869
 Type.h:1870
 Type.h:1871
 Type.h:1872
 Type.h:1873
 Type.h:1874
 Type.h:1875
 Type.h:1876
 Type.h:1877
 Type.h:1878
 Type.h:1879
 Type.h:1880
 Type.h:1881
 Type.h:1882
 Type.h:1883
 Type.h:1884
 Type.h:1885
 Type.h:1886
 Type.h:1887
 Type.h:1888
 Type.h:1889
 Type.h:1890
 Type.h:1891
 Type.h:1892
 Type.h:1893
 Type.h:1894
 Type.h:1895
 Type.h:1896
 Type.h:1897
 Type.h:1898
 Type.h:1899
 Type.h:1900
 Type.h:1901
 Type.h:1902
 Type.h:1903
 Type.h:1904
 Type.h:1905
 Type.h:1906
 Type.h:1907
 Type.h:1908
 Type.h:1909
 Type.h:1910
 Type.h:1911
 Type.h:1912
 Type.h:1913
 Type.h:1914
 Type.h:1915
 Type.h:1916
 Type.h:1917
 Type.h:1918
 Type.h:1919
 Type.h:1920
 Type.h:1921
 Type.h:1922
 Type.h:1923
 Type.h:1924
 Type.h:1925
 Type.h:1926
 Type.h:1927
 Type.h:1928
 Type.h:1929
 Type.h:1930
 Type.h:1931
 Type.h:1932
 Type.h:1933
 Type.h:1934
 Type.h:1935
 Type.h:1936
 Type.h:1937
 Type.h:1938
 Type.h:1939
 Type.h:1940
 Type.h:1941
 Type.h:1942
 Type.h:1943
 Type.h:1944
 Type.h:1945
 Type.h:1946
 Type.h:1947
 Type.h:1948
 Type.h:1949
 Type.h:1950
 Type.h:1951
 Type.h:1952
 Type.h:1953
 Type.h:1954
 Type.h:1955
 Type.h:1956
 Type.h:1957
 Type.h:1958
 Type.h:1959
 Type.h:1960
 Type.h:1961
 Type.h:1962
 Type.h:1963
 Type.h:1964
 Type.h:1965
 Type.h:1966
 Type.h:1967
 Type.h:1968
 Type.h:1969
 Type.h:1970
 Type.h:1971
 Type.h:1972
 Type.h:1973
 Type.h:1974
 Type.h:1975
 Type.h:1976
 Type.h:1977
 Type.h:1978
 Type.h:1979
 Type.h:1980
 Type.h:1981
 Type.h:1982
 Type.h:1983
 Type.h:1984
 Type.h:1985
 Type.h:1986
 Type.h:1987
 Type.h:1988
 Type.h:1989
 Type.h:1990
 Type.h:1991
 Type.h:1992
 Type.h:1993
 Type.h:1994
 Type.h:1995
 Type.h:1996
 Type.h:1997
 Type.h:1998
 Type.h:1999
 Type.h:2000
 Type.h:2001
 Type.h:2002
 Type.h:2003
 Type.h:2004
 Type.h:2005
 Type.h:2006
 Type.h:2007
 Type.h:2008
 Type.h:2009
 Type.h:2010
 Type.h:2011
 Type.h:2012
 Type.h:2013
 Type.h:2014
 Type.h:2015
 Type.h:2016
 Type.h:2017
 Type.h:2018
 Type.h:2019
 Type.h:2020
 Type.h:2021
 Type.h:2022
 Type.h:2023
 Type.h:2024
 Type.h:2025
 Type.h:2026
 Type.h:2027
 Type.h:2028
 Type.h:2029
 Type.h:2030
 Type.h:2031
 Type.h:2032
 Type.h:2033
 Type.h:2034
 Type.h:2035
 Type.h:2036
 Type.h:2037
 Type.h:2038
 Type.h:2039
 Type.h:2040
 Type.h:2041
 Type.h:2042
 Type.h:2043
 Type.h:2044
 Type.h:2045
 Type.h:2046
 Type.h:2047
 Type.h:2048
 Type.h:2049
 Type.h:2050
 Type.h:2051
 Type.h:2052
 Type.h:2053
 Type.h:2054
 Type.h:2055
 Type.h:2056
 Type.h:2057
 Type.h:2058
 Type.h:2059
 Type.h:2060
 Type.h:2061
 Type.h:2062
 Type.h:2063
 Type.h:2064
 Type.h:2065
 Type.h:2066
 Type.h:2067
 Type.h:2068
 Type.h:2069
 Type.h:2070
 Type.h:2071
 Type.h:2072
 Type.h:2073
 Type.h:2074
 Type.h:2075
 Type.h:2076
 Type.h:2077
 Type.h:2078
 Type.h:2079
 Type.h:2080
 Type.h:2081
 Type.h:2082
 Type.h:2083
 Type.h:2084
 Type.h:2085
 Type.h:2086
 Type.h:2087
 Type.h:2088
 Type.h:2089
 Type.h:2090
 Type.h:2091
 Type.h:2092
 Type.h:2093
 Type.h:2094
 Type.h:2095
 Type.h:2096
 Type.h:2097
 Type.h:2098
 Type.h:2099
 Type.h:2100
 Type.h:2101
 Type.h:2102
 Type.h:2103
 Type.h:2104
 Type.h:2105
 Type.h:2106
 Type.h:2107
 Type.h:2108
 Type.h:2109
 Type.h:2110
 Type.h:2111
 Type.h:2112
 Type.h:2113
 Type.h:2114
 Type.h:2115
 Type.h:2116
 Type.h:2117
 Type.h:2118
 Type.h:2119
 Type.h:2120
 Type.h:2121
 Type.h:2122
 Type.h:2123
 Type.h:2124
 Type.h:2125
 Type.h:2126
 Type.h:2127
 Type.h:2128
 Type.h:2129
 Type.h:2130
 Type.h:2131
 Type.h:2132
 Type.h:2133
 Type.h:2134
 Type.h:2135
 Type.h:2136
 Type.h:2137
 Type.h:2138
 Type.h:2139
 Type.h:2140
 Type.h:2141
 Type.h:2142
 Type.h:2143
 Type.h:2144
 Type.h:2145
 Type.h:2146
 Type.h:2147
 Type.h:2148
 Type.h:2149
 Type.h:2150
 Type.h:2151
 Type.h:2152
 Type.h:2153
 Type.h:2154
 Type.h:2155
 Type.h:2156
 Type.h:2157
 Type.h:2158
 Type.h:2159
 Type.h:2160
 Type.h:2161
 Type.h:2162
 Type.h:2163
 Type.h:2164
 Type.h:2165
 Type.h:2166
 Type.h:2167
 Type.h:2168
 Type.h:2169
 Type.h:2170
 Type.h:2171
 Type.h:2172
 Type.h:2173
 Type.h:2174
 Type.h:2175
 Type.h:2176
 Type.h:2177
 Type.h:2178
 Type.h:2179
 Type.h:2180
 Type.h:2181
 Type.h:2182
 Type.h:2183
 Type.h:2184
 Type.h:2185
 Type.h:2186
 Type.h:2187
 Type.h:2188
 Type.h:2189
 Type.h:2190
 Type.h:2191
 Type.h:2192
 Type.h:2193
 Type.h:2194
 Type.h:2195
 Type.h:2196
 Type.h:2197
 Type.h:2198
 Type.h:2199
 Type.h:2200
 Type.h:2201
 Type.h:2202
 Type.h:2203
 Type.h:2204
 Type.h:2205
 Type.h:2206
 Type.h:2207
 Type.h:2208
 Type.h:2209
 Type.h:2210
 Type.h:2211
 Type.h:2212
 Type.h:2213
 Type.h:2214
 Type.h:2215
 Type.h:2216
 Type.h:2217
 Type.h:2218
 Type.h:2219
 Type.h:2220
 Type.h:2221
 Type.h:2222
 Type.h:2223
 Type.h:2224
 Type.h:2225
 Type.h:2226
 Type.h:2227
 Type.h:2228
 Type.h:2229
 Type.h:2230
 Type.h:2231
 Type.h:2232
 Type.h:2233
 Type.h:2234
 Type.h:2235
 Type.h:2236
 Type.h:2237
 Type.h:2238
 Type.h:2239
 Type.h:2240
 Type.h:2241
 Type.h:2242
 Type.h:2243
 Type.h:2244
 Type.h:2245
 Type.h:2246
 Type.h:2247
 Type.h:2248
 Type.h:2249
 Type.h:2250
 Type.h:2251
 Type.h:2252
 Type.h:2253
 Type.h:2254
 Type.h:2255
 Type.h:2256
 Type.h:2257
 Type.h:2258
 Type.h:2259
 Type.h:2260
 Type.h:2261
 Type.h:2262
 Type.h:2263
 Type.h:2264
 Type.h:2265
 Type.h:2266
 Type.h:2267
 Type.h:2268
 Type.h:2269
 Type.h:2270
 Type.h:2271
 Type.h:2272
 Type.h:2273
 Type.h:2274
 Type.h:2275
 Type.h:2276
 Type.h:2277
 Type.h:2278
 Type.h:2279
 Type.h:2280
 Type.h:2281
 Type.h:2282
 Type.h:2283
 Type.h:2284
 Type.h:2285
 Type.h:2286
 Type.h:2287
 Type.h:2288
 Type.h:2289
 Type.h:2290
 Type.h:2291
 Type.h:2292
 Type.h:2293
 Type.h:2294
 Type.h:2295
 Type.h:2296
 Type.h:2297
 Type.h:2298
 Type.h:2299
 Type.h:2300
 Type.h:2301
 Type.h:2302
 Type.h:2303
 Type.h:2304
 Type.h:2305
 Type.h:2306
 Type.h:2307
 Type.h:2308
 Type.h:2309
 Type.h:2310
 Type.h:2311
 Type.h:2312
 Type.h:2313
 Type.h:2314
 Type.h:2315
 Type.h:2316
 Type.h:2317
 Type.h:2318
 Type.h:2319
 Type.h:2320
 Type.h:2321
 Type.h:2322
 Type.h:2323
 Type.h:2324
 Type.h:2325
 Type.h:2326
 Type.h:2327
 Type.h:2328
 Type.h:2329
 Type.h:2330
 Type.h:2331
 Type.h:2332
 Type.h:2333
 Type.h:2334
 Type.h:2335
 Type.h:2336
 Type.h:2337
 Type.h:2338
 Type.h:2339
 Type.h:2340
 Type.h:2341
 Type.h:2342
 Type.h:2343
 Type.h:2344
 Type.h:2345
 Type.h:2346
 Type.h:2347
 Type.h:2348
 Type.h:2349
 Type.h:2350
 Type.h:2351
 Type.h:2352
 Type.h:2353
 Type.h:2354
 Type.h:2355
 Type.h:2356
 Type.h:2357
 Type.h:2358
 Type.h:2359
 Type.h:2360
 Type.h:2361
 Type.h:2362
 Type.h:2363
 Type.h:2364
 Type.h:2365
 Type.h:2366
 Type.h:2367
 Type.h:2368
 Type.h:2369
 Type.h:2370
 Type.h:2371
 Type.h:2372
 Type.h:2373
 Type.h:2374
 Type.h:2375
 Type.h:2376
 Type.h:2377
 Type.h:2378
 Type.h:2379
 Type.h:2380
 Type.h:2381
 Type.h:2382
 Type.h:2383
 Type.h:2384
 Type.h:2385
 Type.h:2386
 Type.h:2387
 Type.h:2388
 Type.h:2389
 Type.h:2390
 Type.h:2391
 Type.h:2392
 Type.h:2393
 Type.h:2394
 Type.h:2395
 Type.h:2396
 Type.h:2397
 Type.h:2398
 Type.h:2399
 Type.h:2400
 Type.h:2401
 Type.h:2402
 Type.h:2403
 Type.h:2404
 Type.h:2405
 Type.h:2406
 Type.h:2407
 Type.h:2408
 Type.h:2409
 Type.h:2410
 Type.h:2411
 Type.h:2412
 Type.h:2413
 Type.h:2414
 Type.h:2415
 Type.h:2416
 Type.h:2417
 Type.h:2418
 Type.h:2419
 Type.h:2420
 Type.h:2421