OpenSG: OSGMField.inl Source File

00001 /*---------------------------------------------------------------------------*\
00002  *                                OpenSG                                     *
00003  *                                                                           *
00004  *                                                                           *
00005  *                 Copyright (C) 2000 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 //  Includes
00041 //---------------------------------------------------------------------------
00042 
00043 #include <algorithm>
00044 
00045 OSG_BEGIN_NAMESPACE
00046 
00047 #ifndef STD
00048 #define STD std
00049 #endif
00050 
00051 /*-------------------------------------------------------------------------*/
00052 /*                            Class Get                                    */
00053 
00054 #ifndef WIN32
00055 template <class FieldTypeT, Int32 fieldNameSpace> inline
00056 const FieldType &MField<FieldTypeT, fieldNameSpace>::getClassType(void)
00057 {
00058     return _fieldType;
00059 }
00060 #endif
00061 
00062 /*-------------------------------------------------------------------------*/
00063 /*                            Constructors                                 */
00064 
00065 template <class FieldTypeT, Int32 fieldNameSpace> inline
00066 MField<FieldTypeT, fieldNameSpace>::MField(void) :
00067      Inherited   ( ),
00068     _values      ( ),
00069     _uiSharedWith(0)
00070 {
00071 }
00072 
00073 template <class FieldTypeT, Int32 fieldNameSpace> inline
00074 MField<FieldTypeT, fieldNameSpace>::MField(const MField &obj) :
00075      Inherited   (obj        ),
00076     _values      (obj._values),
00077     _uiSharedWith(          0)
00078 {
00079 }
00080 
00081 template <class FieldTypeT, Int32 fieldNameSpace> inline
00082 MField<FieldTypeT, fieldNameSpace>::MField(const UInt32 size) :
00083      Inherited   ( ),
00084     _values      ( ),
00085     _uiSharedWith(0)
00086 {
00087     _values.resize(size);
00088 }
00089 
00090 /*-------------------------------------------------------------------------*/
00091 /*                             Destructor                                  */
00092 
00093 template <class FieldTypeT, Int32 fieldNameSpace> inline
00094 MField<FieldTypeT, fieldNameSpace>::~MField(void)
00095 {
00096 }
00097 
00098 /*-------------------------------------------------------------------------*/
00099 /*                               Get                                       */
00100 
00104 template <class FieldTypeT, Int32 fieldNameSpace> inline
00105 typename MField<FieldTypeT, fieldNameSpace>::StorageType &
00106     MField<FieldTypeT, fieldNameSpace>::getValues(void)
00107 {
00108     return _values;
00109 }
00110 
00114 template <class FieldTypeT, Int32 fieldNameSpace> inline
00115 const typename MField<FieldTypeT, fieldNameSpace>::StorageType &
00116     MField<FieldTypeT, fieldNameSpace>::getValues(void) const
00117 {
00118     return _values;
00119 }
00120 
00121 #ifndef WIN32
00122 template <class FieldTypeT, Int32 fieldNameSpace> inline
00123 const FieldType &MField<FieldTypeT, fieldNameSpace>::getType(void) const
00124 {
00125     return _fieldType;
00126 }
00127 #endif
00128 
00129 template <class FieldTypeT, Int32 fieldNameSpace> inline
00130 bool MField<FieldTypeT, fieldNameSpace>::isEmpty(void) const
00131 {
00132     return empty();
00133 }
00134 
00135 template <class FieldTypeT, Int32 fieldNameSpace> inline
00136 void MField<FieldTypeT, fieldNameSpace>::operator =(const MField &source)
00137 {
00138     if(this == &source)
00139        return;
00140 
00141     _values = source._values;
00142 }
00143 
00144 /*-------------------------------------------------------------------------*/
00145 /*                                Set                                      */
00146 
00151 template <class FieldTypeT, Int32 fieldNameSpace> inline
00152 void MField<FieldTypeT, fieldNameSpace>::setAbstrValue(const Field &obj)
00153 {
00154     if(getType() == obj.getType())
00155     {
00156         setValues(*((const MField<FieldTypeT, fieldNameSpace> *) &obj));
00157     }
00158 }
00159 
00160 template <class FieldTypeT, Int32 fieldNameSpace> inline
00161 void MField<FieldTypeT, fieldNameSpace>::setValues(const StorageType &value)
00162 {
00163     _values = value;
00164 }
00165 
00166 template <class FieldTypeT, Int32 fieldNameSpace> inline
00167 void MField<FieldTypeT, fieldNameSpace>::setValues(
00168     const StorageTypeParent &value)
00169 {
00170     // Hack probably move it to MFieldVector (GV)
00171 
00172     *(static_cast<StorageTypeParent *>(&_values)) = value;
00173 }
00174 
00175 template <class FieldTypeT, Int32 fieldNameSpace> inline
00176 void MField<FieldTypeT, fieldNameSpace>::setValues(const Self &obj)
00177 {
00178     _values = obj._values;
00179 }
00180 
00181 /*-------------------------------------------------------------------------*/
00182 /*                             STL Interface                               */
00183 
00184 template <class FieldTypeT, Int32 fieldNameSpace> inline
00185 typename MField<FieldTypeT, 
00186                 fieldNameSpace>::iterator MField<FieldTypeT, 
00187                                                  fieldNameSpace>::begin (void)
00188 {
00189     return _values.begin();
00190 }
00191 
00192 template <class FieldTypeT, Int32 fieldNameSpace> inline
00193 typename MField<FieldTypeT, 
00194                 fieldNameSpace>::iterator MField<FieldTypeT, 
00195                                                  fieldNameSpace>::end(void)
00196 {
00197     return _values.end();
00198 }
00199 
00200 template <class FieldTypeT, Int32 fieldNameSpace> inline
00201 typename MField<FieldTypeT, 
00202                 fieldNameSpace>::reverse_iterator 
00203     MField<FieldTypeT, 
00204            fieldNameSpace>::rbegin(void)
00205 {
00206     return _values.rbegin();
00207 }
00208 
00209 template <class FieldTypeT, Int32 fieldNameSpace> inline
00210 typename MField<FieldTypeT, 
00211                 fieldNameSpace>::reverse_iterator 
00212     MField<FieldTypeT, 
00213            fieldNameSpace>::rend(void)
00214 {
00215     return _values.rend();
00216 }
00217 
00218 template <class FieldTypeT, Int32 fieldNameSpace> inline
00219 typename MField<FieldTypeT, 
00220                 fieldNameSpace>::const_iterator MField<FieldTypeT, 
00221                                                        fieldNameSpace>::begin(
00222                                                            void) const
00223 {
00224     return _values.begin();
00225 }
00226 
00227 template <class FieldTypeT, Int32 fieldNameSpace> inline
00228 typename MField<FieldTypeT, 
00229                 fieldNameSpace>::const_iterator MField<FieldTypeT,
00230                                                        fieldNameSpace>::end(
00231                                                            void) const
00232 {
00233     return _values.end();
00234 }
00235 
00236 template <class FieldTypeT, Int32 fieldNameSpace> inline
00237 typename MField<FieldTypeT,
00238                 fieldNameSpace>::const_reverse_iterator 
00239     MField<FieldTypeT, 
00240            fieldNameSpace>::rbegin(void) const
00241 {
00242     return _values.rbegin();
00243 }
00244 
00245 template <class FieldTypeT, Int32 fieldNameSpace> inline
00246 typename MField<FieldTypeT, 
00247                 fieldNameSpace>::const_reverse_iterator 
00248     MField<FieldTypeT, 
00249            fieldNameSpace>::rend(void) const
00250 {
00251     return _values.rend();
00252 }
00253 
00254 template <class FieldTypeT, Int32 fieldNameSpace> inline
00255 typename MField<FieldTypeT, 
00256                 fieldNameSpace>::reference MField<FieldTypeT, 
00257                                                   fieldNameSpace>::front(void)
00258 {
00259     return _values.front();
00260 }
00261 
00262 template <class FieldTypeT, Int32 fieldNameSpace> inline
00263 typename MField<FieldTypeT, 
00264                 fieldNameSpace>::const_reference MField<FieldTypeT, 
00265                                                         fieldNameSpace>::front(
00266                                                             void) const
00267 {
00268     return _values.front();
00269 }
00270 
00271 template <class FieldTypeT, Int32 fieldNameSpace> inline
00272 typename MField<FieldTypeT, 
00273                 fieldNameSpace>::reference MField<FieldTypeT, 
00274                                                   fieldNameSpace>::back(void)
00275 {
00276     return _values.back();
00277 }
00278 
00279 template <class FieldTypeT, Int32 fieldNameSpace> inline
00280 typename MField<FieldTypeT, 
00281                 fieldNameSpace>::const_reference MField<FieldTypeT, 
00282                                                         fieldNameSpace>::back(
00283                                                             void) const
00284 {
00285     return _values.back();
00286 }
00287 
00288 template <class FieldTypeT, Int32 fieldNameSpace> inline
00289 void MField<FieldTypeT, fieldNameSpace>::clear(void)
00290 {
00291     _values.clear();
00292 }
00293 
00294 template <class FieldTypeT, Int32 fieldNameSpace> inline
00295 typename MField<FieldTypeT, 
00296                 fieldNameSpace>::iterator MField<FieldTypeT, 
00297                                                  fieldNameSpace>::insert(
00298     iterator pos, ArgumentType value)
00299 {
00300     return _values.insert(pos, value);
00301 }
00302 
00303 template <class FieldTypeT, Int32 fieldNameSpace> inline
00304 typename MField<FieldTypeT, 
00305                 fieldNameSpace>::iterator MField<FieldTypeT, 
00306                                                  fieldNameSpace>::erase(
00307                                                      iterator pos)
00308 {
00309     return _values.erase(pos);
00310 }
00311 
00312 template <class FieldTypeT, Int32 fieldNameSpace> inline
00313 typename MField<FieldTypeT, 
00314                 fieldNameSpace>::iterator MField<FieldTypeT, 
00315                                                  fieldNameSpace>::find(
00316     ArgumentType value)
00317 {
00318     return STD::find(_values.begin(), _values.end(), value);
00319 }
00320 
00321 template <class FieldTypeT, Int32 fieldNameSpace> inline
00322 typename MField<FieldTypeT, 
00323                 fieldNameSpace>::const_iterator MField<FieldTypeT, 
00324                                                        fieldNameSpace>::find(
00325     ArgumentType value) const
00326 {
00327     return STD::find(_values.begin(), _values.end(), value);
00328 }
00329 
00330 template <class FieldTypeT, Int32 fieldNameSpace> inline
00331 void MField<FieldTypeT, fieldNameSpace>::push_back(ArgumentType value)
00332 {
00333     _values.push_back(value);
00334 }
00335 
00336 template <class FieldTypeT, Int32 fieldNameSpace> inline
00337 void MField<FieldTypeT, fieldNameSpace>::resize(size_t newsize, FieldTypeT t)
00338 {
00339     _values.resize(newsize, t);
00340 }
00341 
00342 template <class FieldTypeT, Int32 fieldNameSpace> inline
00343 void MField<FieldTypeT, fieldNameSpace>::reserve(size_t newsize)
00344 {
00345     _values.reserve(newsize);
00346 }
00347 
00348 template <class FieldTypeT, Int32 fieldNameSpace> inline
00349 UInt32 MField<FieldTypeT, fieldNameSpace>::size(void) const
00350 {
00351     return _values.size();
00352 }
00353 
00354 template <class FieldTypeT, Int32 fieldNameSpace> inline
00355 UInt32 MField<FieldTypeT, fieldNameSpace>::capacity(void) const
00356 {
00357     return _values.capacity();
00358 }
00359 
00360 template <class FieldTypeT, Int32 fieldNameSpace> inline
00361 bool MField<FieldTypeT, fieldNameSpace>::empty(void) const
00362 {
00363     return _values.empty();
00364 }
00365 
00366 template <class FieldTypeT, Int32 fieldNameSpace> inline
00367 void MField<FieldTypeT, fieldNameSpace>::swap(MField &right)
00368 {
00369     _values.swap(right._values);
00370 }
00371 
00372 /*-------------------------------------------------------------------------*/
00373 /*                           String IO                                     */
00374 
00375 template <class FieldTypeT, Int32 fieldNameSpace> inline
00376 void MField<FieldTypeT, fieldNameSpace>::pushValueByStr(const Char8 *str)
00377 {
00378     FieldTypeT  tmpVal;
00379 
00380     typedef typename osgIF< (MFieldTraits::StringConvertable &
00381                              FieldTraits ::FromStringConvertable), 
00382                             MFieldTraits, 
00383                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00384     
00385     Converter::getFromString(tmpVal, str);
00386     
00387     push_back(tmpVal);
00388 }
00389 
00390 template <class FieldTypeT, Int32 fieldNameSpace> inline
00391 std::string &MField<FieldTypeT, 
00392                     fieldNameSpace>::getValueByStr(std::string &str) const
00393 {
00394     std::string tmpString;
00395 
00396     typedef typename osgIF< (MFieldTraits::StringConvertable &
00397                              FieldTraits ::ToStringConvertable),
00398                             MFieldTraits,
00399                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00400 
00401     for(UInt32 i = 0; i < size(); ++i)
00402     {
00403         Converter::putToString(_values[i], tmpString);
00404 
00405         str.append(tmpString);
00406 
00407         if(i < (size()-1))
00408         {
00409             str.append(", ");
00410         }
00411     }
00412 
00413     return str;
00414 }
00415 
00416 template <class FieldTypeT, Int32 fieldNameSpace> inline
00417 std::string &MField<FieldTypeT, 
00418                     fieldNameSpace>::getValueByStr(
00419                         std::string               &outStr,
00420                         StringConversionStateBase &state) const
00421 {
00422     std::string valStr;
00423 
00424     typedef typename osgIF< (MFieldTraits::StringConvertable &
00425                              FieldTraits ::ToStringConvertable),
00426                             MFieldTraits,
00427                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00428 
00429     state.beginField(this, outStr);
00430 
00431     for(UInt32 i = 0; i < size(); ++i)
00432     {
00433         valStr.erase();
00434         Converter::putToString(_values[i], valStr);
00435 
00436         state.addValueStr(valStr, outStr);
00437     }
00438 
00439     state.endField(this, outStr);
00440     
00441     return outStr;
00442 }
00443 
00444 template <class FieldTypeT, Int32 fieldNameSpace> inline
00445 std::string &MField<FieldTypeT,
00446                     fieldNameSpace>::getValueByStr(
00447                         std::string &str, 
00448                         UInt32       index) const
00449 {
00450     if(index >= size())
00451     {
00452         return str;
00453     }
00454 
00455     std::string tmpString;
00456 
00457     typedef typename osgIF< (MFieldTraits::StringConvertable &
00458                              FieldTraits::ToStringConvertable),
00459                             MFieldTraits,
00460                             ErrorFromToString<FieldTypeT> >::_IRet Converter;
00461 
00462     Converter::putToString(_values[index], tmpString);
00463 
00464     str.append(tmpString);
00465 
00466     return str;
00467 }
00468 
00469 /*-------------------------------------------------------------------------*/
00470 /*                           Index Operator                                */
00471 
00472 template <class FieldTypeT, Int32 fieldNameSpace> inline
00473 typename MField<FieldTypeT, fieldNameSpace>::reference
00474     MField<FieldTypeT, fieldNameSpace>::operator [](UInt32 index)
00475 {
00476     return _values[index];
00477 }
00478 
00479 template <class FieldTypeT, Int32 fieldNameSpace> inline
00480 typename MField<FieldTypeT, fieldNameSpace>::const_reference
00481     MField<FieldTypeT, fieldNameSpace>::operator [](UInt32 index) const
00482 {
00483     return _values[index];
00484 }
00485 
00486 #ifndef OSG_DISABLE_DEPRECATED
00487 template <class FieldTypeT, Int32 fieldNameSpace> inline
00488 typename MField<FieldTypeT, fieldNameSpace>::reference 
00489     MField<FieldTypeT, fieldNameSpace>::getValue (const UInt32 index)
00490 {
00491     return operator[](index);
00492 }
00493 
00494 template <class FieldTypeT, Int32 fieldNameSpace> inline
00495 typename MField<FieldTypeT, fieldNameSpace>::const_reference
00496     MField<FieldTypeT, fieldNameSpace>::getValue (const UInt32 index) const
00497 {
00498     return operator[](index);
00499 }
00500 
00501 template <class FieldTypeT, Int32 fieldNameSpace> inline
00502 void MField<FieldTypeT, fieldNameSpace>::setValue(       ArgumentType value,
00503                                                   const UInt32       index)
00504 {
00505     operator[](index) = value;
00506 }
00507 
00508 template <class FieldTypeT, Int32 fieldNameSpace> inline
00509 void MField<FieldTypeT, fieldNameSpace>::addValue(ArgumentType value)
00510 {
00511     push_back(value);
00512 }
00513 #endif
00514 
00515 template <class FieldTypeT, Int32 fieldNameSpace> inline
00516 UInt32 MField<FieldTypeT, fieldNameSpace>::getSize(void) const
00517 {
00518     return size();
00519 }
00520 
00521 /*-------------------------------------------------------------------------*/
00522 /*                              MT Sync                                    */
00523 
00524 #if !defined(OSG_FIXED_MFIELDSYNC)
00525 template <class FieldTypeT, Int32 fieldNameSpace> inline
00526 void MField<FieldTypeT, fieldNameSpace>::syncWith(Self &source)
00527 {
00528     setValues(source);
00529 }
00530 #else
00531 template <class ValueT, Int32 iNamespace> inline
00532 void MField<ValueT, iNamespace>::syncWith(      Self      &source,
00533                                           const SyncInfo  &sInfo )
00534 
00535 /*
00536                                           BitVector  syncMode,
00537                                           UInt32     uiSyncInfo,
00538                                           UInt32     uiCopyOffset)
00539  */
00540 {
00541     if(sInfo.syncMode != 0x0000)
00542     {
00543         setValues  (source);
00544     }
00545     else
00546     {
00547         UInt32 uiFromAspect  = (sInfo.uiSyncInfo & 0xFF000000) >> 24;
00548         UInt32 uiToAspect    = (sInfo.uiSyncInfo & 0x00FF0000) >> 16;
00549 
00550         bool   bTargetDelete = true;
00551 
00552         if(_uiSharedWith != 0x0000)
00553         {
00554             bTargetDelete = false;
00555 
00556             resolveShare(uiToAspect, sInfo.uiCopyOffset);
00557         }
00558 
00559         Char8  *pOtherMem = reinterpret_cast<Char8 *>(this);
00560         Self   *pOther    = NULL;
00561         UInt32  uiShared  = source._uiSharedWith;
00562         UInt32  uiCheck   = 1;
00563 
00564         pOtherMem -= uiToAspect * sInfo.uiCopyOffset;
00565 
00566         for(UInt32 i = 0; i < 32; ++i)
00567         {
00568             if(0x0000 != (uiShared & uiCheck))
00569             {
00570                 pOther = 
00571                     reinterpret_cast<Self *>(
00572                         pOtherMem + (i * sInfo.uiCopyOffset));
00573 
00574                 pOther->_uiSharedWith |= (1 << uiToAspect);
00575 
00576                 uiShared &= ~uiCheck;
00577             }
00578 
00579             if(0x0000 == uiShared)
00580             {
00581                 break;
00582             }
00583 
00584             uiCheck <<= 1;
00585         }
00586         
00587         _uiSharedWith        |= source._uiSharedWith;
00588         _uiSharedWith        |= (1 << uiFromAspect);
00589 
00590         source._uiSharedWith |= (1 << uiToAspect  );
00591 
00592         _values.shareValues(source._values, bTargetDelete);
00593     }
00594 }
00595 
00596 template <class ValueT, Int32 iNamespace> inline
00597 void MField<ValueT, iNamespace>::beginEdit(UInt32 uiAspect,
00598                                            UInt32 uiCopyOffset)
00599 {
00600     if(_uiSharedWith != 0x0000)
00601     {
00602         Self   *pOther = resolveShare(uiAspect, uiCopyOffset);
00603 
00604         _values.resolveShare();
00605 
00606         setValues(*pOther);
00607     }
00608 }
00609 
00610 template <class ValueT, Int32 iNamespace> inline
00611 typename MField<ValueT, 
00612                 iNamespace>::Self *
00613     MField<ValueT, 
00614            iNamespace>::resolveShare(UInt32 uiAspect, 
00615                                      UInt32 uiCopyOffset)
00616 {
00617     Char8  *pOtherMem = reinterpret_cast<Char8 *>(this);
00618     Self   *pOther    = NULL;
00619     UInt32  uiShared  = _uiSharedWith;
00620     UInt32  uiCheck   = 1;
00621     UInt32  uiOwn     = 1 << uiAspect;
00622     
00623     pOtherMem -= uiAspect * uiCopyOffset;
00624     
00625     for(UInt32 i = 0; i < 32; ++i)
00626     {
00627         if(0x0000 != (uiShared & uiCheck))
00628         {
00629             pOther = 
00630                 reinterpret_cast<Self *>(
00631                     pOtherMem + (i * uiCopyOffset));
00632             
00633             pOther->_uiSharedWith &= ~uiOwn;
00634             _uiSharedWith         &= ~uiCheck;
00635             
00636             uiShared &= ~uiCheck;
00637         }
00638         
00639         if(0x0000 == uiShared)
00640         {
00641             break;
00642         }
00643         
00644         uiCheck <<= 1;
00645     }    
00646 
00647     return pOther;
00648 }
00649 
00650 template <class ValueT, Int32 iNamespace> inline
00651 void MField<ValueT, iNamespace>::terminateShare(UInt32 uiAspect, 
00652                                                 UInt32 uiCopyOffset)
00653 {
00654     if(_uiSharedWith != 0x0000)
00655     {
00656         Char8  *pOtherMem = reinterpret_cast<Char8 *>(this);
00657         Self   *pOther    = NULL;
00658         UInt32  uiShared  = _uiSharedWith;
00659         UInt32  uiCheck   = 1 << (uiAspect + 1);
00660         UInt32  uiOwn     = 1 << uiAspect;
00661 
00662         for(UInt32 i = 1; i < 32; ++i)
00663         {
00664             if(0x0000 != (uiShared & uiCheck))
00665             {
00666                 pOther = 
00667                     reinterpret_cast<Self *>(
00668                         pOtherMem + (i * uiCopyOffset));
00669                 
00670                 pOther->_uiSharedWith &= ~uiOwn;
00671                 _uiSharedWith         &= ~uiCheck;
00672 
00673                 pOther->_values.resolveShare();
00674 
00675                 uiShared &= ~uiCheck;
00676             }
00677             
00678             if(0x0000 == uiShared)
00679             {
00680                 break;
00681             }
00682 
00683             uiCheck <<= 1;
00684         }
00685     }
00686 }
00687 #endif
00688 
00689 /*-------------------------------------------------------------------------*/
00690 /*                         Binary Interface                                */
00691 
00692 template <class FieldTypeT, Int32 fieldNameSpace> inline
00693 UInt32 MField<FieldTypeT, fieldNameSpace>::getBinSize(void) const
00694 {
00695     return sizeof(UInt32) + // num elements
00696         (_values.size() ? 
00697             MFieldTraits::getBinSize(&(_values[0]), _values.size()) : 0);
00698 }
00699 
00700 template <class FieldTypeT, Int32 fieldNameSpace> inline
00701 void MField<FieldTypeT, 
00702             fieldNameSpace>::copyToBin(BinaryDataHandler &pMem) const
00703 {
00704     UInt32 n = _values.size();
00705 
00706     pMem.putValue(n);
00707     if(n)
00708         MFieldTraits::copyToBin(   pMem, 
00709                                 &(_values[0]),
00710                                   _values.size());
00711 }
00712 
00713 template <class FieldTypeT, Int32 fieldNameSpace> inline
00714 void MField<FieldTypeT, fieldNameSpace>::copyFromBin(BinaryDataHandler &pMem)
00715 {
00716     UInt32 n;
00717 
00718      pMem  .getValue(n);
00719     _values.clear ( );
00720 
00721 #ifdef __hpux
00722     FieldTypeT tmpVal;
00723 
00724     _values.resize(n, tmpVal);
00725 #else
00726     _values.resize(n);
00727 #endif
00728 
00729     if(n)
00730         MFieldTraits::copyFromBin(pMem, 
00731                                   &(_values[0]),
00732                                   n);
00733 }
00734 
00735 /*-------------------------------------------------------------------------*/
00736 /*                               Dump                                      */
00737 
00738 template <class FieldTypeT, Int32 fieldNameSpace> inline
00739 void MField<FieldTypeT, fieldNameSpace>::dump(void) const
00740 {
00741     std::cout << "STMFST : " << std::endl;
00742 
00743     for(UInt32 i = 0; i < _values.size(); i++)
00744     {
00745 //        cout << _values[i] << " , ";
00746     }
00747 
00748     std::cout << std::endl;
00749 }
00750 
00751 /*-------------------------------------------------------------------------*/
00752 /*                             Create                                      */
00753 
00754 template <class FieldTypeT, Int32 fieldNameSpace> inline
00755 Field *MField<FieldTypeT, fieldNameSpace>::create(void) 
00756 {
00757     return new MField<FieldTypeT, fieldNameSpace>(); 
00758 }
00759 
00760 OSG_END_NAMESPACE
00761 
00762 #define OSGMFIELD_INLINE_CVSID "@(#)$Id: $"
00763 
00764