Source/Base/Field/OSGFieldTraits.h

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 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 _OSGFIELDTRAITS_H_
  40 #define _OSGFIELDTRAITS_H_
  41 #ifdef __sgi
  42 #pragma once
  43 #endif
  44
  45 #include "OSGFieldForwards.h"
  46 #include "OSGLog.h"
  47 #include "OSGContainerForwards.h"
  48 #include "OSGFieldType.h"
  49 #include "OSGPointerType.h"
  50
  51 #include <iosfwd>
  52
  53 #include <boost/mpl/if.hpp>
  54
  55 OSG_BEGIN_NAMESPACE
  56
  57 class FieldType;
  58 class BasicFieldConnector;
  59
  60 template<class FieldTypeT>
  61 class FieldConnector;
  62
  63 /*! \ingroup GrpBaseFieldTraits
  64     \ingroup GrpLibOSGBase
  65  */
  66
  67 struct FieldTraitsBase
  68 {
  69     enum
  70     {
  71         NotConvertible        = 0x00,
  72
  73         ToStringConvertible   = 0x01,
  74         FromStringConvertible = 0x02,
  75
  76         ToStreamConvertible   = 0x10,
  77         FromStreamConvertible = 0x20
  78     };
  79
  80     typedef void ParentType;
  81
  82     static const Char8 *getSPName(void) { return "Field";   }
  83     static const Char8 *getMPName(void) { return "Field";   }
  84 };
  85
  86 enum VecSize
  87 {
  88     Vec1,
  89     Vec2,
  90     Vec3,
  91     Vec4
  92 };
  93
  94
  95 template<class ValueT, Int32 iNamespace = 0>
  96 struct FieldTraits;
  97
  98 /*! \ingroup GrpBaseFieldTraits
  99     \ingroup GrpLibOSGBase
 100     \nohierarchy
 101  */
 102
 103 struct InvalidTrait
 104 {
 105 };
 106
 107 /*! \ingroup GrpBaseFieldTraits
 108     \ingroup GrpLibOSGBase
 109  */
 110
 111 template<class ValueT, Int32 NamespaceI = 0>
 112 struct FieldTraitsTemplateBase : public FieldTraitsBase
 113 {
 114 #ifndef __hpux
 115     static const UInt32 uiTest = TypeTraits<ValueT>::IsPOD == true;
 116
 117     typedef typename
 118         boost::mpl::if_<boost::mpl::bool_<(uiTest == 1)>,
 119                         const ValueT  ,
 120                         const ValueT & >::type  ArgumentType;
 121 #else
 122     typedef typename
 123     boost::mpl::if_<boost::mpl::bool_<TypeTraits<ValueT>::IsPOD>,
 124                     const ValueT  ,
 125                     const ValueT & >::type  ArgumentType;
 126 #endif
 127
 128
 129     typedef      ValueT                            ValueType;
 130
 131     typedef      OSG_STL_DEFAULT_ALLOCATOR(ValueT) MFAlloc;
 132
 133
 134     static const Int32                 iNamespace      = NamespaceI;
 135     static const bool                  bIsPointerField = false;
 136 };
 137
 138 /*! \ingroup GrpBaseFieldTraits
 139     \ingroup GrpLibOSGBase
 140  */
 141
 142 template<class ValueT, Int32 iNamespace = 0>
 143 struct FieldTraitsPODTemplateBase : public FieldTraitsTemplateBase<ValueT,
 144                                                                    iNamespace>
 145 {
 146     static bool      getFromCString(      ValueT  &outVal,
 147                                     const Char8  *&inVal )
 148     {
 149         outVal = TypeTraits<ValueT>::getFromCString(inVal);
 150
 151         return true;
 152     }
 153
 154     static void putToString(const ValueT      &inVal,
 155                                   std::string &outVal)
 156     {
 157         TypeTraits<ValueT>::putToString(inVal, outVal);
 158     }
 159
 160     static void putToStream(const ValueT    &val,
 161                                   OutStream &str)
 162     {
 163         TypeTraits<ValueT>::putToStream(val, str);
 164     }
 165
 166     // Binary
 167
 168     static SizeT  getBinSize(const ValueT &)
 169     {
 170         return sizeof(ValueT);
 171     }
 172
 173     static SizeT  getBinSize(const ValueT   *,
 174                                    SizeT     uiNumObjects)
 175     {
 176         return sizeof(ValueT) * uiNumObjects;
 177     }
 178
 179     static void copyToBin(      BinaryDataHandler &pMem,
 180                           const ValueT            &oObject)
 181     {
 182         pMem.putValue(oObject);
 183     }
 184
 185     static void copyToBin(      BinaryDataHandler &pMem,
 186                           const ValueT            *pObjectStore,
 187                                 SizeT              uiNumObjects)
 188     {
 189         pMem.putValues(&(pObjectStore[0]), uiNumObjects);
 190     }
 191
 192     static void copyFromBin(BinaryDataHandler &pMem,
 193                             ValueT            &oObject)
 194     {
 195         pMem.getValue(oObject);
 196     }
 197
 198     static void copyFromBin(BinaryDataHandler &pMem,
 199                             ValueT            *pObjectStore,
 200                             SizeT              uiNumObjects)
 201     {
 202         pMem.getValues(&(pObjectStore[0]), uiNumObjects);
 203     }
 204 };
 205
 206 /*! \ingroup GrpBaseFieldTraits
 207     \ingroup GrpLibOSGBase
 208  */
 209
 210 template<class ValueT, Int32 iNamespace = 0>
 211 struct FieldTraitsVecTemplateBase : public FieldTraitsTemplateBase<ValueT,
 212                                                                    iNamespace>
 213 {
 214     // Binary
 215
 216     typedef FieldTraitsVecTemplateBase<ValueT,
 217                                        iNamespace>  Self;
 218
 219     static const UInt32                            _uiSize = ValueT::_uiSize;
 220
 221     typedef typename ValueT::ValueType              SingleValueT;
 222
 223     static bool getFromCString(      ValueT  &outVal,
 224                                const Char8  *&inVal )
 225     {
 226         outVal.setValueFromCString(inVal);
 227
 228         return true;
 229     }
 230
 231     static SizeT  getBinSize(const ValueT &)
 232     {
 233         return sizeof(SingleValueT) * _uiSize;
 234     }
 235
 236     static SizeT  getBinSize(const ValueT   *,
 237                                    SizeT     uiNumObjects)
 238     {
 239         return sizeof(SingleValueT) * _uiSize * uiNumObjects;
 240     }
 241
 242     static void copyToBin(      BinaryDataHandler &pMem,
 243                           const ValueT            &oObject)
 244     {
 245         pMem.putValues(&(oObject[0]), _uiSize);
 246     }
 247
 248     static void copyToBin(      BinaryDataHandler &pMem,
 249                           const ValueT            *pObjectStore,
 250                                 SizeT              uiNumObjects)
 251     {
 252         pMem.putValues(&(pObjectStore[0][0]), uiNumObjects * _uiSize);
 253     }
 254
 255     static void copyFromBin(BinaryDataHandler &pMem,
 256                             ValueT            &oObject)
 257     {
 258         pMem.getValues(&(oObject[0]), _uiSize);
 259     }
 260
 261     static void copyFromBin(BinaryDataHandler &pMem,
 262                             ValueT            *pObjectStore,
 263                             SizeT              uiNumObjects)
 264     {
 265         pMem.getValues(&(pObjectStore[0][0]), uiNumObjects * _uiSize);
 266     }
 267 };
 268
 269 /*! \ingroup GrpBaseFieldTraits
 270     \ingroup GrpLibOSGBase
 271  */
 272
 273 template<class ValueT, Int32 iNamespace = 0>
 274 struct FieldTraitsPtrToStringTemplateBase :
 275     public FieldTraitsTemplateBase<ValueT, iNamespace>
 276 {
 277     // Binary
 278
 279     typedef FieldTraitsPtrToStringTemplateBase<ValueT,
 280                                                iNamespace>  Self;
 281
 282     static SizeT  getBinSize(const ValueT &oObject)
 283     {
 284         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 285
 286         std::string value;
 287
 288         MappedTrait::putToString(oObject, value);
 289
 290         return value.length() + 1 + sizeof(UInt32);
 291     }
 292
 293     static SizeT  getBinSize(const ValueT   *pObjectStore,
 294                                    SizeT     uiNumObjects)
 295     {
 296         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 297
 298         SizeT size = 0;
 299
 300         for(SizeT i = 0; i < uiNumObjects; ++i)
 301         {
 302             size += MappedTrait::getBinSize(pObjectStore[i]);
 303         }
 304
 305         return size;
 306     }
 307
 308     static void copyToBin(      BinaryDataHandler &pMem,
 309                           const ValueT            &oObject)
 310     {
 311         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 312
 313         std::string value;
 314
 315         MappedTrait::putToString(oObject, value);
 316
 317         pMem.putValue(value);
 318     }
 319
 320     static void copyToBin(      BinaryDataHandler &pMem,
 321                           const ValueT            *pObjectStore,
 322                                 SizeT              uiNumObjects)
 323     {
 324         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 325
 326         // defaut: copy each element
 327         for(SizeT i = 0; i < uiNumObjects; ++i)
 328         {
 329             MappedTrait::copyToBin(pMem, pObjectStore[i]);
 330         }
 331     }
 332
 333     static void copyFromBin(BinaryDataHandler &pMem,
 334                             ValueT            &oObject)
 335     {
 336         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 337
 338         const Char8 *c = NULL;
 339
 340         std::string value;
 341
 342         pMem.getValue(value);
 343
 344         c = value.c_str();
 345
 346         MappedTrait::getFromCString(oObject, c);
 347     }
 348
 349     static void copyFromBin(BinaryDataHandler &pMem,
 350                             ValueT            *pObjectStore,
 351                             SizeT              uiNumObjects)
 352     {
 353         typedef FieldTraits<ValueT, iNamespace> MappedTrait;
 354
 355         // defaut: copy each element
 356         for(SizeT i = 0; i < uiNumObjects; ++i)
 357         {
 358             MappedTrait::copyFromBin(pMem, pObjectStore[i]);
 359         }
 360     }
 361 };
 362
 363 /*! \ingroup GrpBaseFieldTraits
 364     \ingroup GrpLibOSGBase
 365  */
 366
 367 template<class ValueT, Int32 iNamespace = 0>
 368 struct FieldTraitsVec1TemplateBase :
 369     public FieldTraitsVecTemplateBase<ValueT,
 370                                       iNamespace>
 371 {
 372     static void putToStream(const ValueT    &val,
 373                                   OutStream &str)
 374     {
 375         typedef typename ValueT::ValueType     ValueType;
 376
 377         typedef          TypeTraits<ValueType> TypeTrait;
 378
 379         TypeTrait::putToStream(val[0], str);
 380     }
 381 };
 382
 383 /*! \ingroup GrpBaseFieldTraits
 384     \ingroup GrpLibOSGBase
 385  */
 386
 387 template<class ValueT, Int32 iNamespace = 0>
 388 struct FieldTraitsVec2TemplateBase :
 389     public FieldTraitsVecTemplateBase<ValueT,
 390                                       iNamespace>
 391 {
 392     static void putToStream(const ValueT    &val,
 393                                   OutStream &str)
 394     {
 395         typedef typename ValueT::ValueType     ValueType;
 396
 397         typedef          TypeTraits<ValueType> TypeTrait;
 398
 399         TypeTrait::putToStream(val[0], str);
 400
 401         str << " ";
 402
 403         TypeTrait::putToStream(val[1], str);
 404     }
 405 };
 406
 407
 408 /*! \ingroup GrpBaseFieldTraits
 409     \ingroup GrpLibOSGBase
 410  */
 411
 412 template<class ValueT, Int32 iNamespace = 0>
 413 struct FieldTraitsVec3TemplateBase :
 414     public FieldTraitsVecTemplateBase<ValueT,
 415                                       iNamespace>
 416 {
 417     static void putToStream(const ValueT    &val,
 418                                   OutStream &str)
 419     {
 420         typedef typename ValueT::ValueType     ValueType;
 421
 422         typedef          TypeTraits<ValueType> TypeTrait;
 423
 424         TypeTrait::putToStream(val[0], str);
 425
 426         str << " ";
 427
 428         TypeTrait::putToStream(val[1], str);
 429
 430         str << " ";
 431
 432         TypeTrait::putToStream(val[2], str);
 433     }
 434 };
 435
 436
 437 /*! \ingroup GrpBaseFieldTraits
 438     \ingroup GrpLibOSGBase
 439  */
 440
 441 template<class ValueT, Int32 iNamespace = 0>
 442 struct FieldTraitsVec4TemplateBase :
 443     public FieldTraitsVecTemplateBase<ValueT,
 444                                       iNamespace>
 445 {
 446     static void putToStream(const ValueT    &val,
 447                                   OutStream &str)
 448     {
 449         typedef typename ValueT::ValueType     ValueType;
 450
 451         typedef          TypeTraits<ValueType> TypeTrait;
 452
 453         TypeTrait::putToStream(val[0], str);
 454
 455         str << " ";
 456
 457         TypeTrait::putToStream(val[1], str);
 458
 459         str << " ";
 460
 461         TypeTrait::putToStream(val[2], str);
 462
 463         str << " ";
 464
 465         TypeTrait::putToStream(val[3], str);
 466     }
 467 };
 468
 469
 470 /*! \ingroup GrpBaseFieldTraits
 471     \ingroup GrpLibOSGBase
 472     \nohierarchy
 473  */
 474
 475 template <class T, Int32 iNamespace = 0>
 476 struct StreamConversionError
 477 {
 478     static void getFromStream(      T            &,
 479                                     std::istream &)
 480     {
 481         SLOG << "Error from stream conversion not available for "
 482              << FieldTraits<T, iNamespace>::getType().getCName() << std::endl;
 483     }
 484
 485     static void putToStream(const T         &,
 486                                   OutStream &)
 487     {
 488         SLOG << "Error to stream conversion not available for "
 489              << FieldTraits<T, iNamespace>::getType().getCName() << std::endl;
 490     }
 491 };
 492
 493 /*! \ingroup GrpBaseFieldTraits
 494     \ingroup GrpLibOSGBase
 495     \nohierarchy
 496  */
 497
 498 template <class T, Int32 iNamespace = 0>
 499 struct StringConversionError
 500 {
 501     static void getFromCString(      T      &,
 502                                const Char8 *&)
 503     {
 504         SLOG << "Error from string conversion not available for "
 505              << FieldTraits<T, iNamespace>::getType().getCName() << std::endl;
 506     }
 507
 508     static void putToString(const T           &,
 509                                   std::string &)
 510     {
 511         SLOG << "Error to string conversion not available for "
 512              << FieldTraits<T, iNamespace>::getType().getCName() << std::endl;
 513     }
 514 };
 515
 516 template<class    DescT,
 517          enum     FieldType::Cardinality eFieldCard,
 518          typename RefCountPolicy                    ,
 519          enum     FieldType::Class       eFieldClass>
 520 class FieldDescription;
 521
 522 OSG_END_NAMESPACE
 523
 524 #include "OSGFieldTraits.inl"
 525
 526 #endif /* _OSGFIELDTRAITS_H_ */