Home | History | Annotate | Download | only in dae 
      1 /*
      2 * Copyright 2006 Sony Computer Entertainment Inc.
      3 *
      4 * Licensed under the MIT Open Source License, for details please see license.txt or the website
      5 * http://www.opensource.org/licenses/mit-license.php
      6 *
      7 */
      8 
      9 #include <sstream>
     10 #include <dae/daeAtomicType.h>
     11 #include <dae/daeElement.h>
     12 #include <dae/daeURI.h>
     13 #include <dae/daeIDRef.h>
     14 #include <dae/daeMetaElement.h>
     15 #include <dae/daeDatabase.h>
     16 #include <dae/daeErrorHandler.h>
     17 #include <dae/daeUtils.h>
     18 
     19 namespace {
     20 	// Skip leading whitespace
     21 	daeChar* skipWhitespace(daeChar* s) {
     22 		if (s) {
     23 			// !!!GAC NEEDS TO BE CHANGED to use XML standard whitespace parsing
     24 			while(*s == ' ' || *s == '\r' || *s == '\n' || *s == '\t') s++;
     25 		}
     26 
     27 		return s;
     28 	}
     29 
     30 	// Move forward past this token
     31 	daeChar* skipToken(daeChar* s) {
     32 		while(*s != ' ' && *s != '\r' && *s != '\n' && *s != '\t' && *s != 0) s++;
     33 		return s;
     34 	}
     35 
     36 	// Given a string of whitespace-separated tokens, this function returns a null-terminated string
     37 	// containing the next token. If the next token is already null-terminated, no memory is allocated
     38 	// and the function returns the pointer that was passed in. Note that this function assumes that
     39 	// the string passed in starts with the next token and not a whitespace.
     40 	// If returnValue != s, the client should free the returnValue with delete[].
     41 	daeChar* extractToken(daeChar* s) {
     42 		if (!s)
     43 			return 0;
     44 
     45 		daeChar* tmp = skipToken(s);
     46 		if (*tmp != 0) {
     47 			daeChar* scopy = new daeChar[tmp-s+1];
     48 			strncpy(scopy, s, tmp-s);
     49 			scopy[tmp-s] = 0;
     50 			return scopy;
     51 		}
     52 
     53 		return s;
     54 	}
     55 }
     56 
     57 
     58 daeAtomicTypeList::daeAtomicTypeList(DAE& dae) {
     59 	types.append(new daeUIntType(dae));
     60 	types.append(new daeIntType(dae));
     61 	types.append(new daeLongType(dae));
     62 	types.append(new daeShortType(dae));
     63 	types.append(new daeULongType(dae));
     64 	types.append(new daeFloatType(dae));
     65 	types.append(new daeDoubleType(dae));
     66 	types.append(new daeStringRefType(dae));
     67 	types.append(new daeElementRefType(dae));
     68 	types.append(new daeEnumType(dae));
     69 	types.append(new daeRawRefType(dae));
     70 	types.append(new daeResolverType(dae));
     71 	types.append(new daeIDResolverType(dae));
     72 	types.append(new daeBoolType(dae));
     73 	types.append(new daeTokenType(dae));
     74 }
     75 
     76 daeAtomicTypeList::~daeAtomicTypeList() {
     77 	size_t types_count = types.getCount();
     78 	for (size_t i = 0; i < types_count; i++)
     79 		delete types[i];
     80 }
     81 
     82 daeInt daeAtomicTypeList::append(daeAtomicType* t) {
     83 	return (daeInt)types.append(t);
     84 }
     85 
     86 const daeAtomicType* daeAtomicTypeList::getByIndex(daeInt index) {
     87 	return types[index];
     88 }
     89 
     90 daeInt daeAtomicTypeList::getCount() {
     91 	return (daeInt)types.getCount();
     92 }
     93 
     94 daeAtomicType* daeAtomicTypeList::get(daeStringRef typeString) {
     95 	size_t types_count = types.getCount();
     96 	for (size_t i = 0; i < types_count; i++) {
     97 		daeStringRefArray& nameBindings = types[i]->getNameBindings();
     98 		size_t nameBindings_count = nameBindings.getCount();
     99 		for (size_t j = 0; j < nameBindings_count; j++) {
    100 			if (strcmp(typeString, nameBindings[j]) == 0)
    101 				return types[i];
    102 		}
    103 	}
    104 
    105 	return NULL;
    106 }
    107 
    108 daeAtomicType* daeAtomicTypeList::get(daeEnum typeEnum) {
    109 	size_t types_count = types.getCount();
    110 	for (size_t i = 0; i < types_count; i++)
    111 		if (typeEnum == types[i]->getTypeEnum())
    112 			return types[i];
    113 	return NULL;
    114 }
    115 
    116 
    117 daeAtomicType::daeAtomicType(DAE& dae)
    118 {
    119 	_dae = &dae;
    120 	_size = -1;
    121 	_alignment = -1;
    122 	_typeEnum = -1;
    123 	_typeString = "notype";
    124 	_printFormat = "badtype";
    125 	_scanFormat = "";
    126 	_maxStringLength = -1;
    127 }
    128 
    129 daeBool
    130 daeAtomicType::stringToMemory(daeChar *src, daeChar* dstMemory)
    131 {
    132 	sscanf(src, _scanFormat, dstMemory);
    133 	return true;
    134 }
    135 
    136 void daeAtomicType::arrayToString(daeArray& array, std::ostringstream& buffer) {
    137 	if (array.getCount() > 0)
    138 		memoryToString(array.getRaw(0), buffer);
    139 
    140 	size_t array_count = array.getCount();
    141 	for (size_t i = 1; i < array_count; i++) {
    142 		buffer << ' ';
    143 		memoryToString(array.getRaw(i), buffer);
    144 	}
    145 }
    146 
    147 daeBool
    148 daeAtomicType::stringToArray(daeChar* src, daeArray& array) {
    149 	array.clear();
    150 	array.setElementSize(_size);
    151 
    152 	if (src == 0)
    153 		return false;
    154 
    155 	// We're about to insert null terminators into the string so that scanf doesn't take forever
    156 	// doing strlens. Since the memory might not be writable, I need to duplicate the string and
    157 	// write into the duplicate, or else I might get access violations.
    158 	// This sucks... surely we can do better than this.
    159 	daeChar* srcDup = new daeChar[strlen(src)+1];
    160 	strcpy(srcDup, src);
    161 	src = srcDup;
    162 
    163 	while (*src != 0)
    164 	{
    165 		src = skipWhitespace(src);
    166 		if(*src != 0)
    167 		{
    168 			daeChar* token = src;
    169 			src = skipToken(src);
    170 			daeChar temp = *src;
    171 			*src = 0;
    172 			size_t count = array.getCount();
    173 			array.setCount(count+1);
    174 			if (!stringToMemory(token, array.getRaw(count))) {
    175 				delete[] srcDup;
    176 				return false;
    177 			}
    178 
    179 			*src = temp;
    180 		}
    181 	}
    182 
    183 	delete[] srcDup;
    184 	return true;
    185 }
    186 
    187 daeInt daeAtomicType::compareArray(daeArray& value1, daeArray& value2) {
    188 	if (value1.getCount() != value2.getCount())
    189 		return value1.getCount() > value2.getCount() ? 1 : -1;
    190 
    191 	size_t value1_count = value1.getCount();
    192 	for (size_t i = 0; i < value1_count; i++) {
    193 		daeInt result = compare(value1.getRaw(i), value2.getRaw(i));
    194 		if (result != 0)
    195 			return result;
    196 	}
    197 
    198 	return 0;
    199 }
    200 
    201 void daeAtomicType::copyArray(daeArray& src, daeArray& dst) {
    202 	dst.setCount(src.getCount());
    203 	size_t src_count = src.getCount();
    204 	for (size_t i = 0; i < src_count; i++)
    205 		copy(src.getRaw(i), dst.getRaw(i));
    206 }
    207 
    208 daeInt
    209 daeAtomicType::compare(daeChar* value1, daeChar* value2) {
    210 	return memcmp(value1, value2, _size);
    211 }
    212 
    213 daeEnumType::daeEnumType(DAE& dae) : daeAtomicType(dae)
    214 {
    215 	_size = sizeof(daeEnum);
    216 	_alignment = sizeof(daeEnum);
    217 	_typeEnum = EnumType;
    218 	_nameBindings.append("enum");
    219 	_printFormat = "%s";//"%%.%ds";
    220 	_scanFormat = "%s";
    221 	_strings = NULL;
    222 	_values = NULL;
    223 	_typeString = "enum";
    224 }
    225 
    226 daeEnumType::~daeEnumType() {
    227 	if ( _strings ) {
    228 		delete _strings;
    229 		_strings = NULL;
    230 	}
    231 	if ( _values ) {
    232 		delete _values;
    233 		_values = NULL;
    234 	}
    235 }
    236 
    237 daeBoolType::daeBoolType(DAE& dae) : daeAtomicType(dae)
    238 {
    239 	_size = sizeof(daeBool);
    240 	_alignment = sizeof(daeBool);
    241 	_typeEnum = BoolType;
    242 	_printFormat = "%d";
    243 	_scanFormat = "%d";
    244 	_typeString = "bool";
    245 	_maxStringLength = (daeInt)strlen("false")+1;
    246 	_nameBindings.append("bool");
    247 	//_nameBindings.append("xsBool");
    248 	_nameBindings.append("xsBoolean");
    249 }
    250 
    251 daeIntType::daeIntType(DAE& dae) : daeAtomicType(dae)
    252 {
    253 	_size = sizeof(daeInt);
    254 	_alignment = sizeof(daeInt);
    255 	_typeEnum = IntType;
    256 	_maxStringLength = 16;
    257 	_nameBindings.append("int");
    258 	_nameBindings.append("xsInteger");
    259 	_nameBindings.append("xsHexBinary");
    260 	_nameBindings.append("xsIntegerArray");
    261 	_nameBindings.append("xsHexBinaryArray");
    262 	_nameBindings.append("xsByte");
    263 	_nameBindings.append("xsInt");
    264 	_printFormat = "%d";
    265 	_scanFormat = "%d";
    266 	_typeString = "int";
    267 }
    268 daeLongType::daeLongType(DAE& dae) : daeAtomicType(dae)
    269 {
    270 	_size = sizeof(daeLong);
    271 	_alignment = sizeof(daeLong);
    272 	_typeEnum = LongType;
    273 	_maxStringLength = 32;
    274 	_nameBindings.append("xsLong");
    275 	_nameBindings.append("xsLongArray");
    276 #if defined(_MSC_VER) || defined(__MINGW32__)
    277 	_printFormat = "%I64d";
    278 	_scanFormat = "%I64d";
    279 #else
    280 	_printFormat = "%lld";
    281 	_scanFormat = "%lld";
    282 #endif
    283 	_typeString = "long";
    284 }
    285 daeShortType::daeShortType(DAE& dae) : daeAtomicType(dae)
    286 {
    287 	_maxStringLength = 8;
    288 	_size = sizeof(daeShort);
    289 	_alignment = sizeof(daeShort);
    290 	_typeEnum = ShortType;
    291 	_nameBindings.append("short");
    292 	_nameBindings.append("xsShort");
    293 	_printFormat = "%hd";
    294 	_scanFormat = "%hd";
    295 	_typeString = "short";
    296 }
    297 daeUIntType::daeUIntType(DAE& dae) : daeAtomicType(dae)
    298 {
    299 	_maxStringLength = 16;
    300 	_size = sizeof(daeUInt);
    301 	_alignment = sizeof(daeUInt);
    302 	_typeEnum = UIntType;
    303 	_nameBindings.append("uint");
    304 	_nameBindings.append("xsNonNegativeInteger");
    305 	_nameBindings.append("xsUnsignedByte");
    306 	_nameBindings.append("xsUnsignedInt");
    307 	_nameBindings.append("xsPositiveInteger");
    308 	_printFormat = "%u";
    309 	_scanFormat = "%u";
    310 	_typeString = "uint";
    311 }
    312 daeULongType::daeULongType(DAE& dae) : daeAtomicType(dae)
    313 {
    314 	_size = sizeof(daeULong);
    315 	_alignment = sizeof(daeULong);
    316 	_typeEnum = ULongType;
    317 	_maxStringLength = 32;
    318 	_nameBindings.append("ulong");
    319 	_nameBindings.append("xsUnsignedLong");
    320 #if defined(_MSC_VER) || defined(__MINGW32__)
    321 	_printFormat = "%I64u";
    322 	_scanFormat = "%I64u";
    323 #else
    324 	_printFormat = "%llu";
    325 	_scanFormat = "%llu";
    326 #endif
    327 	_typeString = "ulong";
    328 }
    329 daeFloatType::daeFloatType(DAE& dae) : daeAtomicType(dae)
    330 {
    331 	_maxStringLength = 64;
    332 	_size = sizeof(daeFloat);
    333 	_alignment = sizeof(daeFloat);
    334 	_typeEnum = FloatType;
    335 	_nameBindings.append("float");
    336 	_nameBindings.append("xsFloat");
    337 	_printFormat = "%g";
    338 	_scanFormat = "%g";
    339 	_typeString = "float";
    340 }
    341 daeDoubleType::daeDoubleType(DAE& dae) : daeAtomicType(dae)
    342 {
    343 	_size = sizeof(daeDouble);
    344 	_alignment = sizeof(daeDouble);
    345 	_typeEnum = DoubleType;
    346 	_nameBindings.append("double");
    347 	_nameBindings.append("xsDouble");
    348 	_nameBindings.append("xsDecimal");
    349 	_printFormat = "%lg";
    350 	_scanFormat = "%lg";
    351 	_typeString = "double";
    352 	_maxStringLength = 64;
    353 }
    354 
    355 daeStringRefType::daeStringRefType(DAE& dae) : daeAtomicType(dae)
    356 {
    357 	_size = sizeof(daeStringRef);
    358 	_alignment = sizeof(daeStringRef);
    359 	_typeEnum = StringRefType;
    360 	_nameBindings.append("string");
    361 	_nameBindings.append("xsString");
    362 	_nameBindings.append("xsDateTime");
    363 	_printFormat = "%s";
    364 	_scanFormat = "%s";
    365 	_typeString = "string";
    366 }
    367 
    368 daeTokenType::daeTokenType(DAE& dae) : daeStringRefType(dae)
    369 {
    370 	_size = sizeof(daeStringRef);
    371 	_alignment = sizeof(daeStringRef);
    372 	_typeEnum = TokenType;
    373 	_nameBindings.append("token");
    374 	_nameBindings.append("xsID");
    375 	_nameBindings.append("xsNCName");
    376 	_nameBindings.append("xsNMTOKEN");
    377 	_nameBindings.append("xsName");
    378 	_nameBindings.append("xsToken");
    379 	_nameBindings.append("xsNameArray");
    380 	_nameBindings.append("xsTokenArray");
    381 	_nameBindings.append("xsNCNameArray");
    382 	_printFormat = "%s";
    383 	_scanFormat = "%s";
    384 	_typeString = "token";
    385 }
    386 
    387 daeElementRefType::daeElementRefType(DAE& dae) : daeAtomicType(dae)
    388 {
    389 	_size = sizeof(daeElementRef);
    390 	_alignment = sizeof(daeElementRef);
    391 	_typeEnum = ElementRefType;
    392 	_nameBindings.append("element");
    393 	_nameBindings.append("Element");
    394 	_nameBindings.append("TrackedElement");
    395 	_printFormat = "%p";
    396 	_scanFormat = "%p";
    397 	_typeString = "element";
    398 	_maxStringLength = 64;
    399 }
    400 
    401 daeRawRefType::daeRawRefType(DAE& dae) : daeAtomicType(dae)
    402 {
    403 	_size = sizeof(daeRawRef);
    404 	_alignment = sizeof(daeRawRef);
    405 	_typeEnum = RawRefType;
    406 	_nameBindings.append("raw");
    407 	_printFormat = "%p";
    408 	_scanFormat = "%p";
    409 	_typeString = "raw";
    410 	_maxStringLength = 64;
    411 }
    412 
    413 daeResolverType::daeResolverType(DAE& dae) : daeAtomicType(dae)
    414 {
    415 	_size = sizeof(daeURI);
    416 	_alignment = sizeof(daeURI);
    417 	_typeEnum = ResolverType;
    418 	_nameBindings.append("resolver");
    419 	_nameBindings.append("xsAnyURI");
    420 	_printFormat = "%s";
    421 	_scanFormat = "%s";
    422 	_typeString = "resolver";
    423 }
    424 daeIDResolverType::daeIDResolverType(DAE& dae) : daeAtomicType(dae)
    425 {
    426 	_size = sizeof(daeIDRef);
    427 	_alignment = sizeof(daeIDRef);
    428 	_typeEnum = IDResolverType;
    429 	_nameBindings.append("xsIDREF");
    430 	_nameBindings.append("xsIDREFS");
    431 	_printFormat = "%s";
    432 	_scanFormat = "%s";
    433 	_typeString = "idref_resolver";
    434 }
    435 
    436 daeBool daeIntType::memoryToString(daeChar* src, std::ostringstream& dst) {
    437 	dst << *(daeInt*)src;
    438 	return true;
    439 }
    440 
    441 daeBool daeLongType::memoryToString(daeChar* src, std::ostringstream& dst) {
    442 	dst << *(daeLong*)src;
    443 	return true;
    444 }
    445 
    446 daeBool daeShortType::memoryToString(daeChar* src, std::ostringstream& dst) {
    447 	dst << *(daeShort*)src;
    448 	return true;
    449 }
    450 
    451 daeBool daeUIntType::memoryToString(daeChar* src, std::ostringstream& dst) {
    452 	dst << *(daeUInt*)src;
    453 	return true;
    454 }
    455 
    456 daeBool daeULongType::memoryToString(daeChar* src, std::ostringstream& dst) {
    457 #ifdef _MSC_VER
    458 	// Microsoft's stringstream implementation has weird performance issues
    459 	static char buffer[64];
    460 	_snprintf(buffer, 64, _printFormat, *((daeULong*)src));
    461 	dst << buffer;
    462 #else
    463 	dst << *(daeULong*)src;
    464 #endif
    465 	return true;
    466 }
    467 
    468 daeBool daeFloatType::memoryToString(daeChar* src, std::ostringstream& dst) {
    469 	if ( *(daeFloat*)src != *(daeFloat*)src ) // NAN
    470 		dst << "NaN";
    471 	else if ( *(daeUInt*)src == 0x7f800000 ) // +INF
    472 		dst << "INF";
    473 	else if ( *(daeUInt*)src == 0xff800000 ) // -INF
    474 		dst << "-INF";
    475 	else
    476 		dst << *(daeFloat*)src;
    477 	return true;
    478 }
    479 
    480 daeBool
    481 daeFloatType::stringToMemory(daeChar *src, daeChar* dstMemory)
    482 {
    483 	src = skipWhitespace(src);
    484 
    485 	if ( strncmp(src, "NaN", 3) == 0 ) {
    486 		daeErrorHandler::get()->handleWarning("NaN encountered while setting an attribute or value\n");
    487 		*(daeInt*)(dstMemory) = 0x7f800002;
    488 	}
    489 	else if ( strncmp(src, "INF", 3) == 0 ) {
    490 		daeErrorHandler::get()->handleWarning( "INF encountered while setting an attribute or value\n" );
    491 		*(daeInt*)(dstMemory) = 0x7f800000;
    492 	}
    493 	else if ( strncmp(src, "-INF", 4) == 0 ) {
    494 		daeErrorHandler::get()->handleWarning( "-INF encountered while setting an attribute or value\n" );
    495 		*(daeInt*)(dstMemory) = 0xff800000;
    496 	}
    497 	else
    498 	{
    499 		sscanf(src, _scanFormat, dstMemory);
    500 	}
    501 	return true;
    502 }
    503 
    504 daeBool daeDoubleType::memoryToString(daeChar* src, std::ostringstream& dst) {
    505 	if ( *(daeDouble*)src != *(daeDouble*)src ) // NAN
    506 		dst << "NaN";
    507 	else if ( *(daeULong*)src == 0x7ff0000000000000LL ) // +INF
    508 		dst << "INF";
    509 	else if ( *(daeULong*)src == 0xfff0000000000000LL ) // -INF
    510 		dst << "-INF";
    511 	else {
    512 #ifdef _MSC_VER
    513 		// Microsoft's stringstream implementation has weird performance issues
    514 		static char buffer[64];
    515 		_snprintf(buffer, 64, _printFormat, *((daeDouble*)src));
    516 		dst << buffer;
    517 #else
    518 		dst << *(daeDouble*)src;
    519 #endif
    520 	}
    521 	return true;
    522 }
    523 
    524 daeBool
    525 daeDoubleType::stringToMemory(daeChar *src, daeChar* dstMemory)
    526 {
    527 	src = skipWhitespace(src);
    528 
    529 	if ( strncmp(src, "NaN", 3) == 0 ) {
    530 		daeErrorHandler::get()->handleWarning( "NaN encountered while setting an attribute or value\n" );
    531 		*(daeLong*)(dstMemory) = 0x7ff0000000000002LL;
    532 	}
    533 	else if ( strncmp(src, "INF", 3) == 0 ) {
    534 		daeErrorHandler::get()->handleWarning( "INF encountered while setting an attribute or value\n" );
    535 		*(daeLong*)(dstMemory) = 0x7ff0000000000000LL;
    536 	}
    537 	else if ( strncmp(src, "-INF", 4) == 0 ) {
    538 		daeErrorHandler::get()->handleWarning( "-INF encountered while setting an attribute or value\n" );
    539 		*(daeLong*)(dstMemory) = 0xfff0000000000000LL;
    540 	}
    541 	else
    542 	{
    543 		sscanf(src, _scanFormat, dstMemory);
    544 	}
    545 	return true;
    546 }
    547 
    548 daeBool daeRawRefType::memoryToString(daeChar* src, std::ostringstream& dst) {
    549 	dst << (void *)(*((daeRawRef*)src));
    550 	return true;
    551 }
    552 
    553 daeBool daeStringRefType::memoryToString(daeChar* src, std::ostringstream& dst) {
    554 	daeString s = *((daeStringRef *)src);
    555 	if (s)
    556 		dst << s;
    557 	return true;
    558 }
    559 
    560 daeBool daeResolverType::memoryToString(daeChar* src, std::ostringstream& dst) {
    561 	// Get the URI we are trying to write
    562 	daeURI *thisURI = ((daeURI *)src);
    563 	// Encode spaces with %20
    564 	dst << cdom::replace(thisURI->originalStr(), " ", "%20");
    565 	return true;
    566 }
    567 
    568 daeBool daeIDResolverType::memoryToString(daeChar* src, std::ostringstream& dst) {
    569 	dst << ((daeIDRef *)src)->getID();
    570 	return true;
    571 }
    572 
    573 daeBool
    574 daeResolverType::stringToMemory(daeChar* src, daeChar* dstMemory)
    575 {
    576 	((daeURI*)dstMemory)->set(cdom::replace(src, " ", "%20"));
    577 	return true;
    578 }
    579 
    580 daeBool
    581 daeIDResolverType::stringToMemory(daeChar* src, daeChar* dstMemory)
    582 {
    583 	src = skipWhitespace(src);
    584 	daeChar* id = extractToken(src);
    585 	((daeIDRef*)dstMemory)->setID(id);
    586 	if (id != src)
    587 		delete[] id;
    588 	return true;
    589 }
    590 
    591 daeBool
    592 daeStringRefType::stringToMemory(daeChar* srcChars, daeChar* dstMemory)
    593 {
    594 	*((daeStringRef*)dstMemory) = srcChars;
    595 	return true;
    596 }
    597 
    598 daeBool
    599 daeTokenType::stringToMemory(daeChar* src, daeChar* dst)
    600 {
    601 	src = skipWhitespace(src);
    602 	daeChar* srcTmp = extractToken(src);
    603 	*((daeStringRef*)dst) = srcTmp;
    604 	if (srcTmp != src)
    605 		delete[] srcTmp;
    606 	return true;
    607 }
    608 
    609 daeBool
    610 daeEnumType::stringToMemory(daeChar* src, daeChar* dst )
    611 {
    612 	src = skipWhitespace(src);
    613 	daeChar* srcTmp = extractToken(src);
    614 
    615 	size_t index(0);
    616 	bool result = _strings->find(srcTmp, index) != DAE_ERR_QUERY_NO_MATCH;
    617 	if (result) {
    618 		daeEnum val = _values->get( index );
    619 		*((daeEnum*)dst) = val;
    620 	}
    621 
    622 	if (srcTmp != src)
    623 		delete[] srcTmp;
    624 
    625 	return result;
    626 }
    627 
    628 daeBool daeEnumType::memoryToString(daeChar* src, std::ostringstream& dst) {
    629 	daeStringRef s = "unknown";
    630 	if (_strings != NULL) {
    631 		size_t index;
    632 		if (_values->find(*((daeEnum*)src), index) == DAE_OK)
    633 			s = _strings->get(index);
    634 	}
    635 	dst << (const char*)s;
    636 	return true;
    637 }
    638 
    639 daeBool
    640 daeBoolType::stringToMemory(daeChar* srcChars, daeChar* dstMemory)
    641 {
    642 	if (strncmp(srcChars,"true",4)==0 || strncmp(srcChars,"1",1)==0)
    643 		*((daeBool*)dstMemory) = true;
    644 	else
    645 		*((daeBool*)dstMemory) = false;
    646 	return true;
    647 }
    648 
    649 daeBool daeBoolType::memoryToString(daeChar* src, std::ostringstream& dst) {
    650 	if (*((daeBool*)src))
    651 		dst << "true";
    652 	else
    653 		dst << "false";
    654 	return true;
    655 }
    656 //!!!ACL added for 1.4 complex types and groups
    657 
    658 // Unimplemented
    659 daeBool daeElementRefType::memoryToString(daeChar* src, std::ostringstream& dst) {
    660 	(void)src;
    661 	(void)dst;
    662 	return false;
    663 }
    664 
    665 daeMemoryRef daeBoolType::create() {
    666 	return (daeMemoryRef)new daeBool;
    667 }
    668 
    669 daeMemoryRef daeIntType::create() {
    670 	return (daeMemoryRef)new daeInt;
    671 }
    672 
    673 daeMemoryRef daeLongType::create() {
    674 	return (daeMemoryRef)new daeLong;
    675 }
    676 
    677 daeMemoryRef daeUIntType::create() {
    678 	return (daeMemoryRef)new daeUInt;
    679 }
    680 
    681 daeMemoryRef daeULongType::create() {
    682 	return (daeMemoryRef)new daeULong;
    683 }
    684 
    685 daeMemoryRef daeShortType::create() {
    686 	return (daeMemoryRef)new daeShort;
    687 }
    688 
    689 daeMemoryRef daeFloatType::create() {
    690 	return (daeMemoryRef)new daeFloat;
    691 }
    692 
    693 daeMemoryRef daeDoubleType::create() {
    694 	return (daeMemoryRef)new daeDouble;
    695 }
    696 
    697 daeMemoryRef daeStringRefType::create() {
    698 	return (daeMemoryRef)new daeStringRef;
    699 }
    700 
    701 daeMemoryRef daeTokenType::create() {
    702 	return (daeMemoryRef)new daeStringRef;
    703 }
    704 
    705 daeMemoryRef daeElementRefType::create() {
    706 	return (daeMemoryRef)new daeElementRef;
    707 }
    708 
    709 daeMemoryRef daeEnumType::create() {
    710 	return (daeMemoryRef)new daeEnum;
    711 }
    712 
    713 daeMemoryRef daeRawRefType::create() {
    714 	return (daeMemoryRef)new daeRawRef;
    715 }
    716 
    717 daeMemoryRef daeResolverType::create() {
    718 	return (daeMemoryRef)new daeURI(*_dae);
    719 }
    720 
    721 daeMemoryRef daeIDResolverType::create() {
    722 	return (daeMemoryRef)new daeIDRef;
    723 }
    724 
    725 
    726 void daeBoolType::destroy(daeMemoryRef obj) {
    727 	delete (daeBool*)obj;
    728 }
    729 
    730 void daeIntType::destroy(daeMemoryRef obj) {
    731 	delete (daeInt*)obj;
    732 }
    733 
    734 void daeLongType::destroy(daeMemoryRef obj) {
    735 	delete (daeLong*)obj;
    736 }
    737 
    738 void daeUIntType::destroy(daeMemoryRef obj) {
    739 	delete (daeUInt*)obj;
    740 }
    741 
    742 void daeULongType::destroy(daeMemoryRef obj) {
    743 	delete (daeULong*)obj;
    744 }
    745 
    746 void daeShortType::destroy(daeMemoryRef obj) {
    747 	delete (daeShort*)obj;
    748 }
    749 
    750 void daeFloatType::destroy(daeMemoryRef obj) {
    751 	delete (daeFloat*)obj;
    752 }
    753 
    754 void daeDoubleType::destroy(daeMemoryRef obj) {
    755 	delete (daeDouble*)obj;
    756 }
    757 
    758 void daeStringRefType::destroy(daeMemoryRef obj) {
    759 	delete (daeStringRef*)obj;
    760 }
    761 
    762 void daeTokenType::destroy(daeMemoryRef obj) {
    763 	delete (daeStringRef*)obj;
    764 }
    765 
    766 void daeElementRefType::destroy(daeMemoryRef obj) {
    767 	delete (daeElementRef*)obj;
    768 }
    769 
    770 void daeEnumType::destroy(daeMemoryRef obj) {
    771 	delete (daeEnum*)obj;
    772 }
    773 
    774 void daeRawRefType::destroy(daeMemoryRef obj) {
    775 	delete (daeRawRef*)obj;
    776 }
    777 
    778 void daeResolverType::destroy(daeMemoryRef obj) {
    779 	delete (daeURI*)obj;
    780 }
    781 
    782 void daeIDResolverType::destroy(daeMemoryRef obj) {
    783 	delete (daeIDRef*)obj;
    784 }
    785 
    786 
    787 daeInt daeStringRefType::compare(daeChar* value1, daeChar* value2) {
    788 	daeString s1 = *((daeStringRef *)value1);
    789 	daeString s2 = *((daeStringRef *)value2);
    790 	// For string types, the empty string and null are considered equivalent
    791 	if (!s1)
    792 		s1 = "";
    793 	if (!s2)
    794 		s2 = "";
    795 	return strcmp(s1, s2);
    796 }
    797 
    798 daeInt daeResolverType::compare(daeChar* value1, daeChar* value2) {
    799 	return strcmp(((daeURI*)value1)->str().c_str(), ((daeURI*)value2)->str().c_str());
    800 }
    801 
    802 daeInt daeIDResolverType::compare(daeChar* value1, daeChar* value2) {
    803 	return (daeIDRef&)*value1 == (daeIDRef&)*value2;
    804 }
    805 
    806 
    807 daeArray* daeBoolType::createArray() {
    808 	return new daeTArray<daeBool>;
    809 }
    810 
    811 daeArray* daeIntType::createArray() {
    812 	return new daeTArray<daeInt>;
    813 }
    814 
    815 daeArray* daeLongType::createArray() {
    816 	return new daeTArray<daeLong>;
    817 }
    818 
    819 daeArray* daeUIntType::createArray() {
    820 	return new daeTArray<daeUInt>;
    821 }
    822 
    823 daeArray* daeULongType::createArray() {
    824 	return new daeTArray<daeULong>;
    825 }
    826 
    827 daeArray* daeShortType::createArray() {
    828 	return new daeTArray<daeShort>;
    829 }
    830 
    831 daeArray* daeFloatType::createArray() {
    832 	return new daeTArray<daeFloat>;
    833 }
    834 
    835 daeArray* daeDoubleType::createArray() {
    836 	return new daeTArray<daeDouble>;
    837 }
    838 
    839 daeArray* daeStringRefType::createArray() {
    840 	return new daeTArray<daeStringRef>;
    841 }
    842 
    843 daeArray* daeTokenType::createArray() {
    844 	return new daeTArray<daeStringRef>;
    845 }
    846 
    847 daeArray* daeElementRefType::createArray() {
    848 	return new daeTArray<daeElementRef>;
    849 }
    850 
    851 daeArray* daeEnumType::createArray() {
    852 	return new daeTArray<daeEnum>;
    853 }
    854 
    855 daeArray* daeRawRefType::createArray() {
    856 	return new daeTArray<daeRawRef>;
    857 }
    858 
    859 daeArray* daeResolverType::createArray() {
    860 	// !!!steveT
    861 	// The daeURI object no longer has a constructor that takes no arguments, so
    862 	// it's not compatible with daeTArray. Therefore this method currently can't be used,
    863 	// and asserts if you try to use it. The DOM doesn't ever call this code now,
    864 	// so the situation is sort of alright, but we might need to fix this in the future.
    865 	assert(false);
    866 	return NULL;
    867 }
    868 
    869 daeArray* daeIDResolverType::createArray() {
    870 	return new daeTArray<daeIDRef>;
    871 }
    872 
    873 
    874 void daeBoolType::copy(daeChar* src, daeChar* dst) {
    875 	(daeBool&)*dst = (daeBool&)*src;
    876 }
    877 
    878 void daeIntType::copy(daeChar* src, daeChar* dst) {
    879 	(daeInt&)*dst = (daeInt&)*src;
    880 }
    881 
    882 void daeLongType::copy(daeChar* src, daeChar* dst) {
    883 	(daeLong&)*dst = (daeLong&)*src;
    884 }
    885 
    886 void daeUIntType::copy(daeChar* src, daeChar* dst) {
    887 	(daeUInt&)*dst = (daeUInt&)*src;
    888 }
    889 
    890 void daeULongType::copy(daeChar* src, daeChar* dst) {
    891 	(daeULong&)*dst = (daeULong&)*src;
    892 }
    893 
    894 void daeShortType::copy(daeChar* src, daeChar* dst) {
    895 	(daeShort&)*dst = (daeShort&)*src;
    896 }
    897 
    898 void daeFloatType::copy(daeChar* src, daeChar* dst) {
    899 	(daeFloat&)*dst = (daeFloat&)*src;
    900 }
    901 
    902 void daeDoubleType::copy(daeChar* src, daeChar* dst) {
    903 	(daeDouble&)*dst = (daeDouble&)*src;
    904 }
    905 
    906 void daeStringRefType::copy(daeChar* src, daeChar* dst) {
    907 	(daeStringRef&)*dst = (daeStringRef&)*src;
    908 }
    909 
    910 void daeTokenType::copy(daeChar* src, daeChar* dst) {
    911 	(daeStringRef&)*dst = (daeStringRef&)*src;
    912 }
    913 
    914 void daeElementRefType::copy(daeChar* src, daeChar* dst) {
    915 	(daeElementRef&)*dst = (daeElementRef&)*src;
    916 }
    917 
    918 void daeEnumType::copy(daeChar* src, daeChar* dst) {
    919 	(daeEnum&)*dst = (daeEnum&)*src;
    920 }
    921 
    922 void daeRawRefType::copy(daeChar* src, daeChar* dst) {
    923 	(daeRawRef&)*dst = (daeRawRef&)*src;
    924 }
    925 
    926 void daeResolverType::copy(daeChar* src, daeChar* dst) {
    927 	(daeURI&)*dst = (daeURI&)*src;
    928 }
    929 
    930 void daeIDResolverType::copy(daeChar* src, daeChar* dst) {
    931 	(daeIDRef&)*dst = (daeIDRef&)*src;
    932 }
    933 
    934 void daeResolverType::setDocument(daeChar* value, daeDocument* doc) {
    935 	daeURI* uri = (daeURI*)value;
    936 	uri->setContainer(uri->getContainer());
    937 }
    938 
    939 void daeResolverType::setDocument(daeArray& array, daeDocument* doc) {
    940 	// !!!steveT
    941 	// The daeURI object no longer has a constructor that takes no arguments, so
    942 	// it's not compatible with daeTArray. Therefore this method currently can't be used,
    943 	// and asserts if you try to use it. The DOM doesn't ever call this code now,
    944 	// so the situation is sort of alright, but we might need to fix this in the future.
    945 	assert(false);
    946 }
    947