OpenSG: OSGVecFieldDataType.h Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
00006  *                                                                           *
00007  *                            www.opensg.org                                 *
00008  *                                                                           *
00009  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
00010  *                                                                           *
00011 \*---------------------------------------------------------------------------*/
00012 /*---------------------------------------------------------------------------*\
00013  *                                License                                    *
00014  *                                                                           *
00015  * This library is free software; you can redistribute it and/or modify it   *
00016  * under the terms of the GNU Library General Public License as published    *
00017  * by the Free Software Foundation, version 2.                               *
00018  *                                                                           *
00019  * This library is distributed in the hope that it will be useful, but       *
00020  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
00021  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
00022  * Library General Public License for more details.                          *
00023  *                                                                           *
00024  * You should have received a copy of the GNU Library General Public         *
00025  * License along with this library; if not, write to the Free Software       *
00026  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
00027  *                                                                           *
00028 \*---------------------------------------------------------------------------*/
00029 /*---------------------------------------------------------------------------*\
00030  *                                Changes                                    *
00031  *                                                                           *
00032  *                                                                           *
00033  *                                                                           *
00034  *                                                                           *
00035  *                                                                           *
00036  *                                                                           *
00037 \*---------------------------------------------------------------------------*/
00038 
00039 
00040 #ifndef _OSG_VECFIELDDATATYPE_H_
00041 #define _OSG_VECFIELDDATATYPE_H_
00042 
00043 #include <OSGBase.h>
00044 #include <OSGFieldDataType.h>
00045 #include <OSGVector.h>
00046 
00047 #include <string>
00048 
00049 OSG_BEGIN_NAMESPACE
00050 
00051 #if !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
00052 
00053 #ifdef OSG_DOC_FILES_IN_MODULE
00054 
00058 #endif
00059 
00060 
00063 #if !defined(OSG_DOC_DEV_TRAITS)
00064 
00065 #endif
00066 
00067 template<class ValueTypeT>
00068 struct FieldTraitsRecurseVecStoreBase : public FieldTraits
00069 {
00070     enum                     { bHasParent = 0x00 };
00071 
00072 #ifndef __hpux
00073     static const UInt32 uiTest = TypeTraits<ValueTypeT>::IsPOD == false;
00074 
00075     typedef typename 
00076     osgIF<uiTest == 1, 
00077           const ValueTypeT  , 
00078           const ValueTypeT & >::_IRet  ArgumentType;
00079 #else
00080     typedef typename 
00081     osgIF<!TypeTraits<ValueTypeT>::IsPOD, 
00082           const ValueTypeT  , 
00083           const ValueTypeT & >::_IRet  ArgumentType;
00084 #endif
00085 
00086     static UInt32 getBinSize (const ValueTypeT &)
00087     {
00088         return sizeof(ValueTypeT);
00089     }
00090 
00091     static UInt32 getBinSize (const ValueTypeT *,
00092                                     UInt32      uiNumObjects)
00093     {
00094         return sizeof(ValueTypeT) * uiNumObjects;
00095     }
00096 
00097     static void   copyToBin  (      BinaryDataHandler &pMem, 
00098                               const ValueTypeT        &oObject)
00099     {
00100         pMem.putValues(&oObject[0], ValueTypeT::_iSize);
00101     }
00102 
00103     static void   copyToBin  (      BinaryDataHandler &pMem, 
00104                               const ValueTypeT        *pObjectStore,
00105                                     UInt32             uiNumObjects)
00106     {
00107         pMem.putValues(&pObjectStore[0][0], ValueTypeT::_iSize*uiNumObjects);
00108     }
00109 
00110     static void   copyFromBin(      BinaryDataHandler &pMem, 
00111                                     ValueTypeT        &oObject)
00112     {
00113         pMem.getValues(&oObject[0], ValueTypeT::_iSize);
00114     }
00115 
00116     static void   copyFromBin(      BinaryDataHandler &pMem, 
00117                                     ValueTypeT        *pObjectStore,
00118                                     UInt32             uiNumObjects)
00119     {
00120         pMem.getValues(&pObjectStore[0][0], ValueTypeT::_iSize*uiNumObjects);
00121     }
00122 };
00123 
00124 #if defined(__hpuxX)
00125 template<class ValueTypeT> 
00126 const UInt32 FieldTraitsRecurseVecStoreBase<ValueTypeT>::uiTest;
00127 #endif
00128 
00131 #if !defined(OSG_DOC_DEV_TRAITS)
00132 
00133 #endif
00134 
00135 template<class ValueTypeT>
00136 struct FieldTraitsRecurseVecStore2Base : 
00137     public FieldTraitsRecurseVecStoreBase<ValueTypeT> 
00138 {
00139     enum               { bHasParent = 0x00 };
00140 };
00141 
00144 #if !defined(OSG_DOC_DEV_TRAITS)
00145 
00146 #endif
00147 
00148 template<class ValueTypeT>
00149 struct FieldTraitsRecurseVecStore3Base : 
00150     public FieldTraitsRecurseVecStoreBase<ValueTypeT>
00151 {
00152     enum              { bHasParent = 0x00 };
00153 };
00154 
00157 #if !defined(OSG_DOC_DEV_TRAITS)
00158 
00159 #endif
00160 
00161 template<class ValueTypeT>
00162 struct FieldTraitsRecurseVecStore4Base : 
00163     public FieldTraitsRecurseVecStoreBase<ValueTypeT>
00164 {
00165     enum              { bHasParent = 0x00 };
00166 };
00167 
00168 
00171 #if !defined(OSG_DOC_DEV_TRAITS)
00172 
00173 #endif
00174 
00175 template <>
00176 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2ub> :
00177     public FieldTraitsRecurseVecStore2Base<Vec2ub>
00178 {
00179     static  DataType                _type;
00180     typedef FieldDataTraits<Vec2ub>  Self;
00181 
00182 
00183     enum             { StringConvertable = Self::ToStringConvertable   | 
00184                                            Self::FromStringConvertable };
00185 
00186     enum             { bHasParent        = 0x01                        };
00187 
00188     static DataType &getType      (void) { return _type;               }
00189 
00190     static Char8    *getSName     (void) { return "SFVec2ub";           }
00191     static Char8    *getMName     (void) { return "MFVec2ub";           }
00192 
00193     static Vec2ub    getDefault   (void) { return Vec2ub();             }
00194 
00195     static bool      getFromString(      Vec2ub  &outVal,
00196                                    const Char8 *&inVal)
00197     {
00198         outVal.setValueFromCString(inVal);
00199         
00200         return true;
00201     }
00202 
00203     static void      putToString  (const      Vec2ub &inVal,
00204                                          std::string &outStr)
00205     {
00206         typedef TypeTraits<Vec2ub::ValueType> TypeTrait;
00207         
00208         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00209         outStr.append("  ");
00210         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00211     }
00212 };
00213 
00214 #if !defined(OSG_DOC_DEV_TRAITS)
00215 
00217 #endif
00218 
00221 #if !defined(OSG_DOC_DEV_TRAITS)
00222 
00223 #endif
00224 
00225 template <>
00226 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3ub> :
00227     public FieldTraitsRecurseVecStore2Base<Vec3ub>
00228 {
00229     static  DataType                _type;
00230     typedef FieldDataTraits<Vec3ub>  Self;
00231 
00232 
00233     enum             { StringConvertable = Self::ToStringConvertable   | 
00234                                            Self::FromStringConvertable };
00235 
00236     enum             { bHasParent        = 0x01                        };
00237 
00238     static DataType &getType      (void) { return _type;               }
00239 
00240     static Char8    *getSName     (void) { return "SFVec3ub";           }
00241     static Char8    *getMName     (void) { return "MFVec3ub";           }
00242 
00243     static Vec3ub    getDefault   (void) { return Vec3ub();             }
00244 
00245     static bool      getFromString(      Vec3ub  &outVal,
00246                                    const Char8 *&inVal)
00247     {
00248         outVal.setValueFromCString(inVal);
00249         
00250         return true;
00251     }
00252 
00253     static void      putToString  (const      Vec3ub &inVal,
00254                                          std::string &outStr)
00255     {
00256         typedef TypeTraits<Vec3ub::ValueType> TypeTrait;
00257         
00258         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00259         outStr.append("  ");
00260         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00261         outStr.append("  ");
00262         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00263     }
00264 };
00265 
00266 #if !defined(OSG_DOC_DEV_TRAITS)
00267 
00269 #endif
00270 
00273 #if !defined(OSG_DOC_DEV_TRAITS)
00274 
00275 #endif
00276 
00277 template <>
00278 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4ub> :
00279     public FieldTraitsRecurseVecStore2Base<Vec4ub>
00280 {
00281     static  DataType                _type;
00282     typedef FieldDataTraits<Vec4ub>  Self;
00283 
00284 
00285     enum             { StringConvertable = Self::ToStringConvertable   | 
00286                                            Self::FromStringConvertable };
00287 
00288     enum             { bHasParent        = 0x01                        };
00289 
00290     static DataType &getType      (void) { return _type;               }
00291 
00292     static Char8    *getSName     (void) { return "SFVec4ub";           }
00293     static Char8    *getMName     (void) { return "MFVec4ub";           }
00294 
00295     static Vec4ub    getDefault   (void) { return Vec4ub();             }
00296 
00297     static bool      getFromString(      Vec4ub  &outVal,
00298                                    const Char8  *&inVal)
00299     {
00300         outVal.setValueFromCString(inVal);
00301         
00302         return true;
00303     }
00304 
00305     static void      putToString  (const      Vec4ub &inVal,
00306                                          std::string &outStr)
00307     {
00308         typedef TypeTraits<Vec4ub::ValueType> TypeTrait;
00309         
00310         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00311         outStr.append("  ");
00312         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00313         outStr.append("  ");
00314         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00315         outStr.append("  ");
00316         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
00317     }
00318 };
00319 
00320 #if !defined(OSG_DOC_DEV_TRAITS)
00321 
00323 #endif
00324 
00325 
00326 
00327 #ifndef OSG_NO_INT8_PNT
00328 
00330 #if !defined(OSG_DOC_DEV_TRAITS)
00331 
00332 #endif
00333 
00334 template <>
00335 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2b> :
00336     public FieldTraitsRecurseVecStore2Base<Vec2b>
00337 {
00338     static  DataType                _type;
00339     typedef FieldDataTraits<Vec2b>  Self;
00340 
00341 
00342     enum             { StringConvertable = Self::ToStringConvertable   | 
00343                                            Self::FromStringConvertable };
00344 
00345     enum             { bHasParent        = 0x01                        };
00346 
00347     static DataType &getType      (void) { return _type;               }
00348 
00349     static Char8    *getSName     (void) { return "SFVec2b";           }
00350     static Char8    *getMName     (void) { return "MFVec2b";           }
00351 
00352     static Vec2b    getDefault   (void) { return Vec2b();             }
00353 
00354     static bool      getFromString(      Vec2b  &outVal,
00355                                    const Char8 *&inVal)
00356     {
00357         outVal.setValueFromCString(inVal);
00358         
00359         return true;
00360     }
00361 
00362     static void      putToString  (const      Vec2b &inVal,
00363                                          std::string &outStr)
00364     {
00365         typedef TypeTraits<Vec2b::ValueType> TypeTrait;
00366         
00367         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00368         outStr.append("  ");
00369         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00370     }
00371 };
00372 
00373 #if !defined(OSG_DOC_DEV_TRAITS)
00374 
00376 #endif
00377 
00380 #if !defined(OSG_DOC_DEV_TRAITS)
00381 
00382 #endif
00383 
00384 template <>
00385 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3b> :
00386     public FieldTraitsRecurseVecStore2Base<Vec3b>
00387 {
00388     static  DataType                _type;
00389     typedef FieldDataTraits<Vec3b>  Self;
00390 
00391 
00392     enum             { StringConvertable = Self::ToStringConvertable   | 
00393                                            Self::FromStringConvertable };
00394 
00395     enum             { bHasParent        = 0x01                        };
00396 
00397     static DataType &getType      (void) { return _type;               }
00398 
00399     static Char8    *getSName     (void) { return "SFVec3b";           }
00400     static Char8    *getMName     (void) { return "MFVec3b";           }
00401 
00402     static Vec3b    getDefault   (void) { return Vec3b();             }
00403 
00404     static bool      getFromString(      Vec3b  &outVal,
00405                                    const Char8 *&inVal)
00406     {
00407         outVal.setValueFromCString(inVal);
00408         
00409         return true;
00410     }
00411 
00412     static void      putToString  (const      Vec3b &inVal,
00413                                          std::string &outStr)
00414     {
00415         typedef TypeTraits<Vec3b::ValueType> TypeTrait;
00416         
00417         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00418         outStr.append("  ");
00419         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00420         outStr.append("  ");
00421         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00422     }
00423 };
00424 
00425 #if !defined(OSG_DOC_DEV_TRAITS)
00426 
00428 #endif
00429 
00432 #if !defined(OSG_DOC_DEV_TRAITS)
00433 
00434 #endif
00435 
00436 template <>
00437 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4b> :
00438     public FieldTraitsRecurseVecStore2Base<Vec4b>
00439 {
00440     static  DataType                _type;
00441     typedef FieldDataTraits<Vec4b>  Self;
00442 
00443 
00444     enum             { StringConvertable = Self::ToStringConvertable   | 
00445                                            Self::FromStringConvertable };
00446 
00447     enum             { bHasParent        = 0x01                        };
00448 
00449     static DataType &getType      (void) { return _type;               }
00450 
00451     static Char8    *getSName     (void) { return "SFVec4b";           }
00452     static Char8    *getMName     (void) { return "MFVec4b";           }
00453 
00454     static Vec4b    getDefault   (void) { return Vec4b();             }
00455 
00456     static bool      getFromString(      Vec4b  &outVal,
00457                                    const Char8  *&inVal)
00458     {
00459         outVal.setValueFromCString(inVal);
00460         
00461         return true;
00462     }
00463 
00464     static void      putToString  (const      Vec4b &inVal,
00465                                          std::string &outStr)
00466     {
00467         typedef TypeTraits<Vec4b::ValueType> TypeTrait;
00468         
00469         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00470         outStr.append("  ");
00471         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00472         outStr.append("  ");
00473         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00474         outStr.append("  ");
00475         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
00476     }
00477 };
00478 
00479 #if !defined(OSG_DOC_DEV_TRAITS)
00480 
00482 #endif
00483 #endif
00484 
00485 
00488 #if !defined(OSG_DOC_DEV_TRAITS)
00489 
00490 #endif
00491 
00492 template <>
00493 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2us> :
00494     public FieldTraitsRecurseVecStore2Base<Vec2us>
00495 {
00496     static  DataType                _type;
00497     typedef FieldDataTraits<Vec2us>  Self;
00498 
00499 
00500     enum             { StringConvertable = Self::ToStringConvertable   | 
00501                                            Self::FromStringConvertable };
00502 
00503     enum             { bHasParent        = 0x01                        };
00504 
00505     static DataType &getType      (void) { return _type;               }
00506 
00507     static Char8    *getSName     (void) { return "SFVec2us";           }
00508     static Char8    *getMName     (void) { return "MFVec2us";           }
00509 
00510     static Vec2us    getDefault   (void) { return Vec2us();             }
00511 
00512     static bool      getFromString(      Vec2us  &outVal,
00513                                    const Char8 *&inVal)
00514     {
00515         outVal.setValueFromCString(inVal);
00516         
00517         return true;
00518     }
00519 
00520     static void      putToString  (const      Vec2us &inVal,
00521                                          std::string &outStr)
00522     {
00523         typedef TypeTraits<Vec2us::ValueType> TypeTrait;
00524         
00525         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00526         outStr.append("  ");
00527         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00528     }
00529 };
00530 
00531 #if !defined(OSG_DOC_DEV_TRAITS)
00532 
00534 #endif
00535 
00538 #if !defined(OSG_DOC_DEV_TRAITS)
00539 
00540 #endif
00541 
00542 template <>
00543 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3us> :
00544     public FieldTraitsRecurseVecStore2Base<Vec3us>
00545 {
00546     static  DataType                _type;
00547     typedef FieldDataTraits<Vec3us>  Self;
00548 
00549 
00550     enum             { StringConvertable = Self::ToStringConvertable   | 
00551                                            Self::FromStringConvertable };
00552 
00553     enum             { bHasParent        = 0x01                        };
00554 
00555     static DataType &getType      (void) { return _type;               }
00556 
00557     static Char8    *getSName     (void) { return "SFVec3us";           }
00558     static Char8    *getMName     (void) { return "MFVec3us";           }
00559 
00560     static Vec3us    getDefault   (void) { return Vec3us();             }
00561 
00562     static bool      getFromString(      Vec3us  &outVal,
00563                                    const Char8 *&inVal)
00564     {
00565         outVal.setValueFromCString(inVal);
00566         
00567         return true;
00568     }
00569 
00570     static void      putToString  (const      Vec3us &inVal,
00571                                          std::string &outStr)
00572     {
00573         typedef TypeTraits<Vec3us::ValueType> TypeTrait;
00574         
00575         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00576         outStr.append("  ");
00577         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00578         outStr.append("  ");
00579         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00580     }
00581 };
00582 
00583 #if !defined(OSG_DOC_DEV_TRAITS)
00584 
00586 #endif
00587 
00590 #if !defined(OSG_DOC_DEV_TRAITS)
00591 
00592 #endif
00593 
00594 template <>
00595 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4us> :
00596     public FieldTraitsRecurseVecStore2Base<Vec4us>
00597 {
00598     static  DataType                _type;
00599     typedef FieldDataTraits<Vec4us>  Self;
00600 
00601 
00602     enum             { StringConvertable = Self::ToStringConvertable   | 
00603                                            Self::FromStringConvertable };
00604 
00605     enum             { bHasParent        = 0x01                        };
00606 
00607     static DataType &getType      (void) { return _type;               }
00608 
00609     static Char8    *getSName     (void) { return "SFVec4us";           }
00610     static Char8    *getMName     (void) { return "MFVec4us";           }
00611 
00612     static Vec4us    getDefault   (void) { return Vec4us();             }
00613 
00614     static bool      getFromString(      Vec4us  &outVal,
00615                                    const Char8  *&inVal)
00616     {
00617         outVal.setValueFromCString(inVal);
00618         
00619         return true;
00620     }
00621 
00622     static void      putToString  (const      Vec4us &inVal,
00623                                          std::string &outStr)
00624     {
00625         typedef TypeTraits<Vec4us::ValueType> TypeTrait;
00626         
00627         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00628         outStr.append("  ");
00629         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00630         outStr.append("  ");
00631         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00632         outStr.append("  ");
00633         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
00634     }
00635 };
00636 
00637 #if !defined(OSG_DOC_DEV_TRAITS)
00638 
00640 #endif
00641 
00642 
00643 
00646 #if !defined(OSG_DOC_DEV_TRAITS)
00647 
00648 #endif
00649 
00650 template <>
00651 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2s> :
00652     public FieldTraitsRecurseVecStore2Base<Vec2s>
00653 {
00654     static  DataType                _type;
00655     typedef FieldDataTraits<Vec2s>  Self;
00656 
00657 
00658     enum             { StringConvertable = Self::ToStringConvertable   | 
00659                                            Self::FromStringConvertable };
00660 
00661     enum             { bHasParent        = 0x01                        };
00662 
00663     static DataType &getType      (void) { return _type;               }
00664 
00665     static Char8    *getSName     (void) { return "SFVec2s";           }
00666     static Char8    *getMName     (void) { return "MFVec2s";           }
00667 
00668     static Vec2s    getDefault   (void) { return Vec2s();             }
00669 
00670     static bool      getFromString(      Vec2s  &outVal,
00671                                    const Char8 *&inVal)
00672     {
00673         outVal.setValueFromCString(inVal);
00674         
00675         return true;
00676     }
00677 
00678     static void      putToString  (const      Vec2s &inVal,
00679                                          std::string &outStr)
00680     {
00681         typedef TypeTraits<Vec2s::ValueType> TypeTrait;
00682         
00683         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00684         outStr.append("  ");
00685         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00686     }
00687 };
00688 
00689 #if !defined(OSG_DOC_DEV_TRAITS)
00690 
00692 #endif
00693 
00696 #if !defined(OSG_DOC_DEV_TRAITS)
00697 
00698 #endif
00699 
00700 template <>
00701 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3s> :
00702     public FieldTraitsRecurseVecStore2Base<Vec3s>
00703 {
00704     static  DataType                _type;
00705     typedef FieldDataTraits<Vec3s>  Self;
00706 
00707 
00708     enum             { StringConvertable = Self::ToStringConvertable   | 
00709                                            Self::FromStringConvertable };
00710 
00711     enum             { bHasParent        = 0x01                        };
00712 
00713     static DataType &getType      (void) { return _type;               }
00714 
00715     static Char8    *getSName     (void) { return "SFVec3s";           }
00716     static Char8    *getMName     (void) { return "MFVec3s";           }
00717 
00718     static Vec3s    getDefault   (void) { return Vec3s();             }
00719 
00720     static bool      getFromString(      Vec3s  &outVal,
00721                                    const Char8 *&inVal)
00722     {
00723         outVal.setValueFromCString(inVal);
00724         
00725         return true;
00726     }
00727 
00728     static void      putToString  (const      Vec3s &inVal,
00729                                          std::string &outStr)
00730     {
00731         typedef TypeTraits<Vec3s::ValueType> TypeTrait;
00732         
00733         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00734         outStr.append("  ");
00735         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00736         outStr.append("  ");
00737         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00738     }
00739 };
00740 
00741 #if !defined(OSG_DOC_DEV_TRAITS)
00742 
00744 #endif
00745 
00748 #if !defined(OSG_DOC_DEV_TRAITS)
00749 
00750 #endif
00751 
00752 template <>
00753 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4s> :
00754     public FieldTraitsRecurseVecStore2Base<Vec4s>
00755 {
00756     static  DataType                _type;
00757     typedef FieldDataTraits<Vec4s>  Self;
00758 
00759 
00760     enum             { StringConvertable = Self::ToStringConvertable   | 
00761                                            Self::FromStringConvertable };
00762 
00763     enum             { bHasParent        = 0x01                        };
00764 
00765     static DataType &getType      (void) { return _type;               }
00766 
00767     static Char8    *getSName     (void) { return "SFVec4s";           }
00768     static Char8    *getMName     (void) { return "MFVec4s";           }
00769 
00770     static Vec4s    getDefault   (void) { return Vec4s();             }
00771 
00772     static bool      getFromString(      Vec4s  &outVal,
00773                                    const Char8  *&inVal)
00774     {
00775         outVal.setValueFromCString(inVal);
00776         
00777         return true;
00778     }
00779 
00780     static void      putToString  (const      Vec4s &inVal,
00781                                          std::string &outStr)
00782     {
00783         typedef TypeTraits<Vec4s::ValueType> TypeTrait;
00784         
00785         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00786         outStr.append("  ");
00787         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00788         outStr.append("  ");
00789         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00790         outStr.append("  ");
00791         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
00792     }
00793 };
00794 
00795 #if !defined(OSG_DOC_DEV_TRAITS)
00796 
00798 #endif
00799 
00800 
00801 
00804 #if !defined(OSG_DOC_DEV_TRAITS)
00805 
00806 #endif
00807 
00808 template <>
00809 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2f> :
00810     public FieldTraitsRecurseVecStore2Base<Vec2f>
00811 {
00812     static  DataType                _type;
00813     typedef FieldDataTraits<Vec2f>  Self;
00814 
00815 
00816     enum             { StringConvertable = Self::ToStringConvertable   | 
00817                                            Self::FromStringConvertable };
00818 
00819     enum             { bHasParent        = 0x01                        };
00820 
00821     static DataType &getType      (void) { return _type;               }
00822 
00823     static Char8    *getSName     (void) { return "SFVec2f";           }
00824     static Char8    *getMName     (void) { return "MFVec2f";           }
00825 
00826     static Vec2f    getDefault   (void) { return Vec2f();             }
00827 
00828     static bool      getFromString(      Vec2f  &outVal,
00829                                    const Char8 *&inVal)
00830     {
00831         outVal.setValueFromCString(inVal);
00832         
00833         return true;
00834     }
00835 
00836     static void      putToString  (const      Vec2f &inVal,
00837                                          std::string &outStr)
00838     {
00839         typedef TypeTraits<Vec2f::ValueType> TypeTrait;
00840         
00841         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00842         outStr.append("  ");
00843         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00844     }
00845 };
00846 
00847 #if !defined(OSG_DOC_DEV_TRAITS)
00848 
00850 #endif
00851 
00854 #if !defined(OSG_DOC_DEV_TRAITS)
00855 
00856 #endif
00857 
00858 template <>
00859 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3f> :
00860     public FieldTraitsRecurseVecStore2Base<Vec3f>
00861 {
00862     static  DataType                _type;
00863     typedef FieldDataTraits<Vec3f>  Self;
00864 
00865 
00866     enum             { StringConvertable = Self::ToStringConvertable   | 
00867                                            Self::FromStringConvertable };
00868 
00869     enum             { bHasParent        = 0x01                        };
00870 
00871     static DataType &getType      (void) { return _type;               }
00872 
00873     static Char8    *getSName     (void) { return "SFVec3f";           }
00874     static Char8    *getMName     (void) { return "MFVec3f";           }
00875 
00876     static Vec3f    getDefault   (void) { return Vec3f();             }
00877 
00878     static bool      getFromString(      Vec3f  &outVal,
00879                                    const Char8 *&inVal)
00880     {
00881         outVal.setValueFromCString(inVal);
00882         
00883         return true;
00884     }
00885 
00886     static void      putToString  (const      Vec3f &inVal,
00887                                          std::string &outStr)
00888     {
00889         typedef TypeTraits<Vec3f::ValueType> TypeTrait;
00890         
00891         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00892         outStr.append("  ");
00893         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00894         outStr.append("  ");
00895         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00896     }
00897 };
00898 
00899 #if !defined(OSG_DOC_DEV_TRAITS)
00900 
00902 #endif
00903 
00906 #if !defined(OSG_DOC_DEV_TRAITS)
00907 
00908 #endif
00909 
00910 template <>
00911 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4f> :
00912     public FieldTraitsRecurseVecStore2Base<Vec4f>
00913 {
00914     static  DataType                _type;
00915     typedef FieldDataTraits<Vec4f>  Self;
00916 
00917 
00918     enum             { StringConvertable = Self::ToStringConvertable   | 
00919                                            Self::FromStringConvertable };
00920 
00921     enum             { bHasParent        = 0x01                        };
00922 
00923     static DataType &getType      (void) { return _type;               }
00924 
00925     static Char8    *getSName     (void) { return "SFVec4f";           }
00926     static Char8    *getMName     (void) { return "MFVec4f";           }
00927 
00928     static Vec4f    getDefault   (void) { return Vec4f();             }
00929 
00930     static bool      getFromString(      Vec4f  &outVal,
00931                                    const Char8  *&inVal)
00932     {
00933         outVal.setValueFromCString(inVal);
00934         
00935         return true;
00936     }
00937 
00938     static void      putToString  (const      Vec4f &inVal,
00939                                          std::string &outStr)
00940     {
00941         typedef TypeTraits<Vec4f::ValueType> TypeTrait;
00942         
00943         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
00944         outStr.append("  ");
00945         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
00946         outStr.append("  ");
00947         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
00948         outStr.append("  ");
00949         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
00950     }
00951 };
00952 
00953 #if !defined(OSG_DOC_DEV_TRAITS)
00954 
00956 #endif
00957 
00958 
00959 
00962 #if !defined(OSG_DOC_DEV_TRAITS)
00963 
00964 #endif
00965 
00966 template <>
00967 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2d> :
00968     public FieldTraitsRecurseVecStore2Base<Vec2d>
00969 {
00970     static  DataType                _type;
00971     typedef FieldDataTraits<Vec2d>  Self;
00972 
00973 
00974     enum             { StringConvertable = Self::ToStringConvertable   | 
00975                                            Self::FromStringConvertable };
00976 
00977     enum             { bHasParent        = 0x01                        };
00978 
00979     static DataType &getType      (void) { return _type;               }
00980 
00981     static Char8    *getSName     (void) { return "SFVec2d";           }
00982     static Char8    *getMName     (void) { return "MFVec2d";           }
00983 
00984     static Vec2d    getDefault   (void) { return Vec2d();             }
00985 
00986     static bool      getFromString(      Vec2d  &outVal,
00987                                    const Char8 *&inVal)
00988     {
00989         outVal.setValueFromCString(inVal);
00990         
00991         return true;
00992     }
00993 
00994     static void      putToString  (const      Vec2d &inVal,
00995                                          std::string &outStr)
00996     {
00997         typedef TypeTraits<Vec2d::ValueType> TypeTrait;
00998         
00999         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01000         outStr.append("  ");
01001         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01002     }
01003 };
01004 
01005 #if !defined(OSG_DOC_DEV_TRAITS)
01006 
01008 #endif
01009 
01012 #if !defined(OSG_DOC_DEV_TRAITS)
01013 
01014 #endif
01015 
01016 template <>
01017 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3d> :
01018     public FieldTraitsRecurseVecStore2Base<Vec3d>
01019 {
01020     static  DataType                _type;
01021     typedef FieldDataTraits<Vec3d>  Self;
01022 
01023 
01024     enum             { StringConvertable = Self::ToStringConvertable   | 
01025                                            Self::FromStringConvertable };
01026 
01027     enum             { bHasParent        = 0x01                        };
01028 
01029     static DataType &getType      (void) { return _type;               }
01030 
01031     static Char8    *getSName     (void) { return "SFVec3d";           }
01032     static Char8    *getMName     (void) { return "MFVec3d";           }
01033 
01034     static Vec3d    getDefault   (void) { return Vec3d();             }
01035 
01036     static bool      getFromString(      Vec3d  &outVal,
01037                                    const Char8 *&inVal)
01038     {
01039         outVal.setValueFromCString(inVal);
01040         
01041         return true;
01042     }
01043 
01044     static void      putToString  (const      Vec3d &inVal,
01045                                          std::string &outStr)
01046     {
01047         typedef TypeTraits<Vec3d::ValueType> TypeTrait;
01048         
01049         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01050         outStr.append("  ");
01051         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01052         outStr.append("  ");
01053         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01054     }
01055 };
01056 
01057 #if !defined(OSG_DOC_DEV_TRAITS)
01058 
01060 #endif
01061 
01064 #if !defined(OSG_DOC_DEV_TRAITS)
01065 
01066 #endif
01067 
01068 template <>
01069 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4d> :
01070     public FieldTraitsRecurseVecStore2Base<Vec4d>
01071 {
01072     static  DataType                _type;
01073     typedef FieldDataTraits<Vec4d>  Self;
01074 
01075 
01076     enum             { StringConvertable = Self::ToStringConvertable   | 
01077                                            Self::FromStringConvertable };
01078 
01079     enum             { bHasParent        = 0x01                        };
01080 
01081     static DataType &getType      (void) { return _type;               }
01082 
01083     static Char8    *getSName     (void) { return "SFVec4d";           }
01084     static Char8    *getMName     (void) { return "MFVec4d";           }
01085 
01086     static Vec4d    getDefault   (void) { return Vec4d();             }
01087 
01088     static bool      getFromString(      Vec4d  &outVal,
01089                                    const Char8  *&inVal)
01090     {
01091         outVal.setValueFromCString(inVal);
01092         
01093         return true;
01094     }
01095 
01096     static void      putToString  (const      Vec4d &inVal,
01097                                          std::string &outStr)
01098     {
01099         typedef TypeTraits<Vec4d::ValueType> TypeTrait;
01100         
01101         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01102         outStr.append("  ");
01103         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01104         outStr.append("  ");
01105         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01106         outStr.append("  ");
01107         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01108     }
01109 };
01110 
01111 #if !defined(OSG_DOC_DEV_TRAITS)
01112 
01114 #endif
01115 
01116 
01117 
01120 #if !defined(OSG_DOC_DEV_TRAITS)
01121 
01122 #endif
01123 
01124 template <>
01125 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec2ld> :
01126     public FieldTraitsRecurseVecStore2Base<Vec2ld>
01127 {
01128     static  DataType                _type;
01129     typedef FieldDataTraits<Vec2ld>  Self;
01130 
01131 
01132     enum             { StringConvertable = Self::ToStringConvertable   | 
01133                                            Self::FromStringConvertable };
01134 
01135     enum             { bHasParent        = 0x01                        };
01136 
01137     static DataType &getType      (void) { return _type;               }
01138 
01139     static Char8    *getSName     (void) { return "SFVec2ld";           }
01140     static Char8    *getMName     (void) { return "MFVec2ld";           }
01141 
01142     static Vec2ld    getDefault   (void) { return Vec2ld();             }
01143 
01144     static bool      getFromString(      Vec2ld  &outVal,
01145                                    const Char8 *&inVal)
01146     {
01147         outVal.setValueFromCString(inVal);
01148         
01149         return true;
01150     }
01151 
01152     static void      putToString  (const      Vec2ld &inVal,
01153                                          std::string &outStr)
01154     {
01155         typedef TypeTraits<Vec2ld::ValueType> TypeTrait;
01156         
01157         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01158         outStr.append("  ");
01159         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01160     }
01161 };
01162 
01163 #if !defined(OSG_DOC_DEV_TRAITS)
01164 
01166 #endif
01167 
01170 #if !defined(OSG_DOC_DEV_TRAITS)
01171 
01172 #endif
01173 
01174 template <>
01175 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec3ld> :
01176     public FieldTraitsRecurseVecStore2Base<Vec3ld>
01177 {
01178     static  DataType                _type;
01179     typedef FieldDataTraits<Vec3ld>  Self;
01180 
01181 
01182     enum             { StringConvertable = Self::ToStringConvertable   | 
01183                                            Self::FromStringConvertable };
01184 
01185     enum             { bHasParent        = 0x01                        };
01186 
01187     static DataType &getType      (void) { return _type;               }
01188 
01189     static Char8    *getSName     (void) { return "SFVec3ld";           }
01190     static Char8    *getMName     (void) { return "MFVec3ld";           }
01191 
01192     static Vec3ld    getDefault   (void) { return Vec3ld();             }
01193 
01194     static bool      getFromString(      Vec3ld  &outVal,
01195                                    const Char8 *&inVal)
01196     {
01197         outVal.setValueFromCString(inVal);
01198         
01199         return true;
01200     }
01201 
01202     static void      putToString  (const      Vec3ld &inVal,
01203                                          std::string &outStr)
01204     {
01205         typedef TypeTraits<Vec3ld::ValueType> TypeTrait;
01206         
01207         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01208         outStr.append("  ");
01209         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01210         outStr.append("  ");
01211         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01212     }
01213 };
01214 
01215 #if !defined(OSG_DOC_DEV_TRAITS)
01216 
01218 #endif
01219 
01222 #if !defined(OSG_DOC_DEV_TRAITS)
01223 
01224 #endif
01225 
01226 template <>
01227 struct OSG_BASE_DLLMAPPING FieldDataTraits<Vec4ld> :
01228     public FieldTraitsRecurseVecStore2Base<Vec4ld>
01229 {
01230     static  DataType                _type;
01231     typedef FieldDataTraits<Vec4ld>  Self;
01232 
01233 
01234     enum             { StringConvertable = Self::ToStringConvertable   | 
01235                                            Self::FromStringConvertable };
01236 
01237     enum             { bHasParent        = 0x01                        };
01238 
01239     static DataType &getType      (void) { return _type;               }
01240 
01241     static Char8    *getSName     (void) { return "SFVec4ld";           }
01242     static Char8    *getMName     (void) { return "MFVec4ld";           }
01243 
01244     static Vec4ld    getDefault   (void) { return Vec4ld();             }
01245 
01246     static bool      getFromString(      Vec4ld  &outVal,
01247                                    const Char8  *&inVal)
01248     {
01249         outVal.setValueFromCString(inVal);
01250         
01251         return true;
01252     }
01253 
01254     static void      putToString  (const      Vec4ld &inVal,
01255                                          std::string &outStr)
01256     {
01257         typedef TypeTraits<Vec4ld::ValueType> TypeTrait;
01258         
01259         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01260         outStr.append("  ");
01261         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01262         outStr.append("  ");
01263         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01264         outStr.append("  ");
01265         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01266     }
01267 };
01268 
01269 #if !defined(OSG_DOC_DEV_TRAITS)
01270 
01272 #endif
01273 
01274 
01275 
01278 #if !defined(OSG_DOC_DEV_TRAITS)
01279 
01280 #endif
01281 
01282 template <>
01283 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2ub> :
01284     public FieldTraitsRecurseVecStore2Base<Pnt2ub>
01285 {
01286     static  DataType                _type;
01287     typedef FieldDataTraits<Pnt2ub>  Self;
01288 
01289 
01290     enum             { StringConvertable = Self::ToStringConvertable   | 
01291                                            Self::FromStringConvertable };
01292 
01293     enum             { bHasParent        = 0x01                        };
01294 
01295     static DataType &getType      (void) { return _type;               }
01296 
01297     static Char8    *getSName     (void) { return "SFPnt2ub";           }
01298     static Char8    *getMName     (void) { return "MFPnt2ub";           }
01299 
01300     static Pnt2ub    getDefault   (void) { return Pnt2ub();             }
01301 
01302     static bool      getFromString(      Pnt2ub  &outVal,
01303                                    const Char8 *&inVal)
01304     {
01305         outVal.setValueFromCString(inVal);
01306         
01307         return true;
01308     }
01309 
01310     static void      putToString  (const      Pnt2ub &inVal,
01311                                          std::string &outStr)
01312     {
01313         typedef TypeTraits<Pnt2ub::ValueType> TypeTrait;
01314         
01315         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01316         outStr.append("  ");
01317         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01318     }
01319 };
01320 
01321 #if !defined(OSG_DOC_DEV_TRAITS)
01322 
01324 #endif
01325 
01328 #if !defined(OSG_DOC_DEV_TRAITS)
01329 
01330 #endif
01331 
01332 template <>
01333 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3ub> :
01334     public FieldTraitsRecurseVecStore2Base<Pnt3ub>
01335 {
01336     static  DataType                _type;
01337     typedef FieldDataTraits<Pnt3ub>  Self;
01338 
01339 
01340     enum             { StringConvertable = Self::ToStringConvertable   | 
01341                                            Self::FromStringConvertable };
01342 
01343     enum             { bHasParent        = 0x01                        };
01344 
01345     static DataType &getType      (void) { return _type;               }
01346 
01347     static Char8    *getSName     (void) { return "SFPnt3ub";           }
01348     static Char8    *getMName     (void) { return "MFPnt3ub";           }
01349 
01350     static Pnt3ub    getDefault   (void) { return Pnt3ub();             }
01351 
01352     static bool      getFromString(      Pnt3ub  &outVal,
01353                                    const Char8 *&inVal)
01354     {
01355         outVal.setValueFromCString(inVal);
01356         
01357         return true;
01358     }
01359 
01360     static void      putToString  (const      Pnt3ub &inVal,
01361                                          std::string &outStr)
01362     {
01363         typedef TypeTraits<Pnt3ub::ValueType> TypeTrait;
01364         
01365         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01366         outStr.append("  ");
01367         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01368         outStr.append("  ");
01369         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01370     }
01371 };
01372 
01373 #if !defined(OSG_DOC_DEV_TRAITS)
01374 
01376 #endif
01377 
01380 #if !defined(OSG_DOC_DEV_TRAITS)
01381 
01382 #endif
01383 
01384 template <>
01385 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4ub> :
01386     public FieldTraitsRecurseVecStore2Base<Pnt4ub>
01387 {
01388     static  DataType                _type;
01389     typedef FieldDataTraits<Pnt4ub>  Self;
01390 
01391 
01392     enum             { StringConvertable = Self::ToStringConvertable   | 
01393                                            Self::FromStringConvertable };
01394 
01395     enum             { bHasParent        = 0x01                        };
01396 
01397     static DataType &getType      (void) { return _type;               }
01398 
01399     static Char8    *getSName     (void) { return "SFPnt4ub";           }
01400     static Char8    *getMName     (void) { return "MFPnt4ub";           }
01401 
01402     static Pnt4ub    getDefault   (void) { return Pnt4ub();             }
01403 
01404     static bool      getFromString(      Pnt4ub  &outVal,
01405                                    const Char8  *&inVal)
01406     {
01407         outVal.setValueFromCString(inVal);
01408         
01409         return true;
01410     }
01411 
01412     static void      putToString  (const      Pnt4ub &inVal,
01413                                          std::string &outStr)
01414     {
01415         typedef TypeTraits<Pnt4ub::ValueType> TypeTrait;
01416         
01417         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01418         outStr.append("  ");
01419         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01420         outStr.append("  ");
01421         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01422         outStr.append("  ");
01423         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01424     }
01425 };
01426 
01427 #if !defined(OSG_DOC_DEV_TRAITS)
01428 
01430 #endif
01431 
01432 
01433 #ifndef OSG_NO_INT8_PNT
01434 
01436 #if !defined(OSG_DOC_DEV_TRAITS)
01437 
01438 #endif
01439 
01440 template <>
01441 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2b> :
01442     public FieldTraitsRecurseVecStore2Base<Pnt2b>
01443 {
01444     static  DataType                _type;
01445     typedef FieldDataTraits<Pnt2b>  Self;
01446 
01447 
01448     enum             { StringConvertable = Self::ToStringConvertable   | 
01449                                            Self::FromStringConvertable };
01450 
01451     enum             { bHasParent        = 0x01                        };
01452 
01453     static DataType &getType      (void) { return _type;               }
01454 
01455     static Char8    *getSName     (void) { return "SFPnt2b";           }
01456     static Char8    *getMName     (void) { return "MFPnt2b";           }
01457 
01458     static Pnt2b    getDefault   (void) { return Pnt2b();             }
01459 
01460     static bool      getFromString(      Pnt2b  &outVal,
01461                                    const Char8 *&inVal)
01462     {
01463         outVal.setValueFromCString(inVal);
01464         
01465         return true;
01466     }
01467 
01468     static void      putToString  (const      Pnt2b &inVal,
01469                                          std::string &outStr)
01470     {
01471         typedef TypeTraits<Pnt2b::ValueType> TypeTrait;
01472         
01473         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01474         outStr.append("  ");
01475         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01476     }
01477 };
01478 
01479 #if !defined(OSG_DOC_DEV_TRAITS)
01480 
01482 #endif
01483 
01486 #if !defined(OSG_DOC_DEV_TRAITS)
01487 
01488 #endif
01489 
01490 template <>
01491 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3b> :
01492     public FieldTraitsRecurseVecStore2Base<Pnt3b>
01493 {
01494     static  DataType                _type;
01495     typedef FieldDataTraits<Pnt3b>  Self;
01496 
01497 
01498     enum             { StringConvertable = Self::ToStringConvertable   | 
01499                                            Self::FromStringConvertable };
01500 
01501     enum             { bHasParent        = 0x01                        };
01502 
01503     static DataType &getType      (void) { return _type;               }
01504 
01505     static Char8    *getSName     (void) { return "SFPnt3b";           }
01506     static Char8    *getMName     (void) { return "MFPnt3b";           }
01507 
01508     static Pnt3b    getDefault   (void) { return Pnt3b();             }
01509 
01510     static bool      getFromString(      Pnt3b  &outVal,
01511                                    const Char8 *&inVal)
01512     {
01513         outVal.setValueFromCString(inVal);
01514         
01515         return true;
01516     }
01517 
01518     static void      putToString  (const      Pnt3b &inVal,
01519                                          std::string &outStr)
01520     {
01521         typedef TypeTraits<Pnt3b::ValueType> TypeTrait;
01522         
01523         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01524         outStr.append("  ");
01525         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01526         outStr.append("  ");
01527         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01528     }
01529 };
01530 
01531 #if !defined(OSG_DOC_DEV_TRAITS)
01532 
01534 #endif
01535 
01538 #if !defined(OSG_DOC_DEV_TRAITS)
01539 
01540 #endif
01541 
01542 template <>
01543 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4b> :
01544     public FieldTraitsRecurseVecStore2Base<Pnt4b>
01545 {
01546     static  DataType                _type;
01547     typedef FieldDataTraits<Pnt4b>  Self;
01548 
01549 
01550     enum             { StringConvertable = Self::ToStringConvertable   | 
01551                                            Self::FromStringConvertable };
01552 
01553     enum             { bHasParent        = 0x01                        };
01554 
01555     static DataType &getType      (void) { return _type;               }
01556 
01557     static Char8    *getSName     (void) { return "SFPnt4b";           }
01558     static Char8    *getMName     (void) { return "MFPnt4b";           }
01559 
01560     static Pnt4b    getDefault   (void) { return Pnt4b();             }
01561 
01562     static bool      getFromString(      Pnt4b  &outVal,
01563                                    const Char8  *&inVal)
01564     {
01565         outVal.setValueFromCString(inVal);
01566         
01567         return true;
01568     }
01569 
01570     static void      putToString  (const      Pnt4b &inVal,
01571                                          std::string &outStr)
01572     {
01573         typedef TypeTraits<Pnt4b::ValueType> TypeTrait;
01574         
01575         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01576         outStr.append("  ");
01577         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01578         outStr.append("  ");
01579         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01580         outStr.append("  ");
01581         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01582     }
01583 };
01584 
01585 #if !defined(OSG_DOC_DEV_TRAITS)
01586 
01588 #endif
01589 #endif
01590 
01591 
01594 #if !defined(OSG_DOC_DEV_TRAITS)
01595 
01596 #endif
01597 
01598 template <>
01599 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2us> :
01600     public FieldTraitsRecurseVecStore2Base<Pnt2us>
01601 {
01602     static  DataType                _type;
01603     typedef FieldDataTraits<Pnt2us>  Self;
01604 
01605 
01606     enum             { StringConvertable = Self::ToStringConvertable   | 
01607                                            Self::FromStringConvertable };
01608 
01609     enum             { bHasParent        = 0x01                        };
01610 
01611     static DataType &getType      (void) { return _type;               }
01612 
01613     static Char8    *getSName     (void) { return "SFPnt2us";           }
01614     static Char8    *getMName     (void) { return "MFPnt2us";           }
01615 
01616     static Pnt2us    getDefault   (void) { return Pnt2us();             }
01617 
01618     static bool      getFromString(      Pnt2us  &outVal,
01619                                    const Char8 *&inVal)
01620     {
01621         outVal.setValueFromCString(inVal);
01622         
01623         return true;
01624     }
01625 
01626     static void      putToString  (const      Pnt2us &inVal,
01627                                          std::string &outStr)
01628     {
01629         typedef TypeTraits<Pnt2us::ValueType> TypeTrait;
01630         
01631         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01632         outStr.append("  ");
01633         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01634     }
01635 };
01636 
01637 #if !defined(OSG_DOC_DEV_TRAITS)
01638 
01640 #endif
01641 
01644 #if !defined(OSG_DOC_DEV_TRAITS)
01645 
01646 #endif
01647 
01648 template <>
01649 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3us> :
01650     public FieldTraitsRecurseVecStore2Base<Pnt3us>
01651 {
01652     static  DataType                _type;
01653     typedef FieldDataTraits<Pnt3us>  Self;
01654 
01655 
01656     enum             { StringConvertable = Self::ToStringConvertable   | 
01657                                            Self::FromStringConvertable };
01658 
01659     enum             { bHasParent        = 0x01                        };
01660 
01661     static DataType &getType      (void) { return _type;               }
01662 
01663     static Char8    *getSName     (void) { return "SFPnt3us";           }
01664     static Char8    *getMName     (void) { return "MFPnt3us";           }
01665 
01666     static Pnt3us    getDefault   (void) { return Pnt3us();             }
01667 
01668     static bool      getFromString(      Pnt3us  &outVal,
01669                                    const Char8 *&inVal)
01670     {
01671         outVal.setValueFromCString(inVal);
01672         
01673         return true;
01674     }
01675 
01676     static void      putToString  (const      Pnt3us &inVal,
01677                                          std::string &outStr)
01678     {
01679         typedef TypeTraits<Pnt3us::ValueType> TypeTrait;
01680         
01681         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01682         outStr.append("  ");
01683         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01684         outStr.append("  ");
01685         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01686     }
01687 };
01688 
01689 #if !defined(OSG_DOC_DEV_TRAITS)
01690 
01692 #endif
01693 
01696 #if !defined(OSG_DOC_DEV_TRAITS)
01697 
01698 #endif
01699 
01700 template <>
01701 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4us> :
01702     public FieldTraitsRecurseVecStore2Base<Pnt4us>
01703 {
01704     static  DataType                _type;
01705     typedef FieldDataTraits<Pnt4us>  Self;
01706 
01707 
01708     enum             { StringConvertable = Self::ToStringConvertable   | 
01709                                            Self::FromStringConvertable };
01710 
01711     enum             { bHasParent        = 0x01                        };
01712 
01713     static DataType &getType      (void) { return _type;               }
01714 
01715     static Char8    *getSName     (void) { return "SFPnt4us";           }
01716     static Char8    *getMName     (void) { return "MFPnt4us";           }
01717 
01718     static Pnt4us    getDefault   (void) { return Pnt4us();             }
01719 
01720     static bool      getFromString(      Pnt4us  &outVal,
01721                                    const Char8  *&inVal)
01722     {
01723         outVal.setValueFromCString(inVal);
01724         
01725         return true;
01726     }
01727 
01728     static void      putToString  (const      Pnt4us &inVal,
01729                                          std::string &outStr)
01730     {
01731         typedef TypeTraits<Pnt4us::ValueType> TypeTrait;
01732         
01733         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01734         outStr.append("  ");
01735         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01736         outStr.append("  ");
01737         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01738         outStr.append("  ");
01739         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01740     }
01741 };
01742 
01743 #if !defined(OSG_DOC_DEV_TRAITS)
01744 
01746 #endif
01747 
01748 
01749 
01752 #if !defined(OSG_DOC_DEV_TRAITS)
01753 
01754 #endif
01755 
01756 template <>
01757 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2s> :
01758     public FieldTraitsRecurseVecStore2Base<Pnt2s>
01759 {
01760     static  DataType                _type;
01761     typedef FieldDataTraits<Pnt2s>  Self;
01762 
01763 
01764     enum             { StringConvertable = Self::ToStringConvertable   | 
01765                                            Self::FromStringConvertable };
01766 
01767     enum             { bHasParent        = 0x01                        };
01768 
01769     static DataType &getType      (void) { return _type;               }
01770 
01771     static Char8    *getSName     (void) { return "SFPnt2s";           }
01772     static Char8    *getMName     (void) { return "MFPnt2s";           }
01773 
01774     static Pnt2s    getDefault   (void) { return Pnt2s();             }
01775 
01776     static bool      getFromString(      Pnt2s  &outVal,
01777                                    const Char8 *&inVal)
01778     {
01779         outVal.setValueFromCString(inVal);
01780         
01781         return true;
01782     }
01783 
01784     static void      putToString  (const      Pnt2s &inVal,
01785                                          std::string &outStr)
01786     {
01787         typedef TypeTraits<Pnt2s::ValueType> TypeTrait;
01788         
01789         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01790         outStr.append("  ");
01791         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01792     }
01793 };
01794 
01795 #if !defined(OSG_DOC_DEV_TRAITS)
01796 
01798 #endif
01799 
01802 #if !defined(OSG_DOC_DEV_TRAITS)
01803 
01804 #endif
01805 
01806 template <>
01807 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3s> :
01808     public FieldTraitsRecurseVecStore2Base<Pnt3s>
01809 {
01810     static  DataType                _type;
01811     typedef FieldDataTraits<Pnt3s>  Self;
01812 
01813 
01814     enum             { StringConvertable = Self::ToStringConvertable   | 
01815                                            Self::FromStringConvertable };
01816 
01817     enum             { bHasParent        = 0x01                        };
01818 
01819     static DataType &getType      (void) { return _type;               }
01820 
01821     static Char8    *getSName     (void) { return "SFPnt3s";           }
01822     static Char8    *getMName     (void) { return "MFPnt3s";           }
01823 
01824     static Pnt3s    getDefault   (void) { return Pnt3s();             }
01825 
01826     static bool      getFromString(      Pnt3s  &outVal,
01827                                    const Char8 *&inVal)
01828     {
01829         outVal.setValueFromCString(inVal);
01830         
01831         return true;
01832     }
01833 
01834     static void      putToString  (const      Pnt3s &inVal,
01835                                          std::string &outStr)
01836     {
01837         typedef TypeTraits<Pnt3s::ValueType> TypeTrait;
01838         
01839         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01840         outStr.append("  ");
01841         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01842         outStr.append("  ");
01843         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01844     }
01845 };
01846 
01847 #if !defined(OSG_DOC_DEV_TRAITS)
01848 
01850 #endif
01851 
01854 #if !defined(OSG_DOC_DEV_TRAITS)
01855 
01856 #endif
01857 
01858 template <>
01859 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4s> :
01860     public FieldTraitsRecurseVecStore2Base<Pnt4s>
01861 {
01862     static  DataType                _type;
01863     typedef FieldDataTraits<Pnt4s>  Self;
01864 
01865 
01866     enum             { StringConvertable = Self::ToStringConvertable   | 
01867                                            Self::FromStringConvertable };
01868 
01869     enum             { bHasParent        = 0x01                        };
01870 
01871     static DataType &getType      (void) { return _type;               }
01872 
01873     static Char8    *getSName     (void) { return "SFPnt4s";           }
01874     static Char8    *getMName     (void) { return "MFPnt4s";           }
01875 
01876     static Pnt4s    getDefault   (void) { return Pnt4s();             }
01877 
01878     static bool      getFromString(      Pnt4s  &outVal,
01879                                    const Char8  *&inVal)
01880     {
01881         outVal.setValueFromCString(inVal);
01882         
01883         return true;
01884     }
01885 
01886     static void      putToString  (const      Pnt4s &inVal,
01887                                          std::string &outStr)
01888     {
01889         typedef TypeTraits<Pnt4s::ValueType> TypeTrait;
01890         
01891         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01892         outStr.append("  ");
01893         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01894         outStr.append("  ");
01895         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
01896         outStr.append("  ");
01897         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
01898     }
01899 };
01900 
01901 #if !defined(OSG_DOC_DEV_TRAITS)
01902 
01904 #endif
01905 
01906 
01907 
01910 #if !defined(OSG_DOC_DEV_TRAITS)
01911 
01912 #endif
01913 
01914 template <>
01915 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2f> :
01916     public FieldTraitsRecurseVecStore2Base<Pnt2f>
01917 {
01918     static  DataType                _type;
01919     typedef FieldDataTraits<Pnt2f>  Self;
01920 
01921 
01922     enum             { StringConvertable = Self::ToStringConvertable   | 
01923                                            Self::FromStringConvertable };
01924 
01925     enum             { bHasParent        = 0x01                        };
01926 
01927     static DataType &getType      (void) { return _type;               }
01928 
01929     static Char8    *getSName     (void) { return "SFPnt2f";           }
01930     static Char8    *getMName     (void) { return "MFPnt2f";           }
01931 
01932     static Pnt2f    getDefault   (void) { return Pnt2f();             }
01933 
01934     static bool      getFromString(      Pnt2f  &outVal,
01935                                    const Char8 *&inVal)
01936     {
01937         outVal.setValueFromCString(inVal);
01938         
01939         return true;
01940     }
01941 
01942     static void      putToString  (const      Pnt2f &inVal,
01943                                          std::string &outStr)
01944     {
01945         typedef TypeTraits<Pnt2f::ValueType> TypeTrait;
01946         
01947         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01948         outStr.append("  ");
01949         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
01950     }
01951 };
01952 
01953 #if !defined(OSG_DOC_DEV_TRAITS)
01954 
01956 #endif
01957 
01960 #if !defined(OSG_DOC_DEV_TRAITS)
01961 
01962 #endif
01963 
01964 template <>
01965 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3f> :
01966     public FieldTraitsRecurseVecStore2Base<Pnt3f>
01967 {
01968     static  DataType                _type;
01969     typedef FieldDataTraits<Pnt3f>  Self;
01970 
01971 
01972     enum             { StringConvertable = Self::ToStringConvertable   | 
01973                                            Self::FromStringConvertable };
01974 
01975     enum             { bHasParent        = 0x01                        };
01976 
01977     static DataType &getType      (void) { return _type;               }
01978 
01979     static Char8    *getSName     (void) { return "SFPnt3f";           }
01980     static Char8    *getMName     (void) { return "MFPnt3f";           }
01981 
01982     static Pnt3f    getDefault   (void) { return Pnt3f();             }
01983 
01984     static bool      getFromString(      Pnt3f  &outVal,
01985                                    const Char8 *&inVal)
01986     {
01987         outVal.setValueFromCString(inVal);
01988         
01989         return true;
01990     }
01991 
01992     static void      putToString  (const      Pnt3f &inVal,
01993                                          std::string &outStr)
01994     {
01995         typedef TypeTraits<Pnt3f::ValueType> TypeTrait;
01996         
01997         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
01998         outStr.append("  ");
01999         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02000         outStr.append("  ");
02001         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02002     }
02003 };
02004 
02005 #if !defined(OSG_DOC_DEV_TRAITS)
02006 
02008 #endif
02009 
02012 #if !defined(OSG_DOC_DEV_TRAITS)
02013 
02014 #endif
02015 
02016 template <>
02017 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4f> :
02018     public FieldTraitsRecurseVecStore2Base<Pnt4f>
02019 {
02020     static  DataType                _type;
02021     typedef FieldDataTraits<Pnt4f>  Self;
02022 
02023 
02024     enum             { StringConvertable = Self::ToStringConvertable   | 
02025                                            Self::FromStringConvertable };
02026 
02027     enum             { bHasParent        = 0x01                        };
02028 
02029     static DataType &getType      (void) { return _type;               }
02030 
02031     static Char8    *getSName     (void) { return "SFPnt4f";           }
02032     static Char8    *getMName     (void) { return "MFPnt4f";           }
02033 
02034     static Pnt4f    getDefault   (void) { return Pnt4f();             }
02035 
02036     static bool      getFromString(      Pnt4f  &outVal,
02037                                    const Char8  *&inVal)
02038     {
02039         outVal.setValueFromCString(inVal);
02040         
02041         return true;
02042     }
02043 
02044     static void      putToString  (const      Pnt4f &inVal,
02045                                          std::string &outStr)
02046     {
02047         typedef TypeTraits<Pnt4f::ValueType> TypeTrait;
02048         
02049         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02050         outStr.append("  ");
02051         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02052         outStr.append("  ");
02053         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02054         outStr.append("  ");
02055         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
02056     }
02057 };
02058 
02059 #if !defined(OSG_DOC_DEV_TRAITS)
02060 
02062 #endif
02063 
02064 
02065 
02068 #if !defined(OSG_DOC_DEV_TRAITS)
02069 
02070 #endif
02071 
02072 template <>
02073 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2d> :
02074     public FieldTraitsRecurseVecStore2Base<Pnt2d>
02075 {
02076     static  DataType                _type;
02077     typedef FieldDataTraits<Pnt2d>  Self;
02078 
02079 
02080     enum             { StringConvertable = Self::ToStringConvertable   | 
02081                                            Self::FromStringConvertable };
02082 
02083     enum             { bHasParent        = 0x01                        };
02084 
02085     static DataType &getType      (void) { return _type;               }
02086 
02087     static Char8    *getSName     (void) { return "SFPnt2d";           }
02088     static Char8    *getMName     (void) { return "MFPnt2d";           }
02089 
02090     static Pnt2d    getDefault   (void) { return Pnt2d();             }
02091 
02092     static bool      getFromString(      Pnt2d  &outVal,
02093                                    const Char8 *&inVal)
02094     {
02095         outVal.setValueFromCString(inVal);
02096         
02097         return true;
02098     }
02099 
02100     static void      putToString  (const      Pnt2d &inVal,
02101                                          std::string &outStr)
02102     {
02103         typedef TypeTraits<Pnt2d::ValueType> TypeTrait;
02104         
02105         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02106         outStr.append("  ");
02107         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02108     }
02109 };
02110 
02111 #if !defined(OSG_DOC_DEV_TRAITS)
02112 
02114 #endif
02115 
02118 #if !defined(OSG_DOC_DEV_TRAITS)
02119 
02120 #endif
02121 
02122 template <>
02123 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3d> :
02124     public FieldTraitsRecurseVecStore2Base<Pnt3d>
02125 {
02126     static  DataType                _type;
02127     typedef FieldDataTraits<Pnt3d>  Self;
02128 
02129 
02130     enum             { StringConvertable = Self::ToStringConvertable   | 
02131                                            Self::FromStringConvertable };
02132 
02133     enum             { bHasParent        = 0x01                        };
02134 
02135     static DataType &getType      (void) { return _type;               }
02136 
02137     static Char8    *getSName     (void) { return "SFPnt3d";           }
02138     static Char8    *getMName     (void) { return "MFPnt3d";           }
02139 
02140     static Pnt3d    getDefault   (void) { return Pnt3d();             }
02141 
02142     static bool      getFromString(      Pnt3d  &outVal,
02143                                    const Char8 *&inVal)
02144     {
02145         outVal.setValueFromCString(inVal);
02146         
02147         return true;
02148     }
02149 
02150     static void      putToString  (const      Pnt3d &inVal,
02151                                          std::string &outStr)
02152     {
02153         typedef TypeTraits<Pnt3d::ValueType> TypeTrait;
02154         
02155         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02156         outStr.append("  ");
02157         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02158         outStr.append("  ");
02159         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02160     }
02161 };
02162 
02163 #if !defined(OSG_DOC_DEV_TRAITS)
02164 
02166 #endif
02167 
02170 #if !defined(OSG_DOC_DEV_TRAITS)
02171 
02172 #endif
02173 
02174 template <>
02175 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4d> :
02176     public FieldTraitsRecurseVecStore2Base<Pnt4d>
02177 {
02178     static  DataType                _type;
02179     typedef FieldDataTraits<Pnt4d>  Self;
02180 
02181 
02182     enum             { StringConvertable = Self::ToStringConvertable   | 
02183                                            Self::FromStringConvertable };
02184 
02185     enum             { bHasParent        = 0x01                        };
02186 
02187     static DataType &getType      (void) { return _type;               }
02188 
02189     static Char8    *getSName     (void) { return "SFPnt4d";           }
02190     static Char8    *getMName     (void) { return "MFPnt4d";           }
02191 
02192     static Pnt4d    getDefault   (void) { return Pnt4d();             }
02193 
02194     static bool      getFromString(      Pnt4d  &outVal,
02195                                    const Char8  *&inVal)
02196     {
02197         outVal.setValueFromCString(inVal);
02198         
02199         return true;
02200     }
02201 
02202     static void      putToString  (const      Pnt4d &inVal,
02203                                          std::string &outStr)
02204     {
02205         typedef TypeTraits<Pnt4d::ValueType> TypeTrait;
02206         
02207         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02208         outStr.append("  ");
02209         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02210         outStr.append("  ");
02211         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02212         outStr.append("  ");
02213         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
02214     }
02215 };
02216 
02217 #if !defined(OSG_DOC_DEV_TRAITS)
02218 
02220 #endif
02221 
02222 
02223 
02226 #if !defined(OSG_DOC_DEV_TRAITS)
02227 
02228 #endif
02229 
02230 template <>
02231 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt2ld> :
02232     public FieldTraitsRecurseVecStore2Base<Pnt2ld>
02233 {
02234     static  DataType                _type;
02235     typedef FieldDataTraits<Pnt2ld>  Self;
02236 
02237 
02238     enum             { StringConvertable = Self::ToStringConvertable   | 
02239                                            Self::FromStringConvertable };
02240 
02241     enum             { bHasParent        = 0x01                        };
02242 
02243     static DataType &getType      (void) { return _type;               }
02244 
02245     static Char8    *getSName     (void) { return "SFPnt2ld";           }
02246     static Char8    *getMName     (void) { return "MFPnt2ld";           }
02247 
02248     static Pnt2ld    getDefault   (void) { return Pnt2ld();             }
02249 
02250     static bool      getFromString(      Pnt2ld  &outVal,
02251                                    const Char8 *&inVal)
02252     {
02253         outVal.setValueFromCString(inVal);
02254         
02255         return true;
02256     }
02257 
02258     static void      putToString  (const      Pnt2ld &inVal,
02259                                          std::string &outStr)
02260     {
02261         typedef TypeTraits<Pnt2ld::ValueType> TypeTrait;
02262         
02263         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02264         outStr.append("  ");
02265         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02266     }
02267 };
02268 
02269 #if !defined(OSG_DOC_DEV_TRAITS)
02270 
02272 #endif
02273 
02276 #if !defined(OSG_DOC_DEV_TRAITS)
02277 
02278 #endif
02279 
02280 template <>
02281 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt3ld> :
02282     public FieldTraitsRecurseVecStore2Base<Pnt3ld>
02283 {
02284     static  DataType                _type;
02285     typedef FieldDataTraits<Pnt3ld>  Self;
02286 
02287 
02288     enum             { StringConvertable = Self::ToStringConvertable   | 
02289                                            Self::FromStringConvertable };
02290 
02291     enum             { bHasParent        = 0x01                        };
02292 
02293     static DataType &getType      (void) { return _type;               }
02294 
02295     static Char8    *getSName     (void) { return "SFPnt3ld";           }
02296     static Char8    *getMName     (void) { return "MFPnt3ld";           }
02297 
02298     static Pnt3ld    getDefault   (void) { return Pnt3ld();             }
02299 
02300     static bool      getFromString(      Pnt3ld  &outVal,
02301                                    const Char8 *&inVal)
02302     {
02303         outVal.setValueFromCString(inVal);
02304         
02305         return true;
02306     }
02307 
02308     static void      putToString  (const      Pnt3ld &inVal,
02309                                          std::string &outStr)
02310     {
02311         typedef TypeTraits<Pnt3ld::ValueType> TypeTrait;
02312         
02313         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02314         outStr.append("  ");
02315         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02316         outStr.append("  ");
02317         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02318     }
02319 };
02320 
02321 #if !defined(OSG_DOC_DEV_TRAITS)
02322 
02324 #endif
02325 
02328 #if !defined(OSG_DOC_DEV_TRAITS)
02329 
02330 #endif
02331 
02332 template <>
02333 struct OSG_BASE_DLLMAPPING FieldDataTraits<Pnt4ld> :
02334     public FieldTraitsRecurseVecStore2Base<Pnt4ld>
02335 {
02336     static  DataType                _type;
02337     typedef FieldDataTraits<Pnt4ld>  Self;
02338 
02339 
02340     enum             { StringConvertable = Self::ToStringConvertable   | 
02341                                            Self::FromStringConvertable };
02342 
02343     enum             { bHasParent        = 0x01                        };
02344 
02345     static DataType &getType      (void) { return _type;               }
02346 
02347     static Char8    *getSName     (void) { return "SFPnt4ld";           }
02348     static Char8    *getMName     (void) { return "MFPnt4ld";           }
02349 
02350     static Pnt4ld    getDefault   (void) { return Pnt4ld();             }
02351 
02352     static bool      getFromString(      Pnt4ld  &outVal,
02353                                    const Char8  *&inVal)
02354     {
02355         outVal.setValueFromCString(inVal);
02356         
02357         return true;
02358     }
02359 
02360     static void      putToString  (const      Pnt4ld &inVal,
02361                                          std::string &outStr)
02362     {
02363         typedef TypeTraits<Pnt4ld::ValueType> TypeTrait;
02364         
02365         outStr.assign(TypeTrait::putToString((inVal.getValues())[0]));
02366         outStr.append("  ");
02367         outStr.append(TypeTrait::putToString((inVal.getValues())[1]));
02368         outStr.append("  ");
02369         outStr.append(TypeTrait::putToString((inVal.getValues())[2]));
02370         outStr.append("  ");
02371         outStr.append(TypeTrait::putToString((inVal.getValues())[3]));
02372    }
02373 };
02374 
02375 #if !defined(OSG_DOC_DEV_TRAITS)
02376 
02378 #endif
02379 
02380 
02381 #endif // !defined(OSG_DO_DOC) || (OSG_DOC_LEVEL >= 3)
02382 
02383 OSG_END_NAMESPACE
02384 
02385 #define OSGVECFIELDDATATYPE_HEADER_CVSID "@(#)$Id: $"
02386 
02387 #endif /* _OSG_VECFIELDDATATYPE_H_ */
02388 
02389 
02390