Main Page   Class Hierarchy   Compound List   File List   Compound Members  

type.h

00001 #ifndef __TYPE_H__
00002 #define __TYPE_H__
00003 
00004 #include <string.h>
00005 
00006 class RTTIClassDescriptor;
00007 class RTTIFieldDescriptor;
00008 
00012 class RTTI_DLL_ENTRY RTTIType { 
00013   public:
00018     int  getTag() { 
00019         return tag;
00020     }
00021 
00026     virtual void getTypeName(char* buf);
00027 
00028     static RTTIType voidType;
00029     static RTTIType charType;
00030     static RTTIType ucharType;
00031     static RTTIType scharType;
00032     static RTTIType shortType;
00033     static RTTIType ushortType;
00034     static RTTIType intType;
00035     static RTTIType uintType;
00036     static RTTIType longType;
00037     static RTTIType ulongType;
00038     static RTTIType floatType;
00039     static RTTIType doubleType;
00040     static RTTIType boolType;
00041     static RTTIType unknownType;
00042 
00043     enum TypeTag { 
00044         RTTI_UNKNOWN, 
00045         RTTI_VOID, 
00046         RTTI_CHAR, 
00047         RTTI_UCHAR, 
00048         RTTI_SCHAR, 
00049         RTTI_SHORT, 
00050         RTTI_USHORT, 
00051         RTTI_INT, 
00052         RTTI_UINT, 
00053         RTTI_LONG, 
00054         RTTI_ULONG, 
00055         RTTI_FLOAT, 
00056         RTTI_DOUBLE, 
00057         RTTI_BOOL, 
00058         RTTI_ARRAY, 
00059         RTTI_STRUCT, 
00060         RTTI_PTR,  
00061         RTTI_DERIVED,
00062         RTTI_METHOD 
00063     };
00064     
00068     bool isBuiltin() { 
00069         return tag <= RTTI_BOOL;
00070     }
00071     
00075     bool isScalar() { 
00076         return tag > RTTI_VOID && tag <= RTTI_BOOL;
00077     } 
00078         
00082     bool isArray() { 
00083         return tag == RTTI_ARRAY;
00084     }
00085 
00089     bool isPointer() { 
00090         return tag == RTTI_PTR;
00091     }
00092 
00096     bool isClass() { 
00097         return tag == RTTI_STRUCT;
00098     }
00099 
00103     bool isBaseClass() { 
00104         return tag == RTTI_DERIVED;
00105     }
00106     
00110     ~RTTIType();
00111 
00112   protected:
00113     friend class RTTIClassDescriptor;
00114     friend class RTTIFieldDescriptor;
00115     friend class RTTIMethodDescriptor;
00116 
00117     int   tag;
00118 
00119     void destroy() {
00120         if (!isBuiltin()) { 
00121             delete this;
00122         }
00123     }
00124 
00125     RTTIType(int tag) { 
00126         this->tag = tag;
00127     }
00128 };
00129  
00130 
00134 class RTTI_DLL_ENTRY RTTIPtrType : public RTTIType {     
00135   public:
00136     RTTIPtrType(RTTIType* ptrType) : RTTIType(RTTI_PTR) {
00137         this->ptrType = ptrType;
00138     }
00139     void getTypeName(char* buf);
00140   protected:
00141     RTTIType* ptrType;
00142 };
00143 
00147 class RTTI_DLL_ENTRY RTTIArrayType : public RTTIType {     
00148   public:
00149     RTTIArrayType(RTTIType* elemType, int nElems) : RTTIType(RTTI_ARRAY) {
00150         this->elemType = elemType;
00151         this->nElems = nElems;
00152     }
00153     void getTypeName(char* buf);
00154 
00155     int  getArraySize() { 
00156         return nElems;
00157     }
00158 
00159     RTTIType* getElementType() { 
00160         return elemType;
00161     }
00162 
00163   protected:
00164     RTTIType* elemType;
00165     int       nElems;
00166 };
00167 
00171 class RTTI_DLL_ENTRY RTTIDerivedType : public RTTIType {     
00172   public:
00173     RTTIDerivedType(RTTIClassDescriptor* baseClass) : RTTIType(RTTI_DERIVED) {
00174         this->baseClass = baseClass;
00175     }
00176     
00177     RTTIClassDescriptor* getBaseClass() { 
00178         return baseClass;
00179     }
00180 
00181     void getTypeName(char* buf);
00182 
00183   protected:
00184     RTTIClassDescriptor* baseClass;
00185 };
00186 
00190 class RTTI_DLL_ENTRY RTTIMethodType : public RTTIType { 
00191   public:
00192     void getTypeName(char* buf);
00193     
00194     void getMethodDeclaration(char* buf, char const* name);
00195 
00196     virtual void invoke(void* result, void* obj, void* parameters[]) = 0;
00197 
00198     RTTIClassDescriptor* getClass() { 
00199         return methodClass;
00200     }
00201 
00202     RTTIType* getReturnType() { 
00203         return returnType;
00204     }
00205 
00206     RTTIType** getParameterTypes() { 
00207         return paramTypes;
00208     }
00209 
00210     int getNumberOfParameters() { 
00211         return nParams;
00212     }
00213 
00214     RTTIMethodType() : RTTIType(RTTI_METHOD) {}
00215     ~RTTIMethodType() { 
00216         delete[] paramTypes;
00217     }
00218   protected:
00219     friend class RTTIMethodDescriptor;
00220     friend class RTTIBfdRepository;
00221 
00222     RTTIType*  returnType;
00223     int        nParams;
00224     RTTIType** paramTypes;
00225     RTTIClassDescriptor* methodClass;
00226     bool       isStatic;
00227 };
00228         
00229 
00230 #endif
00231 

Generated on Fri Apr 26 17:39:24 2002 for CppReflection by doxygen1.2.15