Source/Base/Field/OSGMField.inl

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 by the OpenSG Forum                          *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 OSG_BEGIN_NAMESPACE
  40
  41 /*-------------------------------------------------------------------------*/
  42 /*                            Constructors                                 */
  43
  44 template <class ValueT, Int32 iNamespace, class AllocT> inline
  45 MField<ValueT, iNamespace, AllocT>::MField(void) :
  46      Inherited   ( ),
  47     _values      ( )
  48 #ifdef OSG_MT_CPTR_ASPECT
  49    ,_uiSharedWith(0)
  50 #endif
  51 {
  52 }
  53
  54 template <class ValueT, Int32 iNamespace, class AllocT> inline
  55 MField<ValueT, iNamespace, AllocT>::MField(const MField &obj) :
  56      Inherited   (obj        ),
  57     _values      (obj._values)
  58 #ifdef OSG_MT_CPTR_ASPECT
  59    ,_uiSharedWith(0          )
  60 #endif
  61 {
  62 }
  63
  64 template <class ValueT, Int32 iNamespace, class AllocT> inline
  65 MField<ValueT, iNamespace, AllocT>::MField(const UInt32 initSize) :
  66      Inherited    ( ),
  67     _values       ( )
  68 #ifdef OSG_MT_CPTR_ASPECT
  69     ,_uiSharedWith(0)
  70 #endif
  71 {
  72     _values.resize(initSize);
  73 }
  74
  75 /*-------------------------------------------------------------------------*/
  76 /*                             Destructor                                  */
  77
  78 template <class ValueT, Int32 iNamespace, class AllocT> inline
  79 MField<ValueT, iNamespace, AllocT>::~MField(void)
  80 {
  81 }
  82
  83 /*-------------------------------------------------------------------------*/
  84 /*                               Get                                       */
  85
  86 /*! Return a reference to the value store
  87  */
  88
  89 template <class ValueT, Int32 iNamespace, class AllocT> inline
  90 typename MField<ValueT, iNamespace, AllocT>::StorageType &
  91     MField<ValueT, iNamespace, AllocT>::getValues(void)
  92 {
  93     return _values;
  94 }
  95
  96 /*! Return a const reference to the value store
  97  */
  98
  99 template <class ValueT, Int32 iNamespace, class AllocT> inline
 100 const typename MField<ValueT, iNamespace, AllocT>::StorageType &
 101     MField<ValueT, iNamespace, AllocT>::getValues(void) const
 102 {
 103     return _values;
 104 }
 105
 106 /*-------------------------------------------------------------------------*/
 107 /*                                Set                                      */
 108
 109 template <class ValueT, Int32 iNamespace, class AllocT> inline
 110 void MField<ValueT, iNamespace, AllocT>::setValues(const StorageType &value)
 111 {
 112     _values = value;
 113 }
 114
 115 template <class ValueT, Int32 iNamespace, class AllocT> inline
 116 void MField<ValueT, iNamespace, AllocT>::setValues(
 117     const StorageTypeParent &value)
 118 {
 119     // Hack probably move it to MFieldVector (GV)
 120
 121     *(static_cast<StorageTypeParent *>(&_values)) = value;
 122 }
 123
 124 template <class ValueT, Int32 iNamespace, class AllocT> inline
 125 void MField<ValueT, iNamespace, AllocT>::setValues(const Self &obj)
 126 {
 127     _values = obj._values;
 128 }
 129
 130 template <class ValueT, Int32 iNamespace, class AllocT> inline
 131 void MField<ValueT, iNamespace, AllocT>::addValueFromCString(const Char8 *str)
 132 {
 133     ValueT tmpVal;
 134
 135     typedef typename boost::mpl::if_<boost::mpl::bool_<
 136         static_cast<bool>(MFieldTraits    ::Convertible &
 137                           FieldTraitsBase ::FromStringConvertible)>,
 138         MFieldTraits,
 139         StringConversionError<ValueT,
 140                               iNamespace> >::type Converter;
 141
 142     Converter::getFromCString(tmpVal, str);
 143
 144     push_back(tmpVal);
 145 }
 146
 147
 148 template <class ValueT, Int32 iNamespace, class AllocT> inline
 149 void MField<ValueT,
 150             iNamespace,
 151             AllocT    >::pushValuesToString(std::string  &str) const
 152 {
 153     typedef typename boost::mpl::if_<boost::mpl::bool_<
 154         static_cast<bool>(MFieldTraits    ::Convertible &
 155                           FieldTraitsBase ::ToStringConvertible)>,
 156         MFieldTraits,
 157         StringConversionError<ValueT,
 158                               iNamespace> >::type Converter;
 159
 160     for(SizeT i = 0; i < size(); ++i)
 161     {
 162         Converter::putToString(_values[i], str);
 163
 164         if(i < (size() - 1))
 165         {
 166             str.append(", ");
 167         }
 168     }
 169
 170 }
 171
 172 template <class ValueT, Int32 iNamespace, class AllocT> inline
 173 void MField<ValueT,
 174             iNamespace,
 175             AllocT    >::pushValuesFromStream(std::istream &str)
 176 {
 177     ValueT tmpVal;
 178
 179     typedef typename boost::mpl::if_<boost::mpl::bool_<
 180         static_cast<bool>(MFieldTraits    ::Convertible &
 181                           FieldTraitsBase ::FromStreamConvertible)>,
 182         MFieldTraits,
 183         StreamConversionError<ValueT,
 184                               iNamespace> >::type Converter;
 185
 186     Converter::getFromStream(tmpVal, str);
 187
 188     push_back(tmpVal);
 189 }
 190
 191 template <class ValueT, Int32 iNamespace, class AllocT> inline
 192 void MField<ValueT,
 193             iNamespace,
 194             AllocT    >::pushIndexedValueFromCString(Char8  const *str,
 195                                                      UInt32        index)
 196 {
 197     ValueT tmpVal;
 198
 199     typedef typename boost::mpl::if_<boost::mpl::bool_<
 200         static_cast<bool>(MFieldTraits    ::Convertible &
 201                           FieldTraitsBase ::FromStringConvertible)>,
 202         MFieldTraits,
 203         StringConversionError<ValueT,
 204                               iNamespace> >::type Converter;
 205
 206     Converter::getFromCString(tmpVal, str);
 207
 208     _values[index] = tmpVal;
 209 }
 210
 211 template <class ValueT, Int32 iNamespace, class AllocT> inline
 212 void MField<ValueT,
 213             iNamespace,
 214             AllocT    >::pushIndexedValueToStream(OutStream &str,
 215                                                   UInt32     index) const
 216 {
 217     typedef typename boost::mpl::if_<boost::mpl::bool_<
 218         static_cast<bool>(MFieldTraits    ::Convertible &
 219                           FieldTraitsBase ::ToStreamConvertible)>,
 220         MFieldTraits,
 221         StreamConversionError<ValueT,
 222                               iNamespace> >::type Converter;
 223
 224     Converter::putToStream(_values[index], str);
 225 }
 226
 227 template <class ValueT, Int32 iNamespace, class AllocT> inline
 228 void MField<ValueT,
 229             iNamespace,
 230             AllocT    >::pushValuesToStream(OutStream &str) const
 231 {
 232     typedef typename boost::mpl::if_<boost::mpl::bool_<
 233         static_cast<bool>(MFieldTraits    ::Convertible &
 234                           FieldTraitsBase ::ToStreamConvertible)>,
 235         MFieldTraits,
 236         StreamConversionError<ValueT,
 237                               iNamespace> >::type Converter;
 238
 239     for(SizeT i = 0; i < size(); ++i)
 240     {
 241         Converter::putToStream(_values[i], str);
 242
 243         if(i < (size() - 1))
 244         {
 245             str << ", ";
 246         }
 247     }
 248
 249 }
 250
 251 template <class ValueT, Int32 iNamespace, class AllocT> inline
 252 void MField<ValueT, iNamespace, AllocT>::pushSizeToStream(OutStream &str) const
 253 {
 254     str << _values.size();
 255 }
 256
 257 /*-------------------------------------------------------------------------*/
 258 /*                         Binary Interface                                */
 259
 260 template <class ValueTypeT, Int32 iNameSpace, class AllocT> inline
 261 SizeT MField<ValueTypeT, iNameSpace, AllocT>::getBinSize(void) const
 262 {
 263     return
 264         sizeof(UInt32) + // num elements
 265         (_values.size() ?
 266          MFieldTraits::getBinSize(&(_values[0]), _values.size()) : 0);
 267 }
 268
 269 template <class ValueTypeT, Int32 iNameSpace, class AllocT> inline
 270 void MField<ValueTypeT,
 271             iNameSpace,
 272             AllocT>::copyToBin(BinaryDataHandler &pMem) const
 273 {
 274     UInt32 n = UInt32(_values.size());
 275
 276     pMem.putValue(n);
 277
 278     if(n != 0)
 279     {
 280         MFieldTraits::copyToBin(   pMem,
 281                                 &(_values[0]),
 282                                   _values.size());
 283     }
 284 }
 285
 286 template <class ValueTypeT, Int32 iNameSpace, class AllocT> inline
 287 void MField<ValueTypeT,
 288             iNameSpace,
 289             AllocT    >::copyFromBin(BinaryDataHandler &pMem)
 290 {
 291      UInt32 n;
 292
 293      pMem  .getValue(n);
 294     _values.clear ( );
 295
 296 #ifdef __hpux
 297     FieldTypeT tmpVal;
 298
 299     _values.resize(n, tmpVal);
 300 #else
 301     _values.resize(n);
 302 #endif
 303
 304     if(n != 0)
 305     {
 306         MFieldTraits::copyFromBin(   pMem,
 307                                   &(_values[0]),
 308                                      n);
 309     }
 310 }
 311
 312 /*-------------------------------------------------------------------------*/
 313 /*                             STL Interface                               */
 314
 315 template <class ValueT, Int32 iNamespace, class AllocT> inline
 316 typename MField<ValueT,
 317                 iNamespace,
 318                 AllocT    >::iterator MField<ValueT,
 319                                              iNamespace,
 320                                              AllocT    >::begin (void)
 321 {
 322     return _values.begin();
 323 }
 324
 325 template <class ValueT, Int32 iNamespace, class AllocT> inline
 326 typename MField<ValueT,
 327                 iNamespace,
 328                 AllocT    >::iterator MField<ValueT,
 329                                              iNamespace,
 330                                              AllocT    >::end(void)
 331 {
 332     return _values.end();
 333 }
 334
 335 template <class ValueT, Int32 iNamespace, class AllocT> inline
 336 typename MField<ValueT,
 337                 iNamespace,
 338                 AllocT    >::reverse_iterator
 339     MField<ValueT,
 340            iNamespace,
 341            AllocT    >::rbegin(void)
 342 {
 343     return _values.rbegin();
 344 }
 345
 346 template <class ValueT, Int32 iNamespace, class AllocT> inline
 347 typename MField<ValueT,
 348                 iNamespace,
 349                 AllocT    >::reverse_iterator
 350     MField<ValueT,
 351            iNamespace,
 352            AllocT    >::rend(void)
 353 {
 354     return _values.rend();
 355 }
 356
 357 template <class ValueT, Int32 iNamespace, class AllocT> inline
 358 typename MField<ValueT,
 359                 iNamespace,
 360                 AllocT    >::const_iterator MField<ValueT,
 361                                                    iNamespace,
 362                                                    AllocT    >::begin(
 363                                                                     void) const
 364 {
 365     return _values.begin();
 366 }
 367
 368 template <class ValueT, Int32 iNamespace, class AllocT> inline
 369 typename MField<ValueT,
 370                 iNamespace,
 371                 AllocT    >::const_iterator MField<ValueT,
 372                                                    iNamespace,
 373                                                    AllocT>::end(void) const
 374 {
 375     return _values.end();
 376 }
 377
 378 template <class ValueT, Int32 iNamespace, class AllocT> inline
 379 typename MField<ValueT,
 380                 iNamespace,
 381                 AllocT    >::const_reverse_iterator
 382     MField<ValueT,
 383            iNamespace,
 384            AllocT>::rbegin(void) const
 385 {
 386     return _values.rbegin();
 387 }
 388
 389 template <class ValueT, Int32 iNamespace, class AllocT> inline
 390 typename MField<ValueT,
 391                 iNamespace,
 392                 AllocT    >::const_reverse_iterator
 393     MField<ValueT,
 394            iNamespace,
 395            AllocT    >::rend(void) const
 396 {
 397     return _values.rend();
 398 }
 399
 400 template <class ValueT, Int32 iNamespace, class AllocT> inline
 401 typename MField<ValueT,
 402                 iNamespace,
 403                 AllocT    >::reference MField<ValueT,
 404                                               iNamespace,
 405                                               AllocT    >::front(void)
 406 {
 407     return _values.front();
 408 }
 409
 410 template <class ValueT, Int32 iNamespace, class AllocT> inline
 411 typename MField<ValueT,
 412                 iNamespace,
 413                 AllocT    >::const_reference MField<ValueT,
 414                                                     iNamespace,
 415                                                     AllocT    >::front(
 416                                                                     void) const
 417 {
 418     return _values.front();
 419 }
 420
 421 template <class ValueT, Int32 iNamespace, class AllocT> inline
 422 typename MField<ValueT,
 423                 iNamespace,
 424                 AllocT    >::reference MField<ValueT,
 425                                               iNamespace,
 426                                               AllocT    >::back(void)
 427 {
 428     return _values.back();
 429 }
 430
 431 template <class ValueT, Int32 iNamespace, class AllocT> inline
 432 typename MField<ValueT,
 433                 iNamespace,
 434                 AllocT    >::const_reference MField<ValueT,
 435                                                     iNamespace,
 436                                                     AllocT    >::back(
 437                                                                     void) const
 438 {
 439     return _values.back();
 440 }
 441
 442 template <class ValueT, Int32 iNamespace, class AllocT> inline
 443 void MField<ValueT, iNamespace, AllocT>::clear(void)
 444 {
 445     _values.clear();
 446 }
 447
 448 template <class ValueT, Int32 iNamespace, class AllocT> inline
 449 typename MField<ValueT,
 450                 iNamespace,
 451                 AllocT    >::iterator MField<ValueT,
 452                                              iNamespace,
 453                                              AllocT    >::insert(
 454     size_type    index,
 455     ArgumentType value)
 456 {
 457     iterator posItor = _values.begin();
 458
 459     posItor += index;
 460
 461     return _values.insert(posItor, value);
 462 }
 463
 464 template <class ValueT, Int32 iNamespace, class AllocT> inline
 465 typename MField<ValueT,
 466                 iNamespace,
 467                 AllocT    >::iterator MField<ValueT,
 468                                              iNamespace,
 469                                              AllocT    >::insert(
 470     iterator pos, ArgumentType value)
 471 {
 472     return _values.insert(pos, value);
 473 }
 474
 475 template <class ValueT, Int32 iNamespace, class AllocT> inline
 476 void MField<ValueT, iNamespace, AllocT>::insert(iterator     pos,
 477                                                 size_type    n,
 478                                                 ArgumentType value)
 479 {
 480     _values.insert(pos, n, value);
 481 }
 482
 483 template <class ValueT, Int32 iNamespace, class AllocT>
 484 template <class InputIterator> inline
 485 void MField<ValueT, iNamespace, AllocT>::insert(iterator      pos,
 486                                                 InputIterator first,
 487                                                 InputIterator last )
 488 {
 489     _values.insert(pos, first, last);
 490 }
 491
 492 template <class ValueT, Int32 iNamespace, class AllocT> inline
 493 typename MField<ValueT,
 494                 iNamespace,
 495                 AllocT    >::iterator MField<ValueT,
 496                                              iNamespace,
 497                                              AllocT    >::erase(iterator pos)
 498 {
 499     return _values.erase(pos);
 500 }
 501
 502 template <class ValueT, Int32 iNamespace, class AllocT> inline
 503 void MField<ValueT,
 504             iNamespace,
 505             AllocT    >::erase(size_type index)
 506 {
 507     iterator pos = _values.begin();
 508
 509     pos += index;
 510
 511     _values.erase(pos);
 512 }
 513
 514 template <class ValueT, Int32 iNamespace, class AllocT> inline
 515 typename MField<ValueT,
 516                 iNamespace,
 517                 AllocT    >::iterator MField<ValueT,
 518                                              iNamespace,
 519                                              AllocT    >::erase(iterator first,
 520                                                                 iterator last )
 521 {
 522     return _values.erase(first, last);
 523 }
 524
 525
 526 template <class ValueT, Int32 iNamespace, class AllocT> inline
 527 typename MField<ValueT,
 528                 iNamespace,
 529                 AllocT    >::iterator MField<ValueT,
 530                                              iNamespace,
 531                                              AllocT    >::find(
 532     ArgumentType value)
 533 {
 534     return std::find(_values.begin(), _values.end(), value);
 535 }
 536
 537 template <class ValueT, Int32 iNamespace, class AllocT> inline
 538 typename MField<ValueT,
 539                 iNamespace,
 540                 AllocT    >::const_iterator MField<ValueT,
 541                                                    iNamespace,
 542                                                    AllocT    >::find(
 543     ArgumentType value) const
 544 {
 545     return std::find(_values.begin(), _values.end(), value);
 546 }
 547
 548 template <class ValueT, Int32 iNamespace, class AllocT> inline
 549 Int32 MField<ValueT, iNamespace, AllocT>::findIndex(ArgumentType value) const
 550 {
 551     const_iterator it = std::find(_values.begin(), _values.end(), value);
 552
 553     if(it != _values.end())
 554     {
 555         return it - _values.begin();
 556     }
 557     else
 558     {
 559         return -1;
 560     }
 561 }
 562
 563 template <class ValueT, Int32 iNamespace, class AllocT> inline
 564 void MField<ValueT, iNamespace, AllocT>::push_back(ArgumentType value)
 565 {
 566     _values.push_back(value);
 567 }
 568
 569 template <class ValueT, Int32 iNamespace, class AllocT> inline
 570 void MField<ValueT, iNamespace, AllocT>::resize(size_type  newsize,
 571                                                 StoredType t      )
 572 {
 573     _values.resize(newsize, t);
 574 }
 575
 576 template <class ValueT, Int32 iNamespace, class AllocT> inline
 577 void MField<ValueT, iNamespace, AllocT>::reserve(size_type newsize)
 578 {
 579     _values.reserve(newsize);
 580 }
 581
 582 template <class ValueT, Int32 iNamespace, class AllocT> inline
 583 typename MField<ValueT, iNamespace, AllocT>::size_type
 584     MField<ValueT, iNamespace, AllocT>::size(void) const
 585 {
 586     return _values.size();
 587 }
 588
 589 template <class ValueT, Int32 iNamespace, class AllocT> inline
 590 UInt32 MField<ValueT, iNamespace, AllocT>::size32(void) const
 591 {
 592     return UInt32(_values.size());
 593 }
 594
 595 template <class ValueT, Int32 iNamespace, class AllocT> inline
 596 typename MField<ValueT, iNamespace, AllocT>::size_type
 597     MField<ValueT, iNamespace, AllocT>::capacity(void) const
 598 {
 599     return _values.capacity();
 600 }
 601
 602 template <class ValueT, Int32 iNamespace, class AllocT> inline
 603 bool MField<ValueT, iNamespace, AllocT>::empty(void) const
 604 {
 605     return _values.empty();
 606 }
 607
 608 template <class FieldTypeT, Int32 fieldNameSpace, class AllocT> inline
 609 void MField<FieldTypeT, fieldNameSpace, AllocT>::swap(MField &right)
 610 {
 611     _values.swap(right._values);
 612 }
 613
 614 template <class FieldTypeT, Int32 fieldNameSpace, class AllocT> inline
 615 void MField<FieldTypeT, fieldNameSpace, AllocT>::replace(
 616     size_type index, ArgumentType value)
 617 {
 618     this->replace(this->begin() + index, value);
 619 }
 620
 621 template <class FieldTypeT, Int32 fieldNameSpace, class AllocT> inline
 622 void MField<FieldTypeT, fieldNameSpace, AllocT>::replace(
 623     iterator pos, ArgumentType value)
 624 {
 625     *pos = value;
 626 }
 627
 628 #ifdef OSG_1_COMPAT
 629 template <class FieldTypeT, Int32 fieldNameSpace, class AllocT> inline
 630 void MField<FieldTypeT, fieldNameSpace, AllocT>::addValue (ArgumentType value)
 631 {
 632     _values.push_back(value);
 633
 634 }
 635 #endif
 636
 637 /*-------------------------------------------------------------------------*/
 638 /*                           Index Operator                                */
 639
 640 template <class ValueT, Int32 iNamespace, class AllocT> inline
 641 typename MField<ValueT, iNamespace, AllocT>::reference
 642     MField<ValueT, iNamespace, AllocT>::operator [](size_type index)
 643 {
 644     return _values[index];
 645 }
 646
 647 template <class ValueT, Int32 iNamespace, class AllocT> inline
 648 typename MField<ValueT, iNamespace, AllocT>::const_reference
 649     MField<ValueT, iNamespace, AllocT>::operator [](size_type index) const
 650 {
 651     return _values[index];
 652 }
 653
 654 template <class ValueT, Int32 iNamespace, class AllocT> inline
 655 bool MField<ValueT,
 656             iNamespace,
 657             AllocT    >::operator ==(const MField &source) const
 658 {
 659     return _values == source._values;
 660 }
 661
 662 template <class ValueT, Int32 iNamespace, class AllocT> inline
 663 const MField<ValueT,
 664             iNamespace,
 665             AllocT    > &MField<ValueT,
 666                                 iNamespace,
 667                                 AllocT    >::operator =(const MField &source)
 668 {
 669     if(this == &source)
 670        return *this;
 671
 672     _values = source._values;
 673
 674     return *this;
 675 }
 676
 677 /*-------------------------------------------------------------------------*/
 678 /*                              MT Sync                                    */
 679
 680 #ifdef OSG_MT_CPTR_ASPECT
 681 template <class ValueT, Int32 iNamespace, class AllocT> inline
 682 void MField<ValueT,
 683             iNamespace,
 684             AllocT    >::syncWith(Self               &source,
 685                                   ConstFieldMaskArg   syncMode,
 686                                   UInt32              uiSyncInfo,
 687                                   AspectOffsetStore  &oOffsets  )
 688 {
 689     if(syncMode != 0x0000)
 690     {
 691         setValues  (source);
 692     }
 693     else
 694     {
 695         UInt32 uiFromAspect  = (uiSyncInfo & 0xFF000000) >> 24;
 696         UInt32 uiToAspect    = (uiSyncInfo & 0x00FF0000) >> 16;
 697
 698         bool   bTargetDelete = true;
 699
 700         if(_uiSharedWith != 0x0000)
 701         {
 702             bTargetDelete = false;
 703
 704             resolveShare(uiToAspect, oOffsets);
 705         }
 706
 707         Char8  *pOtherMem = reinterpret_cast<Char8 *>(this);
 708         Self   *pOther    = NULL;
 709         UInt32  uiShared  = source._uiSharedWith;
 710         UInt32  uiCheck   = 1;
 711
 712 //        pOtherMem -= uiToAspect * uiCopyOffset;
 713
 714         for(UInt32 i = 0; i < oOffsets.size(); ++i)
 715         {
 716             if(oOffsets[i] == -1)
 717             {
 718                 uiCheck <<= 1;
 719                 continue;
 720             }
 721
 722             if(0x0000 != (uiShared & uiCheck))
 723             {
 724                 pOther =
 725                     reinterpret_cast<Self *>(
 726                         pOtherMem + (oOffsets[i]));
 727
 728                 pOther->_uiSharedWith |= (1 << uiToAspect);
 729
 730                 uiShared &= ~uiCheck;
 731             }
 732
 733             if(0x0000 == uiShared)
 734             {
 735                 break;
 736             }
 737
 738             uiCheck <<= 1;
 739         }
 740
 741         _uiSharedWith        |= source._uiSharedWith;
 742         _uiSharedWith        |= (1 << uiFromAspect);
 743
 744         source._uiSharedWith |= (1 << uiToAspect  );
 745
 746         _values.shareValues(source._values, bTargetDelete);
 747     }
 748 }
 749
 750 template <class ValueT, Int32 iNamespace, class AllocT> inline
 751 void MField<ValueT, iNamespace, AllocT>::beginEdit(UInt32             uiAspect,
 752                                                    AspectOffsetStore &oOffsets)
 753 {
 754     if(_uiSharedWith != 0x0000)
 755     {
 756         Self   *pOther = resolveShare(uiAspect, oOffsets);
 757
 758         _values.resolveShare();
 759
 760         setValues(*pOther);
 761     }
 762 }
 763
 764
 765 template <class ValueT, Int32 iNamespace, class AllocT> inline
 766 typename MField<ValueT,
 767                 iNamespace,
 768                 AllocT    >::Self *
 769     MField<ValueT,
 770            iNamespace,
 771            AllocT    >::resolveShare(UInt32             uiAspect,
 772                                      AspectOffsetStore &oOffsets)
 773 {
 774     Char8  *pOtherMem = reinterpret_cast<Char8 *>(this);
 775     Self   *pOther    = NULL;
 776
 777     UInt32  uiShared  = _uiSharedWith;
 778     UInt32  uiCheck   = 1;
 779     UInt32  uiOwn     = 1 << uiAspect;
 780
 781     for(UInt32 i = 0; i < oOffsets.size(); ++i)
 782     {
 783         if(oOffsets[i] == -1)
 784         {
 785             uiCheck <<= 1;
 786             continue;
 787         }
 788
 789         if(0x0000 != (uiShared & uiCheck))
 790         {
 791             pOther =
 792                 reinterpret_cast<Self *>(pOtherMem + oOffsets[i]);
 793
 794             pOther->_uiSharedWith &= ~uiOwn;
 795             _uiSharedWith         &= ~uiCheck;
 796
 797             uiShared &= ~uiCheck;
 798         }
 799
 800         if(0x0000 == uiShared)
 801         {
 802             break;
 803         }
 804
 805         uiCheck <<= 1;
 806     }
 807
 808     return pOther;
 809 }
 810
 811 template <class ValueT, Int32 iNamespace, class AllocT> inline
 812 void MField<ValueT,
 813             iNamespace,
 814             AllocT    >::terminateShare(UInt32             uiAspect,
 815                                         AspectOffsetStore &oOffsets)
 816 {
 817     if(_uiSharedWith != 0x0000)
 818     {
 819         /*Self *pOther = */ resolveShare(uiAspect, oOffsets);
 820
 821         _values.resolveShare();
 822     }
 823 }
 824
 825 template <class ValueT, Int32 iNamespace, class AllocT> inline
 826 bool  MField<ValueT, iNamespace, AllocT>::isShared(void)
 827 {
 828     return _uiSharedWith != 0x0000;
 829 }
 830
 831 #endif
 832
 833
 834 template <class ValueT, Int32 iNamespace, class AllocT> inline
 835 void MField<ValueT, iNamespace, AllocT>::dump(      UInt32    uiIndent,
 836                                               const BitVector bvFlags ) const
 837 {
 838     for(UInt32 i = 0; i < uiIndent; ++i)
 839         fprintf(stderr, " ");
 840
 841     fprintf(stderr, "Share with : %08x\n", _uiSharedWith);
 842
 843     _values.dump(uiIndent, bvFlags);
 844 }
 845
 846 OSG_END_NAMESPACE
 847