Source/System/Cluster/Base/OSGRemoteAspect.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
   6  *                                                                           *
   7  *                            www.opensg.org                                 *
   8  *                                                                           *
   9  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
  10  *                                                                           *
  11 \*---------------------------------------------------------------------------*/
  12 /*---------------------------------------------------------------------------*\
  13  *                                License                                    *
  14  *                                                                           *
  15  * This library is free software; you can redistribute it and/or modify it   *
  16  * under the terms of the GNU Library General Public License as published    *
  17  * by the Free Software Foundation, version 2.                               *
  18  *                                                                           *
  19  * This library is distributed in the hope that it will be useful, but       *
  20  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  22  * Library General Public License for more details.                          *
  23  *                                                                           *
  24  * You should have received a copy of the GNU Library General Public         *
  25  * License along with this library; if not, write to the Free Software       *
  26  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  27  *                                                                           *
  28 \*---------------------------------------------------------------------------*/
  29 /*---------------------------------------------------------------------------*\
  30  *                                Changes                                    *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35  *                                                                           *
  36  *                                                                           *
  37 \*---------------------------------------------------------------------------*/
  38
  39 #include <stdlib.h>
  40 #include <stdio.h>
  41
  42 #include "OSGConfig.h"
  43 #include "OSGClusterException.h"
  44 #include "OSGFieldDescriptionBase.h"
  45 #include "OSGRemoteAspect.h"
  46 #include "OSGLog.h"
  47 #include "OSGWindow.h"
  48 #include "OSGMaterial.h"
  49 #include "OSGConnection.h"
  50 #include "OSGStatCollector.h"
  51
  52 #include <map>
  53
  54 #define OSG_REMOTE_ASPECT_SILENT 1
  55
  56 OSG_USING_NAMESPACE
  57
  58 /** \class OSG::RemoteAspect
  59  *  \ingroup GrpSystemCluster
  60  *  \brief Remote aspect controll class
  61  *
  62  * The RemoteAspecet is used to synchronize changes of FieldContainers
  63  * with remote hosts. All changes stored in the current change list
  64  * are send to a Connection.
  65  *
  66  * It is possible to send changes in both directions.
  67  *
  68  **/
  69
  70 RemoteAspect::FieldFilter  RemoteAspect::_fieldFilter;
  71
  72 StatElemDesc<StatTimeElem> RemoteAspect::statSyncTime
  73     ("remoteSyncTime", "time for scenegraph distribution");
  74
  75 /*-------------------------------------------------------------------------*/
  76 /*                            constructor destructor                       */
  77
  78 /*! Constructor
  79  */
  80
  81 RemoteAspect::RemoteAspect(UInt32 aspectId) :
  82     _aspectId(aspectId),
  83
  84     _localFC(),
  85     _remoteFC(),
  86     _localType(),
  87
  88     _sentFC(),
  89     _receivedFC(),
  90     _mappedFC(),
  91     _mappedType(),
  92
  93     _remoteAspectId(0),
  94
  95     _createdFunctors(),
  96     _destroyedFunctors(),
  97     _changedFunctors(),
  98     _statistics(NULL)
  99 {
 100 }
 101
 102 /*! Destructor
 103  */
 104 RemoteAspect::~RemoteAspect(void)
 105 {
 106     FieldContainerFactoryBase *pFactory = FieldContainerFactory::the();
 107     IdSetT::iterator           i;
 108
 109     FieldContainer            *fcPtr = NULL;
 110
 111     // subRef received field container
 112     for(i = _receivedFC.begin(); i != _receivedFC.end(); i++)
 113     {
 114         fcPtr = pFactory->getContainer(*i);
 115
 116         if(fcPtr != NULL)
 117         {
 118             callDestroyed(fcPtr);
 119
 120             fcPtr->resolveLinks();
 121         }
 122     }
 123
 124     // subRef received field container
 125     for(i = _receivedFC.begin(); i != _receivedFC.end(); i++)
 126     {
 127         fcPtr = pFactory->getContainer(*i);
 128
 129         if(fcPtr != NULL)
 130         {
 131             do
 132             {
 133                 fcPtr->subReferenceUnresolved();
 134                 fcPtr = pFactory->getContainer(*i);
 135
 136             } while(fcPtr != NULL);
 137         }
 138     }
 139 }
 140
 141 /*-------------------------------------------------------------------------*/
 142 /*                          Remote aspect functionaliy                     */
 143
 144 /*! \e receiveSync reads changes from the given connection and
 145  *  applies them to the current thread aspect.
 146  *  Functors for registered types are called, if they occur in the
 147  *  sync stream.
 148  *
 149  *  \see registerCreated registerChanged registerDeleted
 150  */
 151
 152 void RemoteAspect::receiveSync(Connection &connection, bool applyToChangelist)
 153 {
 154     bool                              finish    = false;
 155     UInt8                             cmd;
 156     FieldContainerFactoryBase        *fcFactory = FieldContainerFactory::the();
 157     FieldContainerVector              newContainers;
 158     RemoteAspectFieldContainerMapper  mapper;
 159     ChangeList                       *pChangeList =
 160         Thread::getCurrentChangeList();
 161
 162     if(_statistics)
 163     {
 164         _statistics->getElem(statSyncTime)->start();
 165     }
 166
 167     connection.selectChannel();
 168     connection.getValue(_remoteAspectId);
 169
 170     // register mapper into factory
 171     mapper._remoteAspect = this;
 172
 173     fcFactory->setMapper(&mapper);
 174
 175     do
 176     {
 177         connection.getValue(cmd);
 178
 179         switch(cmd)
 180         {
 181             case SYNCENDED:
 182             {
 183                 finish = true;
 184
 185 #ifndef OSG_REMOTE_ASPECT_SILENT
 186                 SLOG << "Receive SYNCENDED\n";
 187 #endif
 188             }
 189             break;
 190
 191             case NEWTYPE:
 192             {
 193                 receiveNewType(connection, fcFactory);
 194             }
 195             break;
 196
 197             case CREATED:
 198             {
 199                 receiveCreated(connection, fcFactory, newContainers);
 200             }
 201             break;
 202
 203             case CHANGED:
 204             {
 205                 receiveChanged(connection, fcFactory);
 206             }
 207             break;
 208
 209             case ADDREFED:
 210             {
 211                 receiveAddRefed(connection, fcFactory, pChangeList);
 212             }
 213             break;
 214
 215             case SUBREFED:
 216             {
 217                 receiveSubRefed(connection, fcFactory, pChangeList);
 218             }
 219             break;
 220
 221             case IDMAPPING:
 222             {
 223                 receiveIdMapping(connection);
 224             }
 225             break;
 226
 227             default:
 228             {
 229                 SFATAL << "Unknown tag:" << Int32(cmd) << std::endl;
 230                 throw RemoteSyncError();
 231             }
 232         }
 233     }
 234     while(!finish);
 235
 236 #ifndef OSG_REMOTE_ASPECT_SILENT
 237     PLOG << std::flush;
 238 #endif
 239
 240     pChangeList->commitDelayedSubRefs();
 241
 242 #ifdef OSG_DEBUG
 243     FieldContainerVector::const_iterator fcIt  = newContainers.begin();
 244     FieldContainerVector::const_iterator fcEnd = newContainers.end  ();
 245
 246     for(; fcIt != fcEnd; ++fcIt)
 247     {
 248         if((*fcIt)->getRefCount() <= 1)
 249         {
 250             SWARNING << "New container type '" << (*fcIt)->getType().getName()
 251                      << "' local id '" << (*fcIt)->getId()
 252                      << "' remote id '"
 253                      << static_cast<UInt32>(_remoteFC[(*fcIt)->getId()])
 254                      << "' dies because of missing ref counts."
 255                      << std::endl;
 256         }
 257     }
 258 #endif // OSG_DEBUG
 259
 260     if(applyToChangelist)
 261     {
 262         Thread::getCurrentChangeList()->commitChanges(ChangedOrigin::Sync);
 263     }
 264     else
 265     {
 266         Thread::getCurrentChangeList()->commitChangesAndClear(ChangedOrigin::Sync);
 267     }
 268
 269     // unregister mapper into factory
 270     fcFactory->setMapper(NULL);
 271
 272     if(_statistics)
 273     {
 274         _statistics->getElem(statSyncTime)->stop();
 275     }
 276 }
 277
 278 /*! All changes from changeList are send to the connecteion except
 279  *  the fields which are filtered. Filters are used to avoid transmission
 280  *  of local states. e.g. GL variables.
 281  */
 282
 283 void RemoteAspect::sendSync(Connection &connection, ChangeList *changeList)
 284 {
 285     FieldContainerFactoryBase *fcFactory = FieldContainerFactory::the();
 286
 287     if(_statistics)
 288     {
 289         _statistics->getElem(statSyncTime)->start();
 290     }
 291
 292     if(!changeList)
 293     {
 294         changeList = OSG::Thread::getCurrentChangeList();
 295     }
 296
 297     // tell my aspect id
 298     connection.putValue(_aspectId);
 299
 300     sendIdMapping(connection);
 301
 302     ChangeList::ChangedStoreConstIt changedIt  = changeList->beginCreated();
 303     ChangeList::ChangedStoreConstIt changedEnd = changeList->endCreated  ();
 304
 305     for(; changedIt != changedEnd; ++changedIt)
 306     {
 307         UInt32          localId = (*changedIt)->uiContainerId;
 308         FieldContainer *fcPtr   = fcFactory->getContainer(localId);
 309
 310         // fcPtr might be locally destroyed already or
 311         // cluster local, no need to transmit it
 312         if((fcPtr  == NULL                                     ) ||
 313            (0x0000 == (fcPtr->getFieldFlags()->_bNamespaceMask &
 314                        FCLocal::Cluster                         ))  )
 315         {
 316             continue;
 317         }
 318
 319         if((*changedIt)->uiEntryDesc == ContainerChangeEntry::Create)
 320         {
 321             sendCreated(connection, fcPtr);
 322         }
 323     }
 324
 325     changedIt  = changeList->begin();
 326     changedEnd = changeList->end  ();
 327
 328     for(; changedIt != changedEnd; ++changedIt)
 329     {
 330         UInt32          localId = (*changedIt)->uiContainerId;
 331         FieldContainer *fcPtr   = fcFactory->getContainer(localId);
 332
 333         // fcPtr might be cluster local, no need to transmit it.
 334         // but we need to transmit subrefs for locally destroyed container
 335         // so this test is different from the one above!
 336         if((fcPtr  != NULL                                      )  &&
 337            (0x0000 == (fcPtr->getFieldFlags()->_bNamespaceMask &
 338                        FCLocal::Cluster                         ))   )
 339         {
 340             continue;
 341         }
 342
 343         if((*changedIt)->uiEntryDesc == ContainerChangeEntry::AddReference)
 344         {
 345             sendAddRefed(connection, fcPtr, localId);
 346         }
 347         else if((*changedIt)->uiEntryDesc == ContainerChangeEntry::SubReference)
 348         {
 349             sendSubRefed(connection, fcPtr, localId);
 350         }
 351         else if((*changedIt)->uiEntryDesc == ContainerChangeEntry::Change &&
 352                 fcPtr                     != NULL                           )
 353         {
 354             sendChanged(connection, fcPtr, (*changedIt)->whichField);
 355         }
 356     }
 357
 358     UInt8 cmd = SYNCENDED;
 359     connection.putValue(cmd);
 360
 361 #ifndef OSG_REMOTE_ASPECT_SILENT
 362     SLOG << "Send SYNCENDED" << std::endl;
 363 #endif
 364
 365     // write buffer
 366     connection.flush();
 367
 368     if(_statistics)
 369     {
 370         _statistics->getElem(statSyncTime)->stop();
 371     }
 372 }
 373
 374 /*! The given functor is called when a create of the specified type
 375  *  is received.
 376  *
 377  *  \see receiveSync
 378  */
 379
 380 void RemoteAspect::registerCreated(const FieldContainerType &type,
 381                                    const Functor            &func)
 382 {
 383     while(type.getId() >= _createdFunctors.size())
 384     {
 385         _createdFunctors.push_back(&_defaultCreatedFunction);
 386     }
 387
 388     _createdFunctors[type.getId()] = func;
 389 }
 390
 391 /*! The given functor is called when a destroy of the specified type
 392  *  is received.
 393  *
 394  *  \see receiveSync
 395  */
 396
 397 void RemoteAspect::registerDestroyed(const FieldContainerType &type,
 398                                      const Functor &func)
 399 {
 400     while(type.getId() >= _destroyedFunctors.size())
 401     {
 402         _destroyedFunctors.push_back(&_defaultDestroyedFunction);
 403     }
 404
 405     _destroyedFunctors[type.getId()] = func;
 406 }
 407
 408 /*! The given functor is called when a change of the specified type
 409  *  is received.
 410  *
 411  *  \see receiveSync
 412  */
 413
 414 void RemoteAspect::registerChanged(const FieldContainerType &type,
 415                                    const Functor &func)
 416 {
 417     while(type.getId() >= _changedFunctors.size())
 418     {
 419         _changedFunctors.push_back(&_defaultChangedFunction);
 420     }
 421
 422     _changedFunctors[type.getId()] = func;
 423 }
 424
 425 /*! add a new field filter. The given fieldmaks will not be transfered
 426  */
 427
 428 /*-------------------------------------------------------------------------*/
 429 /*                          statistics                                     */
 430
 431 /*! add a new field filter. The given fieldmaks will not be transfered
 432  */
 433 void RemoteAspect::addFieldFilter(UInt32 typeId, BitVector mask)
 434 {
 435     _fieldFilter[typeId] |= mask;
 436 }
 437
 438 /*! remove the filter for the given type and mask
 439  */
 440 void RemoteAspect::subFieldFilter(UInt32 typeId, BitVector mask)
 441 {
 442     _fieldFilter[typeId] &= ~mask;
 443 }
 444
 445 /*! Set statistics collector
 446  */
 447
 448 void RemoteAspect::setStatistics(StatCollector *statistics)
 449 {
 450     OSG::setRefd(_statistics, statistics);
 451 }
 452
 453 /*-------------------------------------------------------------------------*/
 454 /*                        protected helpers                                */
 455
 456 /*! Call created functor for a given FieldContainer
 457  *
 458  *  \see registerCreated
 459  */
 460
 461 bool RemoteAspect::callCreated(FieldContainer * const fcp)
 462 {
 463     bool    result;
 464     UInt32  uiFunctorIndex = fcp->getType().getId();
 465
 466     if(uiFunctorIndex < _createdFunctors.size())
 467     {
 468         result = _createdFunctors[uiFunctorIndex](fcp, this);
 469     }
 470     else
 471     {
 472         result = _defaultCreatedFunction(fcp, this);
 473     }
 474
 475     return result;
 476 }
 477
 478 /*! Call destroyed functor for a given FieldContainer
 479  *
 480  *  \see registerDestroyed
 481  */
 482
 483 bool RemoteAspect::callDestroyed(FieldContainer * const fcp)
 484 {
 485     bool    result;
 486     UInt32  uiFunctorIndex = fcp->getType().getId();
 487
 488     if(uiFunctorIndex < _destroyedFunctors.size())
 489     {
 490         result = _destroyedFunctors[uiFunctorIndex](fcp, this);
 491     }
 492     else
 493     {
 494         result = _defaultDestroyedFunction(fcp, this);
 495     }
 496
 497     return result;
 498 }
 499
 500 /*! Call changed functor for a given FieldContainer
 501  *
 502  *  \see registerChanged
 503  */
 504
 505 bool RemoteAspect::callChanged(FieldContainer * const fcp)
 506 {
 507     bool    result;
 508     UInt32  uiFunctorIndex = fcp->getType().getId();
 509
 510     if(uiFunctorIndex < _changedFunctors.size())
 511     {
 512         result = _changedFunctors[uiFunctorIndex](fcp, this);
 513     }
 514     else
 515     {
 516         result = _defaultChangedFunction(fcp, this);
 517     }
 518
 519     return result;
 520 }
 521
 522 /*-------------------------------------------------------------------------*/
 523 /* Receive Helper Functions                                                */
 524
 525 void RemoteAspect::receiveNewType(Connection                &con,
 526                                   FieldContainerFactoryBase *fcFactory)
 527 {
 528     UInt32      remoteTypeId = 0;
 529     UInt32      localTypeId  = 0;
 530     std::string typeName;
 531
 532     con.getValue(remoteTypeId);
 533     con.getValue(typeName);
 534
 535     FieldContainerType *fcType = fcFactory->findType(typeName.c_str());
 536
 537     if(fcType != NULL)
 538     {
 539         localTypeId = fcType->getId();
 540
 541         _localType[remoteTypeId] = localTypeId;
 542     }
 543     else
 544     {
 545         SWARNING << "Unrecognized remote type '" << typeName
 546                  << "' remote type id '" << remoteTypeId
 547                  << "'." << std::endl;
 548     }
 549
 550 #ifndef OSG_REMOTE_ASPECT_SILENT
 551     SLOG << "Receive NEWTYPE: type name '" << typeName
 552          << "' type id (r/l) '" << remoteTypeId
 553          << "/" << localTypeId << "'\n";
 554 #endif
 555 }
 556
 557 void RemoteAspect::receiveCreated(Connection                &con,
 558                                   FieldContainerFactoryBase *fcFactory,
 559                                   FieldContainerVector      &newContainers)
 560 {
 561     UInt32 remoteTypeId = 0;
 562     UInt32 localTypeId  = 0;
 563     UInt32 remoteId     = 0;
 564
 565     con.getValue(remoteTypeId);
 566     con.getValue(remoteId);
 567
 568     LocalTypeMapT::const_iterator  localTypeIt = _localType.find(remoteTypeId);
 569     FieldContainerType            *fcType      = NULL;
 570     FieldContainerUnrecPtr         fcPtr       = NULL;
 571
 572     if(localTypeIt != _localType.end())
 573     {
 574         UInt64 fullRemoteId = getFullRemoteId(remoteId);
 575
 576         if(_localFC.find(fullRemoteId) == _localFC.end())
 577         {
 578             localTypeId = localTypeIt->second;
 579             fcType      = fcFactory->findType(localTypeId);
 580             fcPtr       = fcType->createContainer();
 581
 582             // remove this node, when aspect is removed
 583             _receivedFC.insert(fcPtr->getId());
 584
 585             // local <-> remote mapping
 586             _localFC [fullRemoteId  ] = fcPtr->getId();
 587             _remoteFC[fcPtr->getId()] = fullRemoteId;
 588
 589             callCreated(fcPtr);
 590
 591             newContainers.push_back(fcPtr);
 592
 593 #ifndef OSG_REMOTE_ASPECT_SILENT
 594             SLOG << "Receive CREATED: type (r/l) '" << remoteTypeId
 595                  << "/" << localTypeId
 596                  << "' id (r/l) '" << remoteId << "/"
 597                  << (fcPtr  != NULL ? fcPtr->getId()     : 0)
 598                  << "' type name '"
 599                  << (fcType != NULL ? fcType->getName() : "")
 600                  << "'\n";
 601 #endif
 602         }
 603         else
 604         {
 605             SWARNING << "Already created a local container ("
 606                      << _localFC[fullRemoteId] << ") for "
 607                      << "remote container id '" << remoteId
 608                      << "'" << std::endl;
 609         }
 610     }
 611     else
 612     {
 613         SWARNING << "Unknown (remote) type id '" << remoteTypeId
 614                  << "' for (remote) container id '" << remoteId
 615                  << "'" << std::endl;
 616     }
 617 }
 618
 619 void RemoteAspect::receiveChanged(Connection                &con,
 620                                   FieldContainerFactoryBase *fcFactory)
 621 {
 622     UInt32          remoteId  = 0;
 623     UInt32          localId   = 0;
 624     BitVector       fieldMask = 0;
 625     UInt32          len       = 0;
 626     FieldContainer *fcPtr     = NULL;
 627
 628     con.getValue(remoteId);
 629     con.getValue(fieldMask);
 630     con.getValue(len);
 631
 632     if(getLocalId(remoteId, localId))
 633     {
 634         fcPtr = fcFactory->getContainer(localId);
 635
 636 #ifndef OSG_REMOTE_ASPECT_SILENT
 637         SLOG << "Receive CHANGED: id (r/l) '" << remoteId
 638              << "/" << localId
 639              << "' mask '0x"
 640              << std::hex << fieldMask << std::dec
 641              << "' len '" << len
 642              << "' type name '"
 643              << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 644              << "'\n";
 645 #endif
 646
 647         if(fcPtr == NULL)
 648         {
 649             clearFCMapping(localId, remoteId);
 650
 651             char dummy;
 652
 653             while(len--)
 654                 con.get(&dummy, 1);
 655         }
 656         else
 657         {
 658             fcPtr->copyFromBin(con, fieldMask);
 659
 660             callChanged(fcPtr);
 661         }
 662     }
 663     else
 664     {
 665         char dummy;
 666
 667         SWARNING << "Can not do CHANGED for unknown FC remote id "
 668                  << remoteId
 669                  << " skip "
 670                  << len
 671                  << " bytes."
 672                  << std::endl;
 673
 674         while(len--)
 675             con.get(&dummy, 1);
 676     }
 677 }
 678
 679 void RemoteAspect::receiveAddRefed(Connection                &con,
 680                                    FieldContainerFactoryBase *fcFactory,
 681                                    ChangeList                *pChangeList)
 682 {
 683     UInt32          remoteId = 0;
 684     UInt32          localId  = 0;
 685     FieldContainer *fcPtr    = NULL;
 686
 687     con.getValue(remoteId);
 688
 689     if(getLocalId(remoteId, localId))
 690     {
 691         fcPtr = fcFactory->getContainer(localId);
 692
 693 #ifndef OSG_REMOTE_ASPECT_SILENT
 694         SLOG << "Receive ADDREFED: id (r/l) '" << remoteId
 695              << "/" << localId << "' type name '"
 696              << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 697              << "'\n";
 698 #endif
 699
 700         if(fcPtr == NULL)
 701         {
 702             clearFCMapping(localId, remoteId);
 703         }
 704         else
 705         {
 706             RecordedRefCountPolicy::addRef(fcPtr);
 707         }
 708     }
 709     else
 710     {
 711         SWARNING << "Can not do ADDREFED for unknown FC remote id "
 712                  << remoteId << std::endl;
 713     }
 714 }
 715
 716 void RemoteAspect::receiveSubRefed(Connection                &con,
 717                                    FieldContainerFactoryBase *fcFactory,
 718                                    ChangeList                *pChangeList)
 719 {
 720     UInt32          remoteId = 0;
 721     UInt32          localId  = 0;
 722     FieldContainer *fcPtr    = NULL;
 723
 724     con.getValue(remoteId);
 725
 726     if(getLocalId(remoteId, localId))
 727     {
 728         fcPtr = fcFactory->getContainer(localId);
 729
 730 #ifndef OSG_REMOTE_ASPECT_SILENT
 731         SLOG << "Receive SUBREFED: id (r/l) '" << remoteId
 732              << "/" << localId << "' type name '"
 733              << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 734              << "'\n";
 735 #endif
 736
 737         if(fcPtr == NULL)
 738         {
 739             clearFCMapping(localId, remoteId);
 740         }
 741         else
 742         {
 743             pChangeList->addDelayedSubRef<RecordedRefCountPolicy>(fcPtr);
 744         }
 745     }
 746     else
 747     {
 748         SWARNING << "Can not do SUBREFED for unknown FC remote id "
 749                  << remoteId << std::endl;
 750     }
 751 }
 752
 753 void RemoteAspect::receiveIdMapping(Connection &con)
 754 {
 755     UInt32 remoteId    = 0;
 756     UInt32 localId     = 0;
 757     UInt32 localAspect = 0;
 758
 759     con.getValue(remoteId);
 760     con.getValue(localAspect);
 761     con.getValue(localId);
 762
 763 #ifndef OSG_REMOTE_ASPECT_SILENT
 764     SLOG << "Receive IDMAPPING: id (r/l) '" << remoteId
 765          << "/" << localId
 766          << "' local aspect '"              << localAspect
 767          << "'\n";
 768 #endif
 769
 770     if(localAspect != _aspectId)
 771     {
 772         SFATAL << "ID mapping for wrong aspect" << std::endl;
 773     }
 774
 775     // local <-> remote mapping
 776     UInt64 fullRemoteId    = getFullRemoteId(remoteId);
 777     _localFC[fullRemoteId] = localId;
 778 }
 779
 780 /*-------------------------------------------------------------------------*/
 781 /* Send Helper Functions                                                   */
 782
 783 void RemoteAspect::sendCreated(Connection     &con,
 784                                FieldContainer *fcPtr)
 785 {
 786     UInt8  cmd         = 0;
 787     UInt32 localTypeId = fcPtr->getTypeId();
 788     UInt32 localId     = fcPtr->getId();
 789
 790     if(_mappedType.count(localTypeId) == 0)
 791     {
 792         _mappedType.insert(localTypeId);
 793
 794         const std::string &typeName = fcPtr->getType().getName();
 795
 796 #ifndef OSG_REMOTE_ASPECT_SILENT
 797         SLOG << "Send NEWTYPE: type name '" << typeName
 798              << "' type id '"               << localTypeId
 799              << "'\n";
 800 #endif
 801
 802         cmd = NEWTYPE;
 803         con.putValue(cmd);
 804         con.putValue(localTypeId);
 805         con.putValue(typeName);
 806     }
 807
 808 #ifndef OSG_REMOTE_ASPECT_SILENT
 809     SLOG << "Send CREATED: type name '" << fcPtr->getType().getName()
 810          << "' type id '"               << localTypeId
 811          << "' id '"                    << localId
 812          << "'\n";
 813 #endif
 814
 815     cmd = CREATED;
 816     con.putValue(cmd);
 817     con.putValue(localTypeId);
 818     con.putValue(localId);
 819
 820     // sent container to create
 821     _sentFC.insert(localId);
 822
 823     // fc is known by remote
 824     _mappedFC.insert(localId);
 825 }
 826
 827 void RemoteAspect::sendChanged(Connection     &con,
 828                                FieldContainer *fcPtr,
 829                                BitVector       changedMask)
 830 {
 831     UInt32 localId = fcPtr->getId();
 832
 833     if(_mappedFC.count(localId) == 0)
 834     {
 835 #ifndef OSG_REMOTE_ASPECT_SILENT
 836         SLOG << "Container id '" << localId
 837              << "' type '" << fcPtr->getType().getName()
 838              << "' is not transmitted, dropping 'CHANGED'"
 839              << std::endl;
 840 #endif
 841         return;
 842     }
 843
 844     BitVector fieldMask =
 845         changedMask & fcPtr->getFieldFlags()->_bClusterLocalFlags;
 846
 847     // apply field filter
 848     FieldFilter::const_iterator filterI =
 849         _fieldFilter.find(fcPtr->getType().getId());
 850
 851     if(filterI != _fieldFilter.end())
 852     {
 853         fieldMask &= TypeTraits<BitVector>::BitsSet ^ filterI->second;
 854     }
 855
 856     if(fieldMask)
 857     {
 858         UInt8  cmd = CHANGED;
 859         UInt32 len = UInt32(fcPtr->getBinSize(fieldMask));
 860
 861 #ifndef OSG_REMOTE_ASPECT_SILENT
 862         SLOG << "Send CHANGED: type name '" << fcPtr->getType().getName()
 863              << "' type id '"               << fcPtr->getType().getId()
 864              << "' id '"                    << localId
 865              << "' mask '0x"                << std::hex << fieldMask << std::dec
 866              << "' len '"                   << len
 867              << "'\n";
 868 #endif
 869
 870         con.putValue(cmd      );
 871         con.putValue(localId  ); // id
 872         con.putValue(fieldMask); // mask
 873         con.putValue(len      );
 874
 875         fcPtr->copyToBin(con, fieldMask);
 876     }
 877 }
 878
 879 void RemoteAspect::sendAddRefed(Connection     &con,
 880                                 FieldContainer *fcPtr,
 881                                 UInt32          localId)
 882 {
 883     if(_mappedFC.count(localId) == 0)
 884     {
 885 #ifndef OSG_REMOTE_ASPECT_SILENT
 886         SLOG << "Container type '"
 887              << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 888              << "' id '" << localId
 889              << "' is not transmitted, dropping 'ADDREF'"
 890              << std::endl;
 891 #endif
 892         return;
 893     }
 894
 895 #ifndef OSG_REMOTE_ASPECT_SILENT
 896     SLOG << "Send ADDREFD: type name '"
 897          << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 898          << "' id '" << localId << "'\n";
 899 #endif
 900
 901     UInt8 cmd = ADDREFED;
 902     con.putValue(cmd    );
 903     con.putValue(localId);
 904 }
 905
 906 void RemoteAspect::sendSubRefed(Connection     &con,
 907                                 FieldContainer *fcPtr,
 908                                 UInt32          localId)
 909 {
 910     if(_mappedFC.count(localId) == 0)
 911     {
 912 #ifndef OSG_REMOTE_ASPECT_SILENT
 913         SLOG << "Container type '"
 914              << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 915              << "' id '" << localId
 916              << "' is not transmitted, dropping 'SUBREF'"
 917              << std::endl;
 918 #endif
 919         return;
 920     }
 921
 922 #ifndef OSG_REMOTE_ASPECT_SILENT
 923     SLOG << "Send SUBREFD: type name '"
 924          << (fcPtr != NULL ? fcPtr->getType().getName() : "")
 925          << "' id '" << localId << "'\n";
 926 #endif
 927
 928     UInt8 cmd = SUBREFED;
 929     con.putValue(cmd    );
 930     con.putValue(localId);
 931 }
 932
 933 /*! This is called if a fc was edited that was created by another
 934     aspect
 935  */
 936 void RemoteAspect::sendIdMapping(Connection &con)
 937 {
 938     UInt8                        cmd         = IDMAPPING;
 939     UInt32                       remoteId;
 940     UInt32                       remoteAspect;
 941     RemoteFCMapT::const_iterator remoteFCIt  = _remoteFC.begin();
 942     RemoteFCMapT::const_iterator remoteFCEnd = _remoteFC.end  ();
 943
 944     for(; remoteFCIt != remoteFCEnd; ++remoteFCIt)
 945     {
 946         remoteId     = UInt32(remoteFCIt->second);
 947         remoteAspect = UInt32(remoteFCIt->second >> 32);
 948
 949 #ifndef OSG_REMOTE_ASPECT_SILENT
 950         SLOG << "Send IDMAPPING: localId '" << remoteFCIt->first
 951              << "' remoteAspect '"          << remoteAspect
 952              << "' remoteId '"              << remoteId
 953              << "'\n";
 954 #endif
 955
 956         con.putValue(cmd              );
 957         con.putValue(remoteFCIt->first);
 958         con.putValue(remoteAspect     );
 959         con.putValue(remoteId         );
 960
 961         _mappedFC.insert(remoteFCIt->first);
 962     }
 963
 964     _remoteFC.clear();
 965 }
 966
 967 /*-------------------------------------------------------------------------*/
 968 /* Helper Functions                                                        */
 969
 970 /*! clear maps from local id
 971  */
 972
 973 void RemoteAspect::clearFCMapping(UInt32 localId,UInt32 remoteId)
 974 {
 975     _mappedFC.erase(localId);
 976     _sentFC  .erase(localId);
 977
 978     _receivedFC.erase(localId);
 979
 980     if(!remoteId)
 981     {
 982         RemoteFCMapT::iterator remoteFCI=_remoteFC.find(localId);
 983
 984         if(remoteFCI != _remoteFC.end())
 985             remoteId=static_cast<UInt32>(remoteFCI->second);
 986     }
 987
 988     RemoteFCMapT::iterator remoteFCI=_remoteFC.find(localId);
 989
 990     if(remoteFCI != _remoteFC.end())
 991         _remoteFC.erase(remoteFCI);
 992
 993     LocalFCMapT::iterator localFCI=_localFC.find(remoteId);
 994
 995     if(localFCI != _localFC.end())
 996         _localFC.erase(localFCI);
 997 }
 998
 999 /*! get local id mapped from remote id
1000  */
1001
1002 bool RemoteAspect::getLocalId(UInt32  remoteId,
1003                               UInt32 &localId)
1004 {
1005     UInt64                fullRemoteId =  getFullRemoteId(remoteId);
1006     LocalFCMapT::iterator localFCI     = _localFC.find(fullRemoteId);
1007
1008     if( localFCI != _localFC.end() )
1009     {
1010         localId=localFCI->second;
1011         return true;
1012     }
1013     else
1014     {
1015         return false;
1016     }
1017 }
1018
1019 UInt64 RemoteAspect::getFullRemoteId(UInt32 fcId)
1020 {
1021     UInt64 remoteId=_remoteAspectId;
1022
1023     remoteId <<= 32;
1024     remoteId |=  fcId;
1025
1026     return remoteId;
1027 }
1028
1029 /*-------------------------------------------------------------------------*\
1030  -  private                                                                -
1031 \*-------------------------------------------------------------------------*/
1032
1033 #ifdef __sgi
1034 /* fcp is used only if the FDEBUG macro is not removed by the
1035    proprocessor. Switch off error for unused fcp parameter. */
1036 #pragma set woff 3201
1037 #endif
1038
1039 /*! Default create functor
1040  */
1041
1042 bool RemoteAspect::_defaultCreatedFunction(FieldContainer * const fcp,
1043                                            RemoteAspect   *          )
1044 {
1045     FDEBUG(("Created:%s %d\n",
1046             fcp->getType().getCName(),
1047             fcp->getId()))
1048
1049     return true;
1050 }
1051
1052 /*! Default destroyed functor
1053  */
1054
1055 bool RemoteAspect::_defaultDestroyedFunction(FieldContainer * const fcp,
1056                                              RemoteAspect   *          )
1057 {
1058     FDEBUG(("Destroyed:%s %d\n",
1059             fcp->getType().getCName(),
1060             fcp->getId()))
1061
1062     return true;
1063 }
1064
1065 /*! Default changed functor
1066  */
1067
1068 bool RemoteAspect::_defaultChangedFunction(FieldContainer * const fcp,
1069                                            RemoteAspect   *          )
1070 {
1071     FDEBUG(("Changed:%s %d\n",
1072             fcp->getType().getCName(),
1073             fcp->getId()))
1074
1075     return true;
1076 }
1077
1078 #ifdef __sgi
1079 #pragma reset woff 3201
1080 #endif
1081
1082 /*! Field container id mapper. This mapper maps remote field
1083  *  container id to local ids.
1084  */
1085
1086 UInt32 RemoteAspectFieldContainerMapper::map(UInt32 uiId) const
1087 {
1088     UInt32                                    mappedId;
1089     RemoteAspect::LocalFCMapT::const_iterator i;
1090
1091     i = _remoteAspect->_localFC.find(_remoteAspect->getFullRemoteId(uiId));
1092
1093     if(i == _remoteAspect->_localFC.end())
1094     {
1095         SWARNING << "Can't find container id:" << uiId << std::endl;
1096         mappedId = 0;
1097     }
1098     else
1099     {
1100         mappedId = i->second;
1101     }
1102
1103     FDEBUG(("Map: %d to %d\n", uiId, mappedId))
1104
1105     return mappedId;
1106 }
1107