00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040 #ifndef _OSG_SYSFIELDDATATYPE_H_
00041 #define _OSG_SYSFIELDDATATYPE_H_
00042
00043 #include <OSGFieldDataType.h>
00044 #include <string>
00045 #include <OSGLog.h>
00046
00047 OSG_BEGIN_NAMESPACE
00048
00049 #if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
00050
00051 #ifdef OSG_DOC_FILES_IN_MODULE
00052
00056 #endif
00057
00058
00061 #if !defined(OSG_DOC_DEV_TRAITS)
00062
00063 #endif
00064
00065 template <>
00066 #ifndef OSG_WIN32_CL
00067 struct OSG_BASE_DLLMAPPING FieldDataTraits2<bool> :
00068 #else
00069 struct FieldDataTraits2<bool> :
00070 #endif
00071 public FieldTraitsIntegralRecurseMapper<bool>
00072 {
00073 static DataType _type;
00074
00075 typedef FieldDataTraits2<bool> Self;
00076
00077
00078 enum { StringConvertable = Self::ToStringConvertable |
00079 Self::FromStringConvertable };
00080
00081 static DataType &getType (void) { return _type; }
00082
00083 static const Char8 *getSName (void) { return "SFBool"; }
00084 static const Char8 *getMName (void) { return "MFBool"; }
00085
00086 static bool getDefault (void) { return false; }
00087
00088 static bool getFromString( bool &outVal,
00089 const Char8 *&inVal)
00090 {
00091 if(inVal == NULL)
00092 return false;
00093
00094 if(inVal[0] == 'T' || inVal[0] == 't')
00095 {
00096 if(inVal[1] != 'R' && inVal[1] != 'r')
00097 {
00098 return false;
00099 }
00100
00101 if(inVal[2] != 'U' && inVal[2] != 'u')
00102 {
00103 return false;
00104 }
00105
00106 if(inVal[3] != 'E' && inVal[3] != 'e')
00107 {
00108 return false;
00109 }
00110
00111 outVal = true;
00112 }
00113 else if(inVal[0] == 'F' || inVal[0] == 'f')
00114 {
00115 if(inVal[1] != 'A' && inVal[1] != 'a')
00116 {
00117 return false;
00118 }
00119
00120 if(inVal[2] != 'L' && inVal[2] != 'l')
00121 {
00122 return false;
00123 }
00124
00125 if(inVal[3] != 'S' && inVal[3] != 's')
00126 {
00127 return false;
00128 }
00129
00130 if(inVal[4] != 'E' && inVal[4] != 'e')
00131 {
00132 return false;
00133 }
00134
00135 outVal = false;
00136 }
00137 else
00138 {
00139 return false;
00140 }
00141
00142 return outVal;
00143 }
00144
00145 static void putToString (const bool &inVal,
00146 std::string &outStr)
00147 {
00148 if( inVal == true )
00149 {
00150 outStr.assign("TRUE");
00151 }
00152 else
00153 {
00154 outStr.assign("FALSE");
00155 }
00156 }
00157
00158 #ifndef OSG_WIN32_CL
00159 static UInt32 getBinSize (const bool & )
00160 {
00161 return sizeof(UInt8);
00162 }
00163
00164 static void copyToBin ( BinaryDataHandler &pMem,
00165 const bool &oObject)
00166 {
00167 UInt8 value=oObject;
00168 pMem.putValue(value);
00169 }
00170
00171 static void copyFromBin( BinaryDataHandler &pMem,
00172 bool &oObject)
00173 {
00174 UInt8 value;
00175 pMem.getValue(value);
00176 oObject=value;
00177 }
00178 #endif
00179 };
00180
00181 #if !defined(OSG_DOC_DEV_TRAITS)
00182
00184 #endif
00185
00188 #if !defined(OSG_DOC_DEV_TRAITS)
00189
00190 #endif
00191
00192 template <>
00193 struct OSG_BASE_DLLMAPPING FieldDataTraits<Int8> :
00194 public FieldTraitsIntegralRecurseMapper<Int8>
00195 {
00196 static DataType _type;
00197 typedef FieldDataTraits<Int8> Self;
00198
00199 enum { StringConvertable = Self::ToStringConvertable |
00200 Self::FromStringConvertable };
00201
00202 static DataType &getType (void) { return _type; }
00203
00204 static const Char8 *getSName (void) { return "SFInt8"; }
00205 static const Char8 *getMName (void) { return "MFInt8"; }
00206
00207 static Int8 getDefault (void) { return 0; }
00208
00209 static bool getFromString( Int8 &outVal,
00210 const Char8 *&inVal)
00211 {
00212 outVal = TypeTraits<Int8>::getFromString(inVal);
00213
00214 return true;
00215 }
00216
00217 static void putToString (const Int8 &inVal,
00218 std::string &outStr)
00219 {
00220 outStr.assign(TypeTraits<Int8>::putToString(inVal));
00221 }
00222 };
00223
00224 #if !defined(OSG_DOC_DEV_TRAITS)
00225
00227 #endif
00228
00231 #if !defined(OSG_DOC_DEV_TRAITS)
00232
00233 #endif
00234
00235 template <>
00236 struct OSG_BASE_DLLMAPPING FieldDataTraits<UInt8> :
00237 public FieldTraitsIntegralRecurseMapper<UInt8>
00238 {
00239 static DataType _type;
00240 typedef FieldDataTraits<UInt8> Self;
00241
00242 enum { StringConvertable = Self::ToStringConvertable |
00243 Self::FromStringConvertable };
00244
00245 static DataType &getType (void) { return _type; }
00246
00247 static const Char8 *getSName (void) { return "SFUInt8"; }
00248 static const Char8 *getMName (void) { return "MFUInt8"; }
00249
00250 static UInt8 getDefault (void) { return 0; }
00251
00252 static bool getFromString( UInt8 &outVal,
00253 const Char8 *&inVal)
00254 {
00255 outVal = TypeTraits<UInt8>::getFromString(inVal);
00256
00257 return true;
00258 }
00259
00260 static void putToString (const UInt8 &inVal,
00261 std::string &outStr)
00262 {
00263 outStr.assign(TypeTraits<UInt8>::putToString(inVal));
00264 }
00265 };
00266
00267 #if !defined(OSG_DOC_DEV_TRAITS)
00268
00270 #endif
00271
00274 #if !defined(OSG_DOC_DEV_TRAITS)
00275
00276 #endif
00277
00278 template <>
00279 struct OSG_BASE_DLLMAPPING FieldDataTraits<Int16> :
00280 public FieldTraitsIntegralRecurseMapper<Int16>
00281 {
00282 static DataType _type;
00283 typedef FieldDataTraits<Int16> Self;
00284
00285 enum { StringConvertable = Self::ToStringConvertable |
00286 Self::FromStringConvertable };
00287
00288 static DataType &getType (void) { return _type; }
00289
00290 static const Char8 *getSName (void) { return "SFInt16"; }
00291 static const Char8 *getMName (void) { return "MFInt16"; }
00292
00293 static Int16 getDefault (void) { return 0; }
00294
00295 static bool getFromString( Int16 &outVal,
00296 const Char8 *&inVal)
00297 {
00298 outVal = TypeTraits<Int16>::getFromString(inVal);
00299
00300 return true;
00301 }
00302
00303 static void putToString (const Int16 &inVal,
00304 std::string &outStr)
00305 {
00306 outStr.assign(TypeTraits<Int16>::putToString(inVal));
00307 }
00308 };
00309
00310 #if !defined(OSG_DOC_DEV_TRAITS)
00311
00313 #endif
00314
00317 #if !defined(OSG_DOC_DEV_TRAITS)
00318
00319 #endif
00320
00321 template <>
00322 struct OSG_BASE_DLLMAPPING FieldDataTraits<UInt16> :
00323 public FieldTraitsIntegralRecurseMapper<UInt16>
00324 {
00325 static DataType _type;
00326 typedef FieldDataTraits<UInt16> Self;
00327
00328 enum { StringConvertable = Self::ToStringConvertable |
00329 Self::FromStringConvertable };
00330
00331 static DataType &getType (void) { return _type; }
00332
00333 static const Char8 *getSName (void) { return "SFUInt16"; }
00334 static const Char8 *getMName (void) { return "MFUInt16"; }
00335
00336 static UInt16 getDefault (void) { return 0; }
00337
00338 static bool getFromString( UInt16 &outVal,
00339 const Char8 *&inVal)
00340 {
00341 outVal = TypeTraits<UInt16>::getFromString(inVal);
00342
00343 return true;
00344 }
00345
00346 static void putToString (const UInt16 &inVal,
00347 std::string &outStr)
00348 {
00349 outStr.assign(TypeTraits<UInt16>::putToString(inVal));
00350 }
00351 };
00352
00353 #if !defined(OSG_DOC_DEV_TRAITS)
00354
00356 #endif
00357
00360 #if !defined(OSG_DOC_DEV_TRAITS)
00361
00362 #endif
00363
00364 template <>
00365 struct OSG_BASE_DLLMAPPING FieldDataTraits<Int32> :
00366 public FieldTraitsIntegralRecurseMapper<Int32>
00367 {
00368 static DataType _type;
00369 typedef FieldDataTraits<Int32> Self;
00370
00371 enum { StringConvertable = Self::ToStringConvertable |
00372 Self::FromStringConvertable };
00373
00374 static DataType &getType (void) { return _type; }
00375
00376 static const Char8 *getSName (void) { return "SFInt32"; }
00377 static const Char8 *getMName (void) { return "MFInt32"; }
00378
00379 static Int32 getDefault (void) { return 0; }
00380
00381 static bool getFromString( Int32 &outVal,
00382 const Char8 *&inVal)
00383 {
00384 outVal = TypeTraits<Int32>::getFromString(inVal);
00385
00386 return true;
00387 }
00388
00389 static void putToString (const Int32 &inVal,
00390 std::string &outStr)
00391 {
00392 outStr.assign(TypeTraits<Int32>::putToString(inVal));
00393 }
00394 };
00395
00396 #if !defined(OSG_DOC_DEV_TRAITS)
00397
00399 #endif
00400
00403 #if !defined(OSG_DOC_DEV_TRAITS)
00404
00405 #endif
00406
00407 template <>
00408 struct OSG_BASE_DLLMAPPING FieldDataTraits<UInt32> :
00409 public FieldTraitsIntegralRecurseMapper<UInt32>
00410 {
00411 static DataType _type;
00412 typedef FieldDataTraits<UInt32> Self;
00413
00414 enum { StringConvertable = Self::ToStringConvertable |
00415 Self::FromStringConvertable };
00416
00417 static DataType &getType (void) { return _type; }
00418
00419 static const Char8 *getSName (void) { return "SFUInt32"; }
00420 static const Char8 *getMName (void) { return "MFUInt32"; }
00421
00422 static UInt32 getDefault (void) { return 0; }
00423
00424 static bool getFromString( UInt32 &outVal,
00425 const Char8 *&inVal)
00426 {
00427 outVal = TypeTraits<UInt32>::getFromString(inVal);
00428
00429 return false;
00430 }
00431
00432 static void putToString (const UInt32 &inVal,
00433 std::string &outStr)
00434 {
00435 outStr.assign(TypeTraits<UInt32>::putToString(inVal));
00436 }
00437 };
00438
00439 #if !defined(OSG_DOC_DEV_TRAITS)
00440
00442 #endif
00443
00446 #if !defined(OSG_DOC_DEV_TRAITS)
00447
00448 #endif
00449
00450 template <>
00451 struct OSG_BASE_DLLMAPPING FieldDataTraits<Int64> :
00452 public FieldTraitsIntegralRecurseMapper<Int64>
00453 {
00454 static DataType _type;
00455 typedef FieldDataTraits<Int64> Self;
00456
00457 enum { StringConvertable = Self::ToStringConvertable |
00458 Self::FromStringConvertable };
00459
00460 static DataType &getType (void) { return _type; }
00461
00462 static const Char8 *getSName (void) { return "SFInt64"; }
00463 static const Char8 *getMName (void) { return "MFInt64"; }
00464
00465 static Int64 getDefault (void) { return 0; }
00466
00467 static bool getFromString( Int64 &outVal,
00468 const Char8 *&inVal)
00469 {
00470 outVal = TypeTraits<Int64>::getFromString(inVal);
00471
00472 return false;
00473 }
00474
00475 static void putToString (const Int64 &inVal,
00476 std::string &outStr)
00477 {
00478 outStr.assign(TypeTraits<Int64>::putToString(inVal));
00479 }
00480 };
00481
00482 #if !defined(OSG_DOC_DEV_TRAITS)
00483
00485 #endif
00486
00489 #if !defined(OSG_DOC_DEV_TRAITS)
00490
00491 #endif
00492
00493 template <>
00494 struct OSG_BASE_DLLMAPPING FieldDataTraits<UInt64> :
00495 public FieldTraitsIntegralRecurseMapper<UInt64>
00496 {
00497 static DataType _type;
00498 typedef FieldDataTraits<UInt64> Self;
00499
00500 enum { StringConvertable = Self::ToStringConvertable |
00501 Self::FromStringConvertable };
00502
00503 static DataType &getType (void) { return _type; }
00504
00505 static const Char8 *getSName (void) { return "SFUInt64"; }
00506 static const Char8 *getMName (void) { return "MFUInt64"; }
00507
00508 static UInt64 getDefault (void) { return 0; }
00509
00510 static bool getFromString( UInt64 &outVal,
00511 const Char8 *&inVal)
00512 {
00513 outVal = TypeTraits<UInt64>::getFromString(inVal);
00514
00515 return false;
00516 }
00517
00518 static void putToString (const UInt64 &inVal,
00519 std::string &outStr)
00520 {
00521 outStr.assign(TypeTraits<UInt64>::putToString(inVal));
00522 }
00523 };
00524
00525 #if !defined(OSG_DOC_DEV_TRAITS)
00526
00528 #endif
00529
00530
00533 #if !defined(OSG_DOC_DEV_TRAITS)
00534
00535 #endif
00536
00537 template <>
00538 struct OSG_BASE_DLLMAPPING FieldDataTraits<Real16> :
00539 public FieldTraitsIntegralRecurseMapper<Real16>
00540 {
00541 static DataType _type;
00542 typedef FieldDataTraits<Real16> Self;
00543
00544 enum { StringConvertable = Self::ToStringConvertable |
00545 Self::FromStringConvertable };
00546
00547 static DataType &getType (void) { return _type; }
00548
00549 static const Char8 *getSName (void) { return "SFReal16"; }
00550 static const Char8 *getMName (void) { return "MFReal16"; }
00551
00552 static Real16 getDefault (void) { return 0.f; }
00553
00554 static bool getFromString( Real16 &outVal,
00555 const Char8 *&inVal)
00556 {
00557 outVal = TypeTraits<Real16>::getFromString(inVal);
00558
00559 return true;
00560 }
00561
00562 static void putToString (const Real16 &inVal,
00563 std::string &outStr)
00564 {
00565 outStr.assign(TypeTraits<Real16>::putToString(inVal));
00566 }
00567 };
00568
00569 #if !defined(OSG_DOC_DEV_TRAITS)
00570
00572 #endif
00573
00576 #if !defined(OSG_DOC_DEV_TRAITS)
00577
00578 #endif
00579
00580 template <>
00581 struct OSG_BASE_DLLMAPPING FieldDataTraits<Real32> :
00582 public FieldTraitsIntegralRecurseMapper<Real32>
00583 {
00584 static DataType _type;
00585 typedef FieldDataTraits<Real32> Self;
00586
00587 enum { StringConvertable = Self::ToStringConvertable |
00588 Self::FromStringConvertable };
00589
00590 static DataType &getType (void) { return _type; }
00591
00592 static const Char8 *getSName (void) { return "SFReal32"; }
00593 static const Char8 *getMName (void) { return "MFReal32"; }
00594
00595 static Real32 getDefault (void) { return 0.f; }
00596
00597 static bool getFromString( Real32 &outVal,
00598 const Char8 *&inVal)
00599 {
00600 outVal = TypeTraits<Real32>::getFromString(inVal);
00601
00602 return true;
00603 }
00604
00605 static void putToString (const Real32 &inVal,
00606 std::string &outStr)
00607 {
00608 outStr.assign(TypeTraits<Real32>::putToString(inVal));
00609 }
00610 };
00611
00612 #if !defined(OSG_DOC_DEV_TRAITS)
00613
00615 #endif
00616
00619 #if !defined(OSG_DOC_DEV_TRAITS)
00620
00621 #endif
00622
00623 template <>
00624 struct OSG_BASE_DLLMAPPING FieldDataTraits<Real64> :
00625 public FieldTraitsIntegralRecurseMapper<Real64>
00626 {
00627 static DataType _type;
00628 typedef FieldDataTraits<Real64> Self;
00629
00630 enum { StringConvertable = Self::ToStringConvertable |
00631 Self::FromStringConvertable };
00632
00633 static DataType &getType (void) { return _type; }
00634
00635 static const Char8 *getSName (void) { return "SFReal64"; }
00636 static const Char8 *getMName (void) { return "MFReal64"; }
00637
00638 static Real64 getDefault (void) { return 0.; }
00639
00640 static bool getFromString( Real64 &outVal,
00641 const Char8 *&inVal)
00642 {
00643 outVal = TypeTraits<Real64>::getFromString(inVal);
00644
00645 return true;
00646 }
00647
00648 static void putToString (const Real64 &inVal,
00649 std::string &outStr)
00650 {
00651 outStr.assign(TypeTraits<Real64>::putToString(inVal));
00652 }
00653 };
00654
00655 #if !defined(OSG_DOC_DEV_TRAITS)
00656
00658 #endif
00659
00660
00663 #if !defined(OSG_DOC_DEV_TRAITS)
00664
00665 #endif
00666
00667 template <>
00668 struct OSG_BASE_DLLMAPPING FieldDataTraits<void *> :
00669 public FieldTraitsRecurseBase<void *>
00670 {
00671 static DataType _type;
00672 typedef FieldDataTraits<void *> Self;
00673 typedef void * ArgumentType;
00674 typedef void * FieldTypeT;
00675
00676 enum { StringConvertable = 0x00 };
00677
00678 static DataType &getType (void) { return _type; }
00679
00680 static const Char8 *getSName (void) { return "SFVoidP"; }
00681 static const Char8 *getMName (void) { return "MFVoidP"; }
00682
00683 static void *getDefault (void) { return NULL; }
00684
00685 static bool getFromString( FieldTypeT &voidP,
00686 const Char8 *inStr)
00687 {
00688 if(inStr[0] == '0' && tolower(inStr[1]) == 'x')
00689 {
00690 if(sscanf(inStr + 2, "%p", &voidP) != 1)
00691 {
00692 voidP = NULL;
00693 FWARNING(("FieldDataTraits<void *>::getFromString: '%s' "
00694 "not understood!\n", inStr));
00695 return false;
00696 }
00697 }
00698 else
00699 {
00700 if(sscanf(inStr, "%lu",
00701 reinterpret_cast<unsigned long *>(&voidP)) != 1)
00702 {
00703 voidP = NULL;
00704 FWARNING(("FieldDataTraits<void *>::getFromString: '%s' "
00705 "not understood!\n", inStr));
00706 return false;
00707 }
00708 }
00709
00710 return true;
00711 }
00712
00713 static void putToString (const FieldTypeT &voidP,
00714 std::string &outStr)
00715 {
00716 char buf[32];
00717 sprintf(buf, "%p", voidP);
00718 outStr = buf;
00719 }
00720 };
00721
00722
00723 #endif // !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
00724
00725 OSG_END_NAMESPACE
00726
00727 #define OSGSYSFIELDDATATYPE_HEADER_CVSID "@(#)$Id: $"
00728
00729 #endif
00730
00731
00732
00733
00734
