Source/Base/Base/OSGBaseTypeTraits.h

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2000-2002,2002 by the OpenSG Forum                *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #ifndef _OSGBASETYPETRAITS_H_
  40 #define _OSGBASETYPETRAITS_H_
  41 #ifdef __sgi
  42 #pragma once
  43 #endif
  44
  45 #ifndef _OSGBASETYPES_H_
  46 #error not for direct use, please include OSGBaseTypes.h instead
  47 #endif
  48
  49 #include "OSGGL.h"
  50
  51 #include "OSGIOStream.h"
  52
  53 #include <limits>
  54 #include <boost/lexical_cast.hpp>
  55
  56 // The undef's are needed otherwise the numeric_limits won't work (GV)
  57
  58 #if defined(max)
  59 #undef max
  60 #endif
  61
  62 #if defined(min)
  63 #undef min
  64 #endif
  65
  66 OSG_BEGIN_NAMESPACE
  67
  68 template <class LookupTypeT>
  69 struct TypeTraits;
  70
  71 /*! \ingroup GrpBaseBaseBaseTypeTraits
  72     \ingroup GrpLibOSGBase
  73  */
  74
  75 struct TypeTraitsBase
  76 {
  77 #ifdef GV_CHECK_CHECK
  78     static const  bool               IsPOD    = true;
  79     static const  MathTypeProperties MathProp = BoolValue;
  80
  81     static const  bool               BitsSet     = true ;
  82     static const  bool               BitsClear   = false;
  83
  84     static        bool              getZeroElement(void)
  85     {
  86         return false;
  87     }
  88
  89     static        bool              getOneElement (void)
  90     {
  91         return true;
  92     }
  93
  94     static        bool              getMax        (void)
  95     {
  96         return true;
  97     }
  98
  99     static        bool              getMin        (void)
 100     {
 101         return false;
 102     }
 103 #endif
 104 };
 105
 106 /*! \ingroup GrpBaseBaseBaseTypeTraits
 107     \ingroup GrpLibOSGBase
 108  */
 109
 110 template <class LookupTypeT>
 111 struct TypeTraitsTemplateBase : public TypeTraitsBase
 112 {
 113     static void putToStream(const LookupTypeT &val,
 114                                   OutStream   &str)
 115     {
 116         str << boost::lexical_cast<std::string>(val);
 117     }
 118
 119 #ifdef OSG_1_COMPAT
 120     static LookupTypeT getFromString(const Char8 *szString)
 121     {
 122         typedef TypeTraits<LookupTypeT> SelfTraits;
 123
 124         return SelfTraits::getFromCString(szString);
 125     }
 126 #endif
 127 };
 128
 129
 130 /*! \ingroup GrpBaseBaseBaseTypeTraits
 131     \ingroup GrpLibOSGBase
 132  */
 133
 134 template <class LookupTypeT>
 135 struct TypeTraits : public TypeTraitsTemplateBase<LookupTypeT>
 136 {
 137     static const bool IsPOD = true;
 138
 139 #ifdef OSG_MICROSOFT_DOTNET_COMPILER_HACKS
 140     typedef LookupTypeT RealReturnType;
 141 #endif
 142 };
 143
 144 #if defined(__hpux)
 145 template <class LookupTypeT>
 146 const bool TypeTraits<LookupTypeT>::IsPOD;
 147 #endif
 148
 149
 150 /*! \ingroup GrpBaseBaseBaseTypeTraits
 151     \ingroup GrpLibOSGBase
 152  */
 153
 154 template <>
 155 struct TypeTraits<bool> : public TypeTraitsTemplateBase<bool>
 156 {
 157     static const  bool               IsPOD     = true;
 158     static const  MathTypeProperties MathProp  = BoolValue;
 159
 160     static const  bool               BitsSet   = true ;
 161     static const  bool               BitsClear = false;
 162
 163
 164     static        bool               getZeroElement(void)
 165     {
 166         return false;
 167     }
 168
 169     static        bool               getOneElement (void)
 170     {
 171         return true;
 172     }
 173
 174     static        bool               getMax        (void)
 175     {
 176         return true;
 177     }
 178
 179     static        bool               getMin        (void)
 180     {
 181         return false;
 182     }
 183
 184     static bool getFromCString(const Char8 * pData,
 185                                      Char8 *&pDataEnd)
 186     {
 187         if(pData == NULL)
 188             return false;
 189
 190         if(pData[0] == 'T' || pData[0] == 't')
 191         {
 192             ++pDataEnd;
 193
 194             if(pData[1] != 'R' && pData[1] != 'r')
 195             {
 196                 return false;
 197             }
 198
 199             ++pDataEnd;
 200
 201             if(pData[2] != 'U' && pData[2] != 'u')
 202             {
 203                 return false;
 204             }
 205
 206             ++pDataEnd;
 207
 208             if(pData[3] != 'E' && pData[3] != 'e')
 209             {
 210                 return false;
 211             }
 212
 213             ++pDataEnd;
 214
 215             return true;
 216         }
 217
 218         return false;
 219     }
 220
 221     static bool getFromCString(const Char8 *pData)
 222     {
 223         Char8 *pDataEnd;
 224
 225         return getFromCString(pData, pDataEnd);
 226     }
 227
 228     static void putToString  (const bool        &val,
 229                                     std::string &out)
 230     {
 231         if(val == true)
 232         {
 233             out.append("TRUE");
 234         }
 235         else
 236         {
 237             out.append("FALSE");
 238         }
 239     }
 240
 241     static void putToStream(const bool      &val,
 242                                   OutStream &str)
 243     {
 244         if(val == true)
 245         {
 246             str << "TRUE";
 247         }
 248         else
 249         {
 250             str << "FALSE";
 251         }
 252     }
 253
 254 };
 255
 256
 257 /*! \ingroup GrpBaseBaseBaseTypeTraits
 258     \ingroup GrpLibOSGBase
 259  */
 260
 261 template <>
 262 struct TypeTraits<UInt8> : public TypeTraitsTemplateBase<UInt8>
 263 {
 264     typedef       Real32             RealReturnType;
 265
 266
 267     static const  bool               IsPOD     = true;
 268     static const  MathTypeProperties MathProp  = IntValue;
 269
 270     static const  UInt8              BitsSet   = 0xFF;
 271     static const  UInt8              BitsClear = 0x00;
 272
 273
 274     static        UInt8              getDefaultEps(void)
 275     {
 276         return 0;
 277     }
 278
 279     static        UInt8              getZeroElement(void)
 280     {
 281         return 0;
 282     }
 283
 284     static        UInt8              getOneElement (void)
 285     {
 286         return 1;
 287     }
 288
 289     static        UInt8              getMax        (void)
 290     {
 291         return std::numeric_limits<UInt8>::max();
 292     }
 293
 294     static        UInt8              getMin        (void)
 295     {
 296         return std::numeric_limits<UInt8>::min();
 297     }
 298
 299
 300     static Real32      getFraction  (UInt8 val)
 301     {
 302         return (Real32(val) / Real32(getMax()));
 303     };
 304
 305     static UInt8       getPortion   (Real32 val)
 306     {
 307 #ifdef OSG_WIN32_ICL
 308 #pragma warning (disable : 810)
 309 #endif
 310         return UInt8((val * Real32(getMax())));
 311 #ifdef OSG_WIN32_ICL
 312 #pragma warning (default : 810)
 313 #endif
 314     };
 315
 316
 317     static UInt8       getFromCString(const Char8 * pData,
 318                                             Char8 *&pDataEnd)
 319     {
 320         if(pData != NULL)
 321         {
 322             return UInt8(strtoul(pData, &pDataEnd, 0));
 323         }
 324         else
 325         {
 326             return getZeroElement();
 327         }
 328     }
 329
 330     static UInt8       getFromCString(const Char8 *pData)
 331     {
 332         Char8 *pDataEnd;
 333
 334         return getFromCString(pData, pDataEnd);
 335     }
 336
 337     static void putToString  (const UInt8        val,
 338                                     std::string &out)
 339     {
 340         Char8 buffer[10];
 341
 342         sprintf(buffer, "%u", val);
 343
 344         out.append(buffer);
 345     }
 346
 347     static void putToStream(const UInt8     &val,
 348                                   OutStream &str)
 349     {
 350         str << UInt32(val);
 351     }
 352 };
 353
 354
 355 /*! \ingroup GrpBaseBaseBaseTypeTraits
 356     \ingroup GrpLibOSGBase
 357  */
 358
 359 template <>
 360 struct TypeTraits<Int8> : public TypeTraitsTemplateBase<Int8>
 361 {
 362     typedef       Real32             RealReturnType;
 363
 364
 365     static const  bool               IsPOD       = true;
 366     static const  MathTypeProperties MathProp    = IntValue;
 367
 368     static const  Int8               BitsSet     =  -1; //0xFF;
 369     static const  Int8               BitsClear   =  0x00;
 370
 371
 372     static        Int8               getDefaultEps(void)
 373     {
 374         return 0;
 375     }
 376
 377     static        Int8               getZeroElement(void)
 378     {
 379         return 0;
 380     }
 381
 382     static        Int8               getOneElement (void)
 383     {
 384         return 1;
 385     }
 386
 387     static        Int8               getMin        (void)
 388     {
 389         return std::numeric_limits<Int8>::min();
 390     }
 391
 392     static        Int8               getMax        (void)
 393     {
 394         return std::numeric_limits<Int8>::max();
 395     }
 396
 397
 398     static Real32      getFraction  (Int8   val)
 399     {
 400         return (Real32(val) / Real32(getMax()));
 401     };
 402
 403     static Int8        getPortion   (Real32 val)
 404     {
 405         return Int8(val * Real32(getMax()));
 406     };
 407
 408
 409     static Int8        getFromCString(const Char8 * pData,
 410                                              Char8 *&pDataEnd)
 411     {
 412         if(pData != NULL)
 413         {
 414             return Int8(strtol(pData, &pDataEnd, 0));
 415         }
 416         else
 417         {
 418             return getZeroElement();
 419         }
 420     }
 421
 422     static Int8        getFromCString(const Char8 *pData)
 423     {
 424         Char8 *pDataEnd;
 425
 426         return getFromCString(pData, pDataEnd);
 427     }
 428
 429     static void putToString  (const Int8         val,
 430                                     std::string &out)
 431     {
 432         Char8 buffer[10];
 433
 434         sprintf(buffer, "%i", val);
 435
 436         out.append(buffer);
 437     }
 438
 439     static void putToStream(const Int8      &val,
 440                                   OutStream &str)
 441     {
 442         str << Int32(val);
 443     }
 444 };
 445
 446
 447 /*! \ingroup GrpBaseBaseBaseTypeTraits
 448     \ingroup GrpLibOSGBase
 449  */
 450
 451 template <>
 452 struct TypeTraits<UInt16> : public TypeTraitsTemplateBase<UInt16>
 453 {
 454     typedef       Real32             RealReturnType;
 455
 456
 457     static const  bool               IsPOD       = true;
 458     static const  MathTypeProperties MathProp    = IntValue;
 459
 460     static const  UInt16             BitsSet     = 0xFFFF;
 461     static const  UInt16             BitsClear   = 0x0000;
 462
 463
 464     static        UInt16             getDefaultEps(void)
 465     {
 466         return 0;
 467     }
 468
 469     static        UInt16             getZeroElement(void)
 470     {
 471         return 0;
 472     }
 473
 474     static        UInt16             getOneElement (void)
 475     {
 476         return 1;
 477     }
 478
 479     static        UInt16             getMax        (void)
 480     {
 481         return std::numeric_limits<UInt16>::max();
 482     }
 483
 484     static        UInt16             getMin        (void)
 485     {
 486         return std::numeric_limits<UInt16>::min();
 487     }
 488
 489
 490     static Real32      getFraction  (UInt16 val)
 491     {
 492         return (Real32(val) / Real32(getMax()));
 493     };
 494
 495     static UInt16      getPortion   (Real32 val)
 496     {
 497         return UInt16(val * Real32(getMax()));
 498     };
 499
 500
 501     static UInt16      getFromCString(const Char8 * pData,
 502                                             Char8 *&pDataEnd)
 503     {
 504         if(pData != NULL)
 505         {
 506             return UInt16(strtoul(pData, &pDataEnd, 0));
 507         }
 508         else
 509         {
 510             return getZeroElement();
 511         }
 512     }
 513
 514     static UInt16      getFromCString(const Char8 *pData)
 515     {
 516         Char8 *pDataEnd;
 517
 518         return getFromCString(pData, pDataEnd);
 519     }
 520
 521     static void putToString  (const UInt16       val,
 522                                     std::string &out)
 523     {
 524         Char8 buffer[10];
 525
 526 //      Check WIN32 Version
 527 #ifdef WIN32
 528         sprintf(buffer, "%u", UInt32(val));
 529 #else
 530         sprintf(buffer, "%u", val);
 531 #endif
 532
 533         out.append(buffer);
 534     }
 535 };
 536
 537
 538 /*! \ingroup GrpBaseBaseBaseTypeTraits
 539     \ingroup GrpLibOSGBase
 540  */
 541
 542 template <>
 543 struct TypeTraits<Int16> : public TypeTraitsTemplateBase<Int16>
 544 {
 545     typedef       Real32             RealReturnType;
 546
 547
 548     static const  bool               IsPOD       = true;
 549     static const  MathTypeProperties MathProp    = IntValue;
 550
 551     static const  Int16              BitsSet     =  -1; //0xFFFF;
 552     static const  Int16              BitsClear   =  0x0000;
 553
 554
 555     static        Int16              getDefaultEps(void)
 556     {
 557         return 0;
 558     }
 559
 560     static        Int16              getZeroElement(void)
 561     {
 562         return 0;
 563     }
 564
 565     static        Int16              getOneElement (void)
 566     {
 567         return 1;
 568     }
 569
 570     static        Int16              getMax        (void)
 571     {
 572         return std::numeric_limits<Int16>::max();
 573     }
 574
 575     static        Int16              getMin        (void)
 576     {
 577         return std::numeric_limits<Int16>::min();
 578     }
 579
 580
 581     static Real32      getFraction  (Int16  val)
 582     {
 583         return (Real32(val) / Real32(getMax()));
 584     };
 585
 586     static Int16       getPortion   (Real32 val)
 587     {
 588         return Int16(val * Real32(getMax()));
 589     };
 590
 591
 592     static Int16       getFromCString(const Char8 * pData,
 593                                             Char8 *&pDataEnd)
 594     {
 595         if(pData != NULL)
 596         {
 597             return Int16(strtol(pData, &pDataEnd, 0));
 598         }
 599         else
 600         {
 601             return getZeroElement();
 602         }
 603     }
 604
 605     static Int16       getFromCString(const Char8 *pData)
 606     {
 607         Char8 *pDataEnd;
 608
 609         return getFromCString(pData, pDataEnd);
 610     }
 611
 612     static void putToString  (const Int16        val,
 613                                     std::string &out)
 614     {
 615         Char8 buffer[10];
 616
 617         sprintf(buffer, "%i", val);
 618
 619         out.append(buffer);
 620     }
 621 };
 622
 623
 624 /*! \ingroup GrpBaseBaseBaseTypeTraits
 625     \ingroup GrpLibOSGBase
 626  */
 627
 628 template <>
 629 struct TypeTraits<UInt32> : public TypeTraitsTemplateBase<UInt32>
 630 {
 631     typedef       Real32                RealReturnType;
 632
 633
 634     static const  bool               IsPOD       = true;
 635     static const  MathTypeProperties MathProp    = IntValue;
 636
 637     static const  UInt32             BitsSet     = 0xFFFFFFFF;
 638     static const  UInt32             BitsClear   = 0x00000000;
 639
 640
 641     static        UInt32             getDefaultEps(void)
 642     {
 643         return 0;
 644     }
 645
 646     static        UInt32             getZeroElement(void)
 647     {
 648         return 0;
 649     }
 650
 651     static        UInt32             getOneElement (void)
 652     {
 653         return 1;
 654     }
 655
 656     static        UInt32             getMax        (void)
 657     {
 658         return std::numeric_limits<UInt32>::max();
 659     }
 660
 661     static        UInt32             getMin        (void)
 662     {
 663         return std::numeric_limits<UInt32>::min();
 664     }
 665
 666
 667     static Real32      getFraction  (UInt32 val)
 668     {
 669         return (Real32(val) / Real32(getMax()));
 670     };
 671
 672     static UInt32      getPortion   (Real32 val)
 673     {
 674         return UInt32(val * Real32(getMax()));
 675     };
 676
 677
 678     static UInt32      getFromCString(const Char8 * pData,
 679                                             Char8 *&pDataEnd)
 680     {
 681         if(pData != NULL)
 682         {
 683             return UInt32(strtoul(pData, &pDataEnd, 0));
 684         }
 685         else
 686         {
 687             return getZeroElement();
 688         }
 689     }
 690
 691
 692     static UInt32      getFromCString(const Char8 *pData)
 693     {
 694         Char8 *pDataEnd;
 695
 696         return getFromCString(pData, pDataEnd);
 697     }
 698
 699
 700     static void putToString  (const UInt32       val,
 701                                     std::string &out)
 702     {
 703         Char8 buffer[15];
 704
 705         sprintf(buffer, "%u", val);
 706
 707         out.append(buffer);
 708     }
 709 };
 710
 711
 712 /*! \ingroup GrpBaseBaseBaseTypeTraits
 713     \ingroup GrpLibOSGBase
 714  */
 715
 716 template <>
 717 struct TypeTraits<Int32> : public TypeTraitsTemplateBase<Int32>
 718 {
 719     typedef       Real32             RealReturnType;
 720
 721
 722     static const  bool               IsPOD       = true;
 723     static const  MathTypeProperties MathProp    = IntValue;
 724
 725     static const  Int32              BitsSet     =  0xFFFFFFFF;
 726     static const  Int32              BitsClear   =  0x00000000;
 727
 728     static        Int32              getDefaultEps(void)
 729     {
 730         return 0;
 731     }
 732
 733     static        Int32              getZeroElement(void)
 734     {
 735         return 0;
 736     }
 737
 738     static        Int32              getOneElement (void)
 739     {
 740         return 1;
 741     }
 742
 743     static        Int32              getMax        (void)
 744     {
 745         return std::numeric_limits<Int32>::max();
 746     }
 747
 748     static        Int32              getMin        (void)
 749     {
 750         return std::numeric_limits<Int32>::min();
 751     }
 752
 753
 754     static Real32      getFraction  (Int32  val)
 755     {
 756         return (Real32(val) / Real32(getMax()));
 757     };
 758
 759     static Int32       getPortion   (Real32 val)
 760     {
 761         return Int32(val * Real32(getMax()));
 762     };
 763
 764
 765     static Int32       getFromCString(const Char8 * pData,
 766                                             Char8 *&pDataEnd)
 767     {
 768         if(pData != NULL)
 769         {
 770             return Int32(strtol(pData, &pDataEnd, 0));
 771         }
 772         else
 773         {
 774             return getZeroElement();
 775         }
 776     }
 777
 778     static Int32       getFromCString(const Char8 *pData)
 779     {
 780         Char8 *pDataEnd;
 781
 782         return getFromCString(pData, pDataEnd);
 783     }
 784
 785     static void putToString  (const Int32        val,
 786                                     std::string &out)
 787     {
 788         Char8 buffer[15];
 789
 790         sprintf(buffer, "%i", val);
 791
 792         out.append(buffer);
 793     }
 794 };
 795
 796
 797 /*! \ingroup GrpBaseBaseBaseTypeTraits
 798     \ingroup GrpLibOSGBase
 799  */
 800
 801 template <>
 802 struct TypeTraits<UInt64> : public TypeTraitsTemplateBase<UInt64>
 803 {
 804     typedef       Real32             RealReturnType;
 805
 806
 807     static const  bool               IsPOD       = true;
 808     static const  MathTypeProperties MathProp    = IntValue;
 809
 810     static const  UInt64             BitsSet     = OSGLL(0xFFFFFFFFFFFFFFFF);
 811     static const  UInt64             BitsClear   = OSGLL(0x0000000000000000);
 812
 813     static const  UInt64             Zero        = OSGLL(0x0000000000000000);
 814     static const  UInt64             One         = OSGLL(0x0000000000000001);
 815
 816
 817     static        UInt64             getDefaultEps(void)
 818     {
 819         return 0;
 820     }
 821
 822     static        UInt64             getZeroElement(void)
 823     {
 824         return 0;
 825     }
 826
 827     static        UInt64             getOneElement (void)
 828     {
 829         return 1;
 830     }
 831
 832
 833     static        UInt64             getMax        (void)
 834     {
 835         return std::numeric_limits<UInt64>::max();
 836     }
 837
 838     static        UInt64             getMin        (void)
 839     {
 840         return std::numeric_limits<UInt64>::min();
 841     }
 842
 843
 844     static Real32      getFraction  (UInt64 val)
 845     {
 846         return (Real32(val) / Real32(getMax()));
 847     };
 848
 849     static UInt64      getPortion   (Real32 val)
 850     {
 851         return UInt64(val * Real32(getMax()));
 852     };
 853
 854
 855     static UInt64      getFromCString(const Char8 * pData,
 856                                             Char8 *&pDataEnd)
 857     {
 858         if(pData != NULL)
 859         {
 860 #ifndef WIN32
 861             return UInt64(strtoull(pData, &pDataEnd, 0));
 862 #else
 863             // FIXME
 864             return _atoi64(pData);
 865 #endif
 866         }
 867         else
 868         {
 869             return getZeroElement();
 870         }
 871     }
 872
 873     static UInt64      getFromCString(const Char8 *pData)
 874     {
 875         Char8 *pDataEnd;
 876
 877         return getFromCString(pData, pDataEnd);
 878     }
 879
 880     static void putToString  (const UInt64       val,
 881                                     std::string &out)
 882     {
 883         Char8 buffer[25];
 884 #if defined(__x86_64__) && ! defined(__APPLE__)
 885         sprintf(buffer, "%lu", val);
 886 #else
 887         sprintf(buffer, "%llu", val);
 888 #endif
 889         out.append(buffer);
 890     }
 891 };
 892
 893
 894 /*! \ingroup GrpBaseBaseBaseTypeTraits
 895     \ingroup GrpLibOSGBase
 896  */
 897
 898 template <>
 899 struct TypeTraits<Int64> : public TypeTraitsTemplateBase<Int64>
 900 {
 901     typedef       Real32 RealReturnType;
 902
 903
 904     static const  bool               IsPOD       = true;
 905     static const  MathTypeProperties MathProp    = IntValue;
 906
 907     static const  Int64              BitsSet     =  OSGLL(0xFFFFFFFFFFFFFFFF);
 908     static const  Int64              BitsClear   =  OSGLL(0x0000000000000000);
 909
 910
 911     static        Int64              getDefaultEps(void)
 912     {
 913         return 0;
 914     }
 915
 916     static        Int64              getZeroElement(void)
 917     {
 918         return 0;
 919     }
 920
 921     static        Int64              getOneElement (void)
 922     {
 923         return 1;
 924     }
 925
 926     static        Int64              getMax        (void)
 927     {
 928         return std::numeric_limits<Int64>::max();
 929     }
 930
 931     static        Int64              getMin        (void)
 932     {
 933         return std::numeric_limits<Int64>::min();
 934     }
 935
 936
 937     static Real32      getFraction  (Int64  val)
 938     {
 939         return (Real32(val) / Real32(getMax()));
 940     };
 941
 942     static Int64       getPortion   (Real32 val)
 943     {
 944         return Int64(val * Real32(getMax()));
 945     };
 946
 947
 948     static Int64       getFromCString(const Char8 * pData,
 949                                             Char8 *&pDataEnd)
 950     {
 951         if(pData != NULL)
 952         {
 953 #ifndef WIN32
 954             return  Int64(strtoll(pData, &pDataEnd, 0));
 955 #else
 956             // FIXME
 957             return _atoi64(pData);
 958 #endif
 959         }
 960         else
 961         {
 962             return getZeroElement();
 963         }
 964     }
 965
 966     static Int64       getFromCString(const Char8 *pData)
 967     {
 968         Char8 *pDataEnd;
 969
 970         return getFromCString(pData, pDataEnd);
 971     }
 972
 973     static void putToString  (const Int64        val,
 974                                     std::string &out)
 975     {
 976         Char8 buffer[25];
 977
 978 #if defined(__x86_64__) && ! defined(__APPLE__)
 979         sprintf(buffer, "%li", val);
 980 #else
 981         sprintf(buffer, "%lli", val);
 982 #endif
 983
 984         out.append(buffer);
 985     }
 986 };
 987
 988 /*! \ingroup GrpBaseBaseBaseTypeTraits
 989     \ingroup GrpLibOSGBase
 990 */
 991
 992 template <>
 993 struct TypeTraits<Real16> : public TypeTraitsTemplateBase<Real16>
 994 {
 995     typedef       Real16             RealReturnType;
 996
 997
 998     static const  bool               IsPOD       = true;
 999     static const  MathTypeProperties MathProp    = RealValue;
1000
1001     static        Real16             getDefaultEps(void)
1002     {
1003         return Real16(1E-06f);
1004     }
1005
1006     static        Real16             getZeroElement(void)
1007     {
1008         return Real16(0.f);
1009     }
1010
1011     static        Real16             getOneElement (void)
1012     {
1013         return Real16(1.f);
1014     }
1015
1016     static        Real16             getMax        (void)
1017     {
1018         return  REAL16_MAX;
1019     }
1020
1021     static        Real16             getMin        (void)
1022     {
1023         return -REAL16_MAX;
1024     }
1025
1026
1027     static Real16 getFraction     (Real16 rVal) { return rVal; };
1028     static Real16 getPortion      (Real16 rVal) { return rVal; };
1029
1030
1031     static Real16 getFromCString   (const Char8 *szString,
1032                                           Char8 *&pDataEnd)
1033     {
1034         if(szString != NULL)
1035         {
1036 #if defined(__sgi) || defined(WIN32) || defined(__sun)
1037             return Real16(Real32(atof  (szString)));
1038 #else
1039             return Real16(Real32(strtof(szString, &pDataEnd)));
1040 #endif
1041         }
1042         else
1043         {
1044             return getZeroElement();
1045         }
1046     }
1047
1048     static Real16 getFromCString   (const Char8 *pData)
1049     {
1050         Char8 *pDataEnd;
1051
1052         return getFromCString(pData, pDataEnd);
1053     }
1054
1055     static void putToString(const Real16       val,
1056                                   std::string &out)
1057     {
1058         Char8 buffer[20];
1059
1060         sprintf(buffer, "%e", Real32(val));
1061
1062         out.append(buffer);
1063     }
1064 };
1065
1066
1067 /*! \ingroup GrpBaseBaseBaseTypeTraits
1068     \ingroup GrpLibOSGBase
1069  */
1070
1071 template <>
1072 struct TypeTraits<Real32> : public TypeTraitsTemplateBase<Real32>
1073 {
1074     typedef       Real32             RealReturnType;
1075
1076
1077     static const  bool               IsPOD       = true;
1078     static const  MathTypeProperties MathProp    = RealValue;
1079
1080     static        Real32             ZeroEps(void)
1081     {
1082         return 1E-30f;
1083     }
1084
1085     static        Real32             getDefaultEps(void)
1086     {
1087         return 1E-06f;
1088     }
1089
1090     static        Real32             getZeroElement(void)
1091     {
1092         return 0.f;
1093     }
1094
1095     static        Real32             getOneElement (void)
1096     {
1097         return 1.f;
1098     }
1099
1100     static        Real32             getMax        (void)
1101     {
1102         return  std::numeric_limits<float>::max();
1103     }
1104
1105     static        Real32             getMin        (void)
1106     {
1107         return -std::numeric_limits<float>::max();
1108     }
1109
1110
1111     static Real32 getFraction     (Real32 rVal) { return rVal; };
1112     static Real32 getPortion      (Real32 rVal) { return rVal; };
1113
1114
1115     static Real32 getFromCString   (const Char8 * pData,
1116                                           Char8 *&pDataEnd)
1117     {
1118         if(pData != NULL)
1119         {
1120 #if defined(__sgi) || defined(WIN32) || defined(__sun)
1121             // FIXME
1122             return Real32(atof  (pData));
1123 #else
1124             return Real32(strtof(pData, &pDataEnd));
1125 #endif
1126         }
1127         else
1128         {
1129             return getZeroElement();
1130         }
1131     }
1132
1133     static Real32 getFromCString   (const Char8 *pData)
1134     {
1135         Char8 *pDataEnd;
1136
1137         return getFromCString(pData, pDataEnd);
1138     }
1139
1140     static void putToString(const Real32       val,
1141                                   std::string &out)
1142     {
1143         out.append(boost::lexical_cast<std::string>(val));
1144     }
1145 };
1146
1147
1148 /*! \ingroup GrpBaseBaseBaseTypeTraits
1149     \ingroup GrpLibOSGBase
1150  */
1151
1152 template <>
1153 struct TypeTraits<Fixed32> : public TypeTraitsTemplateBase<Fixed32>
1154 {
1155     typedef       Fixed32             RealReturnType;
1156
1157
1158     static const  bool               IsPOD       = true;
1159     static const  MathTypeProperties MathProp    = RealValue;
1160
1161
1162     static        Fixed32            ZeroEps(void)
1163     {
1164         return Fixed32(0.00009f);
1165     }
1166
1167     static        Fixed32            getDefaultEps (void)
1168     {
1169         return Fixed32(1E-06f);
1170     }
1171
1172     static        Fixed32            getZeroElement(void)
1173     {
1174         return Fixed32(0.f);
1175     }
1176
1177     static        Fixed32            getOneElement (void)
1178     {
1179         return Fixed32(1.f);
1180     }
1181
1182     static        Fixed32            getMax        (void)
1183     {
1184         return Fixed32(REAL16_MAX);
1185     }
1186
1187     static        Fixed32            getMin        (void)
1188     {
1189         return Fixed32(-REAL16_MAX);
1190     }
1191
1192     static Fixed32 getFromCString   (const Char8 * pData,
1193                                            Char8 *&OSG_CHECK_ARG(pDataEnd))
1194     {
1195         // XXX TODO: implement
1196
1197         if(pData != NULL)
1198         {
1199             return getZeroElement();
1200         }
1201         else
1202         {
1203             return getZeroElement();
1204         }
1205     }
1206
1207     static Fixed32 getFromCString   (const Char8 *pData)
1208     {
1209         // XXX TODO: implement
1210
1211         Char8 *pDataEnd;
1212
1213         return getFromCString(pData, pDataEnd);
1214     }
1215
1216     static void putToString(const Fixed32       OSG_CHECK_ARG(val),
1217                                   std::string & OSG_CHECK_ARG(out))
1218     {
1219         // XXX TODO: implement
1220     }
1221 };
1222
1223
1224 /*! \ingroup GrpBaseBaseBaseTypeTraits
1225     \ingroup GrpLibOSGBase
1226  */
1227
1228 template <>
1229 struct TypeTraits<Real64> : public TypeTraitsTemplateBase<Real64>
1230 {
1231     typedef       Real64             RealReturnType;
1232
1233
1234     static const  bool               IsPOD       = true;
1235     static const  MathTypeProperties MathProp    = RealValue;
1236
1237     static        Real64             ZeroEps(void)
1238     {
1239         return 1E-30;
1240     }
1241
1242     static        Real64             getDefaultEps (void)
1243     {
1244         return 1E-12;
1245     }
1246
1247     static        Real64             getZeroElement(void)
1248     {
1249         return 0.0;
1250     }
1251
1252     static        Real64             getOneElement (void)
1253     {
1254         return 1.0;
1255     }
1256
1257     static        Real64             getMax        (void)
1258     {
1259         return  std::numeric_limits<double>::max();
1260     }
1261
1262     static        Real64             getMin        (void)
1263     {
1264         return -std::numeric_limits<double>::max();
1265     }
1266
1267
1268     static Real64 getFraction     (Real64 rVal) { return rVal; };
1269     static Real64 getPortion      (Real64 rVal) { return rVal; };
1270
1271
1272     static Real64 getFromCString   (const Char8 * pData,
1273                                           Char8 *&pDataEnd)
1274     {
1275         if(pData != NULL)
1276         {
1277             return Real64(strtod(pData, &pDataEnd));
1278         }
1279         else
1280         {
1281             return getZeroElement();
1282         }
1283     }
1284
1285     static Real64 getFromCString   (const Char8 *pData)
1286     {
1287         Char8 *pDataEnd;
1288
1289         return getFromCString(pData, pDataEnd);
1290     }
1291
1292     static void putToString(const Real64       val,
1293                                   std::string &out)
1294     {
1295         out.append(boost::lexical_cast<std::string>(val));
1296     }
1297 };
1298
1299
1300 /*! \ingroup GrpBaseBaseBaseTypeTraits
1301     \ingroup GrpLibOSGBase
1302  */
1303
1304 template <>
1305 struct TypeTraits<Real128> : public TypeTraitsTemplateBase<Real128>
1306 {
1307     typedef       Real128             RealReturnType;
1308
1309
1310     static const  bool               IsPOD       = true;
1311     static const  MathTypeProperties MathProp    = RealValue;
1312
1313     static        Real64             getDefaultEps (void)
1314     {
1315         return 1E-24;
1316     }
1317
1318     static        Real128             getZeroElement(void)
1319     {
1320         return 0.0;
1321     }
1322
1323     static        Real128             getOneElement (void)
1324     {
1325         return 1.0;
1326     }
1327
1328     static        Real128             getMax        (void)
1329     {
1330         return  std::numeric_limits<long double>::max();
1331     }
1332
1333     static        Real128             getMin        (void)
1334     {
1335         return -std::numeric_limits<long double>::max();
1336     }
1337
1338
1339     static Real128 getFraction     (Real128 rVal) { return rVal; };
1340     static Real128 getPortion      (Real128 rVal) { return rVal; };
1341
1342
1343     static Real128 getFromCString   (const Char8 * pData,
1344                                            Char8 *&pDataEnd)
1345     {
1346         if(pData != NULL)
1347         {
1348 #if defined(WIN32) || defined(__sun)
1349             return Real128(strtod (pData, &pDataEnd));
1350 #else
1351             return Real128(strtold(pData, &pDataEnd));
1352 #endif
1353         }
1354         else
1355         {
1356             return getZeroElement();
1357         }
1358     }
1359
1360     static Real128 getFromCString   (const Char8 *pData)
1361     {
1362         Char8 *pDataEnd;
1363
1364         return getFromCString(pData, pDataEnd);
1365     }
1366
1367     static void putToString(const Real128      val,
1368                                   std::string &out)
1369     {
1370         out.append(boost::lexical_cast<std::string>(val));
1371     }
1372 };
1373
1374
1375 #ifdef SIZE_T_NEQ_UINT32
1376
1377 /*! \ingroup GrpBaseBaseBaseTypeTraits
1378     \ingroup GrpLibOSGBase
1379  */
1380
1381 #ifdef SIZE_T_64BIT
1382 template <>
1383 struct TypeTraits<size_t> : public TypeTraits<UInt64> {};
1384 #else
1385 template <>
1386 struct TypeTraits<size_t> : public TypeTraits<UInt32> {};
1387 #endif
1388
1389 #if 0
1390 template <>
1391 struct TypeTraits<size_t> : public TypeTraitsTemplateBase<size_t>
1392 {
1393     typedef       Real32                RealReturnType;
1394
1395
1396     static const  bool               IsPOD       = true;
1397     static const  MathTypeProperties MathProp    = IntValue;
1398
1399     static const  UInt32             BitsSet     = 0xFFFFFFFF;
1400     static const  UInt32             BitsClear   = 0x00000000;
1401
1402
1403     static        size_t             getZeroElement(void)
1404     {
1405         return 0;
1406     }
1407
1408     static        size_t             getOneElement (void)
1409     {
1410         return 1;
1411     }
1412
1413     static        size_t             getMax        (void)
1414     {
1415         return std::numeric_limits<size_t>::max();
1416     }
1417
1418     static        size_t             getMin        (void)
1419     {
1420         return std::numeric_limits<size_t>::min();
1421     }
1422
1423
1424     static size_t      getFromCString(const Char8 * pData,
1425                                             Char8 *&pDataEnd)
1426     {
1427         if(pData != NULL)
1428         {
1429             return size_t(strtoul(pData, &pDataEnd, 0));
1430         }
1431         else
1432         {
1433             return getZeroElement();
1434         }
1435     }
1436
1437
1438     static size_t      getFromCString(const Char8 *pData)
1439     {
1440         Char8 *pDataEnd;
1441
1442         return getFromCString(pData, pDataEnd);
1443     }
1444
1445
1446     static void putToString  (const size_t       val,
1447                                     std::string &out)
1448     {
1449         Char8 buffer[15];
1450
1451         sprintf(buffer, "%u", val);
1452
1453         out.append(buffer);
1454     }
1455 };
1456 #endif
1457
1458 #endif
1459
1460
1461 #ifdef OSG_GLENUM_NEQ_UINT32
1462
1463 /*! \ingroup GrpBaseBaseBaseTypeTraits
1464     \ingroup GrpLibOSGBase
1465  */
1466
1467 template <>
1468 struct TypeTraits<GLenum> : public TypeTraitsTemplateBase<GLenum>
1469 {
1470     typedef       Real32                RealReturnType;
1471
1472
1473     static const  bool               IsPOD       = true;
1474     static const  MathTypeProperties MathProp    = IntValue;
1475
1476     static const  UInt32             BitsSet     = 0xFFFFFFFF;
1477     static const  UInt32             BitsClear   = 0x00000000;
1478
1479
1480     static        GLenum             getZeroElement(void)
1481     {
1482         return 0;
1483     }
1484
1485     static        GLenum             getOneElement (void)
1486     {
1487         return 1;
1488     }
1489
1490     static        GLenum             getMax        (void)
1491     {
1492         return 0xFFFFFFFF;
1493     }
1494
1495     static        GLenum             getMin        (void)
1496     {
1497         return 0x00000000;
1498     }
1499
1500
1501     static GLenum      getFromCString(const Char8 * pData,
1502                                             Char8 *&pDataEnd)
1503     {
1504         if(pData != NULL)
1505         {
1506             return GLenum(strtoul(pData, reinterpret_cast<char**>(pDataEnd), 0));
1507         }
1508         else
1509         {
1510             return getZeroElement();
1511         }
1512     }
1513
1514     static GLenum      getFromCString(const Char8 *pData)
1515     {
1516         Char8 *pDataEnd;
1517
1518         return getFromCString(pData, pDataEnd);
1519     }
1520
1521     static void putToString  (const GLenum       val,
1522                                     std::string &out)
1523     {
1524         Char8 buffer[15];
1525
1526         sprintf(buffer, "%lu", static_cast<unsigned long>(val));
1527
1528         out.append(buffer);
1529     }
1530 };
1531
1532 #endif
1533
1534 OSG_END_NAMESPACE
1535
1536 #ifndef OSG_DISABLE_DEPRECATED
1537 #define TypeConstants TypeTraits
1538 #define getAllSet()   BitsSet
1539 #endif
1540
1541 #endif /* _OSGBASETYPETRAITS_H_ */