1 /*****************************************************************************/ 2 /* Software Testing Automation Framework (STAF) */ 3 /* (C) Copyright IBM Corp. 2001 */ 4 /* */ 5 /* This software is licensed under the Eclipse Public License (EPL) V1.0. */ 6 /*****************************************************************************/ 7 8 #ifndef STAF_DataTypes 9 #define STAF_DataTypes 10 11 #include "STAFString.h" 12 13 #ifdef __cplusplus 14 extern "C" { 15 #endif 16 17 /* Begin C language definitions */ 18 19 typedef enum 20 { 21 kSTAFNoneObject = 0, 22 kSTAFScalarStringObject = 1, 23 kSTAFListObject = 2, 24 kSTAFMapObject = 3, 25 kSTAFMarshallingContextObject = 4 26 } STAFObjectType_t; 27 28 typedef struct STAFObjectImpl *STAFObject_t; 29 typedef struct STAFObjectIteratorImpl *STAFObjectIterator_t; 30 31 typedef enum 32 { 33 kSTAFMarshallingDefaults = 0x00000000 34 } STAFObjectMarshallingFlags_t; 35 36 37 typedef enum 38 { 39 kSTAFUnmarshallingDefaults = 0x00000000, 40 kSTAFIgnoreIndirectObjects = 0x00000001 41 } STAFObjectUnmarshallingFlags_t; 42 43 44 // Object constructors/destructors 45 // 46 // Note: When a STAFObject is destructed, it recursively deletes all nested 47 // objects 48 // 49 // Note: Might need to require a Marshalling Context in order to be able 50 // to construct objects. It could be handy for validating metadata, etc. 51 52 STAFRC_t STAFObjectConstructCopy(STAFObject_t *copy, STAFObject_t source); 53 STAFRC_t STAFObjectConstructReference(STAFObject_t *ref, STAFObject_t source); 54 STAFRC_t STAFObjectConstructNone(STAFObject_t *pNone); 55 STAFRC_t STAFObjectConstructScalarString(STAFObject_t *pScalar, 56 STAFStringConst_t string); 57 STAFRC_t STAFObjectConstructList(STAFObject_t *list); 58 STAFRC_t STAFObjectConstructMap(STAFObject_t *map); 59 STAFRC_t STAFObjectConstructMarshallingContext(STAFObject_t *context); 60 STAFRC_t STAFObjectDestruct(STAFObject_t *object); 61 62 // General functions 63 64 STAFRC_t STAFObjectIsStringMarshalledData(STAFStringConst_t string, 65 unsigned int *isMarshalledData); 66 67 // Object functions 68 69 STAFRC_t STAFObjectGetType(STAFObject_t object, STAFObjectType_t *type); 70 STAFRC_t STAFObjectGetSize(STAFObject_t object, unsigned int *size); 71 STAFRC_t STAFObjectIsReference(STAFObject_t object, unsigned int *isRef); 72 STAFRC_t STAFObjectUnmarshallFromString(STAFObject_t *newContext, 73 STAFStringConst_t string, 74 STAFObject_t context, 75 unsigned int flags); 76 STAFRC_t STAFObjectMarshallToString(STAFObject_t object, STAFObject_t context, 77 STAFString_t *string, unsigned int flags); 78 STAFRC_t STAFObjectGetStringValue(STAFObject_t object, STAFString_t *string); 79 STAFRC_t STAFObjectGetFormattedStringValue(STAFObject_t object, 80 STAFString_t *string, 81 unsigned int flags); 82 83 // Scalar functions 84 85 STAFRC_t STAFObjectScalarGetStringValue(STAFObject_t object, 86 STAFStringConst_t *string); 87 STAFRC_t STAFObjectScalarGetUIntValue(STAFObject_t object, 88 unsigned int *uInt, 89 unsigned int defaultValue); 90 91 // List functions 92 93 STAFRC_t STAFObjectListAppend(STAFObject_t list, STAFObject_t object); 94 95 // Iterator functions 96 97 STAFRC_t STAFObjectConstructListIterator(STAFObjectIterator_t *iter, 98 STAFObject_t list); 99 STAFRC_t STAFObjectIteratorHasNext(STAFObjectIterator_t iter, 100 unsigned int *hasNext); 101 STAFRC_t STAFObjectIteratorGetNext(STAFObjectIterator_t iter, 102 STAFObject_t *object); 103 STAFRC_t STAFObjectIteratorDestruct(STAFObjectIterator_t *iter); 104 105 // Map functions 106 107 STAFRC_t STAFObjectMapGet(STAFObject_t map, STAFStringConst_t key, 108 STAFObject_t *object); 109 STAFRC_t STAFObjectMapPut(STAFObject_t map, STAFStringConst_t key, 110 STAFObject_t object); 111 STAFRC_t STAFObjectMapHasKey(STAFObject_t map, STAFStringConst_t key, 112 unsigned int *hasKey); 113 STAFRC_t STAFObjectConstructMapKeyIterator(STAFObjectIterator_t *pIter, 114 STAFObject_t map); 115 STAFRC_t STAFObjectConstructMapValueIterator(STAFObjectIterator_t *pIter, 116 STAFObject_t map); 117 118 // Marshalling Context functions 119 120 STAFRC_t STAFObjectMarshallingContextSetMapClassDefinition( 121 STAFObject_t context, 122 STAFStringConst_t name, 123 STAFObject_t mapClassDefinition); 124 125 STAFRC_t STAFObjectMarshallingContextGetMapClassDefinition( 126 STAFObject_t context, 127 STAFStringConst_t name, 128 STAFObject_t *mapClassDefinition); 129 130 STAFRC_t STAFObjectMarshallingContextHasMapClassDefinition( 131 STAFObject_t context, 132 STAFStringConst_t name, 133 unsigned int *pHasMapClassDefinition); 134 135 STAFRC_t STAFObjectMarshallingContextSetRootObject(STAFObject_t context, 136 STAFObject_t object); 137 STAFRC_t STAFObjectMarshallingContextGetRootObject(STAFObject_t context, 138 STAFObject_t *object); 139 STAFRC_t STAFObjectMarshallingContextAdoptRootObject(STAFObject_t context, 140 STAFObject_t *object); 141 STAFRC_t STAFObjectMarshallingContextGetPrimaryObject(STAFObject_t context, 142 STAFObject_t *object); 143 STAFRC_t STAFObjectConstructMapClassDefinitionIterator( 144 STAFObjectIterator_t *pIter, STAFObject_t context); 145 146 /* End C language definitions */ 147 148 #ifdef __cplusplus 149 } 150 151 /* Begin C++ language definitions */ 152 153 #include "STAFRefPtr.h" 154 155 class STAFObject; 156 typedef STAFRefPtr<STAFObject> STAFObjectPtr; 157 158 159 class STAFObjectIterator 160 { 161 public: 162 163 bool hasNext(); 164 STAFObjectPtr next(); 165 166 ~STAFObjectIterator(); 167 168 private: 169 170 // Don't allow copy construction or assignment 171 STAFObjectIterator(const STAFObjectIterator &); 172 STAFObjectIterator &operator=(const STAFObjectIterator &); 173 174 STAFObjectIterator(STAFObjectIterator_t iter); 175 176 friend class STAFObject; 177 178 STAFObjectIterator_t fIter; 179 }; 180 181 typedef STAFRefPtr<STAFObjectIterator> STAFObjectIteratorPtr; 182 183 184 class STAFMapClassDefinition; 185 typedef STAFRefPtr<STAFMapClassDefinition> STAFMapClassDefinitionPtr; 186 187 class STAFMapClassDefinition 188 { 189 public: 190 191 static STAFMapClassDefinitionPtr create(const STAFString &name); 192 static STAFMapClassDefinitionPtr createReference( 193 STAFMapClassDefinitionPtr source); 194 195 STAFObjectPtr createInstance(); 196 197 STAFMapClassDefinitionPtr reference(); 198 199 void addKey(const STAFString &keyName); 200 void addKey(const STAFString &keyName, const STAFString &displayName); 201 202 void setKeyProperty(const STAFString &keyName, const STAFString &propName, 203 const STAFString &propValue); 204 205 STAFObjectIteratorPtr keyIterator(); 206 207 STAFString name() const; 208 209 STAFObjectPtr getMapClassDefinitionObject(); 210 211 private: 212 213 STAFMapClassDefinition(STAFObjectPtr mapClassDefObj); 214 215 friend class STAFObject; 216 217 STAFObjectPtr fMapClassDefObj; 218 }; 219 220 221 222 class STAFObject 223 { 224 public: 225 226 // Creation methods 227 228 static STAFObjectPtr create(STAFObject_t source); 229 static STAFObjectPtr createReference(const STAFObject &source); 230 static STAFObjectPtr createReference(const STAFObjectPtr &source); 231 static STAFObjectPtr createReference(STAFObject_t source); 232 static STAFObjectPtr createNone(); 233 static STAFObjectPtr createScalar(const STAFString &aString); 234 static STAFObjectPtr createList(); 235 static STAFObjectPtr createMap(); 236 static STAFObjectPtr createMarshallingContext(); 237 238 // General methods 239 240 static bool isMarshalledData(const STAFString &aString); 241 242 // General object methods 243 244 STAFObjectType_t type(); 245 unsigned int size(); 246 247 bool isRef(); 248 STAFObjectPtr reference(); 249 250 STAFString asString(); 251 STAFString asFormattedString(); 252 253 STAFString marshall(unsigned int flags = kSTAFMarshallingDefaults); 254 void marshall(STAFString &output, 255 unsigned int flags = kSTAFMarshallingDefaults); 256 257 // Note: This method always returns a Marshalling Context 258 static STAFObjectPtr unmarshall(const STAFString &input, 259 unsigned int flags = 260 kSTAFUnmarshallingDefaults); 261 262 STAFObject_t getImpl(); 263 264 // List methods 265 266 void append(const STAFObjectPtr &objPtr); 267 void append(const STAFString &aString); 268 269 STAFObjectIteratorPtr iterate(); 270 271 // Map methods 272 273 bool hasKey(const STAFString &key); 274 275 STAFObjectPtr get(const STAFString &key); 276 277 void put(const STAFString &key, const STAFObjectPtr &objPtr); 278 void put(const STAFString &key, const STAFString &aString); 279 280 STAFObjectIteratorPtr keyIterator(); 281 STAFObjectIteratorPtr valueIterator(); 282 283 // Marshalling Context methods 284 285 void setMapClassDefinition(const STAFMapClassDefinitionPtr &defPtr); 286 287 STAFMapClassDefinitionPtr getMapClassDefinition(const STAFString &name); 288 289 bool hasMapClassDefinition(const STAFString &name); 290 291 STAFObjectIteratorPtr mapClassDefinitionIterator(); 292 293 void setRootObject(const STAFObjectPtr &objPtr); 294 STAFObjectPtr getRootObject(); 295 296 // Destructor 297 298 ~STAFObject(); 299 300 private: 301 302 // Don't allow copy construction or assignment 303 STAFObject(const STAFObject &); 304 STAFObject &operator=(const STAFObject &); 305 306 friend class STAFObjectIterator; 307 308 enum ObjectType 309 { 310 STAF_NONE_OBJECT = 0, 311 STAF_LIST_OBJECT = 1, 312 STAF_MAP_OBJECT = 2, 313 STAF_MARSHALLING_CONTEXT_OBJECT = 3 314 }; 315 316 enum ObjectRef 317 { 318 STAF_REF_OBJECT = 0 319 }; 320 321 STAFObject(const STAFString &aString); 322 STAFObject(ObjectType objType); 323 STAFObject(ObjectRef objRefMarker, STAFObject_t); 324 STAFObject(STAFObject_t obj); 325 326 void append(const STAFObject &obj); 327 void put(const STAFString &key, const STAFObject &obj); 328 void setMapClassDefinition(const STAFMapClassDefinition &def); 329 void setRootObject(const STAFObject &obj); 330 331 STAFObject_t fObject; 332 }; 333 334 // Now include inline definitions 335 336 #ifndef STAF_NATIVE_COMPILER 337 #include "STAFDataTypesInlImpl.cpp" 338 #endif 339 340 // End C++ language definitions 341 342 // End #ifdef __cplusplus 343 #endif 344 345 #endif 346