Source/System/FileIO/OSB/OSGOSBRootElement.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                   Copyright (C) 2007 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 "OSGOSBRootElement.h"
  40
  41 #include "OSGOSBElementFactory.h"
  42 #include "OSGContainerPtrFuncs.h"
  43
  44 #include "OSGAttachmentContainer.h"
  45 #include "OSGAttachment.h"
  46 #include "OSGFieldContainerSFields.h"
  47
  48 OSG_USING_NAMESPACE
  49
  50 /*-------------------------------------------------------------------------*/
  51 /* OSBRootElement                                                         */
  52 /*-------------------------------------------------------------------------*/
  53
  54 /*! \class OSG::OSBRootElement
  55     The root element is different from the other elements for it is not
  56     responsible for loading a certain type of FieldContainer but instead holds
  57     the shared state of the OSB IO subsystem. All elements (including the
  58     root element itself) have a pointer to it and can access the shared state
  59     through it.
  60  */
  61
  62 /*-------------------------------------------------------------------------*/
  63 /* Static members                                                          */
  64
  65 OSBElementRegistrationHelper<OSBRootElement>
  66     OSBRootElement::_regHelper =
  67         OSBElementRegistrationHelper<OSBRootElement>("RootElement");
  68
  69 /*-------------------------------------------------------------------------*/
  70 /* Constructor                                                             */
  71
  72 /*! Constructor.
  73  */
  74 OSBRootElement::OSBRootElement(OSBRootElement * /* root */)
  75     : Inherited(this, Inherited::OSGOSBHeaderVersion200)
  76 {
  77     // nothing to do.
  78 }
  79
  80 /*-------------------------------------------------------------------------*/
  81 /* Destructor                                                              */
  82
  83 /*! Destructor.
  84  */
  85 OSBRootElement::~OSBRootElement(void)
  86 {
  87     // nothing to do.
  88 }
  89
  90 /*-------------------------------------------------------------------------*/
  91 /* Reading                                                                 */
  92
  93 /*! Initializes this root element for a read operation from \a inStream.
  94     This must be called before OSBRootElement::read(const std::string&).
  95
  96     \param[in] inStream Stream to read data from.
  97  */
  98 void
  99 OSBRootElement::initialiseRead(std::istream &inStream)
 100 {
 101     _readHandler = new BinaryReadHandler(inStream);
 102
 103     _elements     .clear();
 104     _readIdMap    .clear();
 105     _readPtrFields.clear();
 106 }
 107
 108 /*! Performs clean up tasks after a read operation. This must be called after
 109     OSBRootElement::postRead(void).
 110  */
 111 void
 112 OSBRootElement::terminateRead(void)
 113 {
 114     ElementListIt eI = editElementList().begin();
 115     ElementListIt eE = editElementList().end  ();
 116
 117     for(; eI != eE; ++eI)
 118     {
 119         OSBElementFactory::the()->release(*eI);
 120     }
 121
 122     _elements     .clear();
 123     _readIdMap    .clear();
 124     _readPtrFields.clear();
 125
 126     delete _readHandler;
 127     _readHandler = 0;
 128 }
 129
 130 /*! Reads from the stream set by a preceding call to initialiseRead. Since the
 131     root element is the first one created it reads the file header and
 132     creates the elements to read the data following the header.
 133
 134     \param[in] typeName The argument is ignored.
 135  */
 136 void
 137 OSBRootElement::read(const std::string &/*typeName*/)
 138 {
 139     OSG_OSB_LOG(("OSBRootElement::read\n"));
 140
 141     BinaryReadHandler *rh           = getReadHandler();
 142     std::string        headerMarker;
 143
 144     rh->getValue(headerMarker);
 145
 146     if(headerMarker == OSGOSB_HEADER_ID_1)
 147     {
 148         OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n",
 149                 OSGOSBHeaderVersion100));
 150         setHeaderVersion(OSGOSBHeaderVersion100);
 151     }
 152     else if(headerMarker == OSGOSB_HEADER_ID_2)
 153     {
 154         OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n",
 155                 OSGOSBHeaderVersion200));
 156         setHeaderVersion(OSGOSBHeaderVersion200);
 157     }
 158 //     else if(headerMarker == OSGOSB_HEADER_ID_201)
 159 //     {
 160 //         OSG_OSB_LOG(("OSBRootElement::read: Header version: [%u]\n",
 161 //                 OSGOSBHeaderVersion201));
 162 //         setHeaderVersion(OSGOSBHeaderVersion201);
 163 //     }
 164     else
 165     {
 166         FWARNING(("OSBRootElement::read: Unrecognized file header, could not "
 167                   "load file.\n"));
 168         return;
 169     }
 170
 171     std::string headerName;
 172     rh->getValue(headerName);
 173     std::string headerOptions;
 174     rh->getValue(headerOptions);
 175     UInt64 fileSize;
 176     rh->getValue(fileSize);
 177
 178     OSG_OSB_LOG(("OSBRootElement::read: headerName: [%s]\n",
 179             headerName.c_str()));
 180     OSG_OSB_LOG(("OSBRootElement::read: headerOptions: [%s]\n",
 181             headerOptions.c_str()));
 182     OSG_OSB_LOG(("OSBRootElement::read: fileSize: [%" PRISize "]\n",
 183             fileSize));
 184
 185     std::string     fcTypeName;
 186     UInt32          fcIdFile;    // id used in the file
 187     UInt32          fcIdSystem;  // id used in the system
 188     OSBElementBase *elem;
 189
 190     while(true)
 191     {
 192         if(!readFieldContainerHeader(fcTypeName, fcIdFile))
 193             break;
 194
 195         OSG_OSB_LOG(("OSBRootElement::read: fcTypeName [%s] fcIdFile: [%u]\n",
 196                 fcTypeName.c_str(), fcIdFile));
 197
 198         elem = OSBElementFactory::the()->acquire(fcTypeName, this);
 199         elem->setFCIdFile(fcIdFile  );
 200         elem->read       (fcTypeName);
 201
 202         if(elem->getContainer() != NULL)
 203         {
 204             fcIdSystem = elem->getContainer()->getId();
 205
 206             OSG_OSB_LOG(("OSBRootElement::read: fcIdFile: [%u] fcIdSystem: [%u]\n",
 207                     fcIdFile, fcIdSystem));
 208
 209             editIdMap().insert(
 210                 FieldContainerIdMap::value_type(fcIdFile, fcIdSystem));
 211
 212             if(getContainer() == NULL)
 213             {
 214                 setContainer(elem->getContainer());
 215             }
 216
 217             editElementList().push_back(elem                          );
 218             editIdElemMap  ().insert   (std::make_pair(fcIdFile, elem));
 219         }
 220     }
 221 }
 222
 223 /*! Performs post processing for all elements created during the previous
 224     call to read.
 225     Specifically all these elements have their postRead function called and
 226     afterwards pointer field remapping is performed. This process fills all
 227     fields that hold pointers to FieldContainers with the correct values.
 228  */
 229 void
 230 OSBRootElement::postRead(void)
 231 {
 232     OSG_OSB_LOG(("OSBRootElement::postRead\n"));
 233
 234     ElementListConstIt elemIt  = getElementList().begin();
 235     ElementListConstIt elemEnd = getElementList().end  ();
 236
 237     for(; elemIt != elemEnd; ++elemIt)
 238     {
 239         (*elemIt)->postRead();
 240     }
 241
 242     dumpIdMap();
 243
 244     PtrFieldListConstIt ptrFieldIt  = getPtrFieldList().begin();
 245     PtrFieldListConstIt ptrFieldEnd = getPtrFieldList().end  ();
 246
 247     for(; ptrFieldIt != ptrFieldEnd; ++ptrFieldIt)
 248     {
 249         mapPtrField(*ptrFieldIt);
 250     }
 251
 252     this->postMap();
 253 }
 254
 255 void OSBRootElement::postMap(void)
 256 {
 257     OSG_OSB_LOG(("OSBRootElement::postMap\n"));
 258
 259     ElementListConstIt elemIt  = getElementList().begin();
 260     ElementListConstIt elemEnd = getElementList().end  ();
 261
 262     for(; elemIt != elemEnd; ++elemIt)
 263     {
 264         (*elemIt)->postMap();
 265     }
 266 }
 267
 268 /*-------------------------------------------------------------------------*/
 269 /* Writing                                                                 */
 270
 271 /*! Initializes this root element for a write operation to \a outStream.
 272     This must be called before
 273     OSBRootElement::preWrite(const FieldContainerPtr&).
 274
 275     \param[in] outStream Stream to write data to.
 276  */
 277 void
 278 OSBRootElement::initialiseWrite(std::ostream &outStream)
 279 {
 280     _writeHandler = new BinaryWriteHandler(outStream);
 281
 282     _writeFCList.clear();
 283     _writeIdSet .clear();
 284 }
 285
 286 /*! Performs clean up tasks after a write operation. This must be called after
 287     OSBRootElement::write(void).
 288  */
 289 void
 290 OSBRootElement::terminateWrite(void)
 291 {
 292     ElementListIt eI = editElementList().begin();
 293     ElementListIt eE = editElementList().end  ();
 294
 295     for(; eI != eE; ++eI)
 296     {
 297         OSBElementFactory::the()->release(*eI);
 298     }
 299
 300     _elements   .clear();
 301     _writeFCList.clear();
 302     _writeIdSet .clear();
 303
 304     _writeHandler->flush();
 305
 306     delete _writeHandler;
 307     _writeHandler = 0;
 308 }
 309
 310 /*! Collects all containers that are reachable from \a fc and schedules them
 311     for writing. For each container an approriate element is created and
 312     its preWrite method is called, thus recursively discovering all reachable
 313     containers.
 314
 315     \param[in] fc FieldContainer that is inspected for reachable containers.
 316  */
 317 void
 318 OSBRootElement::preWrite(FieldContainer * const fc)
 319 {
 320     OSG_OSB_LOG(("OSBRootElement::preWrite\n"));
 321
 322     if(fc == NULL)
 323         return;
 324
 325     const std::string    &typeName = fc->getType().getName();
 326           OSBElementBase *elem     = OSBElementFactory::the()->acquire(
 327         typeName, this);
 328
 329     editElementList().push_back(elem);
 330     elem->setContainer(fc         );
 331     elem->setFCIdFile (fc->getId());
 332     elem->preWrite    (fc         );
 333 }
 334
 335 /*! Writes the containers collected with the previous call to preWrite to the
 336     stream set by initialiseWrite.
 337     First the file header is written, then for each element created during
 338     preWrite the write function is called.
 339  */
 340 void
 341 OSBRootElement::write(void)
 342 {
 343     OSG_OSB_LOG(("OSBRootElement::write\n"));
 344
 345     BinaryWriteHandler *wh = getWriteHandler();
 346
 347     wh->putValue(OSGOSB_HEADER_ID_2    );    // version
 348     wh->putValue(std::string("")       );    // name
 349     wh->putValue(std::string("")       );    // options
 350     wh->putValue(static_cast<UInt64>(0));    // size
 351
 352     ElementListConstIt elemIt  = getElementList().begin();
 353     ElementListConstIt elemEnd = getElementList().end  ();
 354
 355     for(; elemIt != elemEnd; ++elemIt)
 356     {
 357         writeFieldContainerHeader((*elemIt)->getContainer());
 358         (*elemIt)->write();
 359     }
 360 }
 361
 362 /*-------------------------------------------------------------------------*/
 363 /* Helper methods                                                          */
 364
 365 /*! Fills the "pointer field" described by \a ptrField with the correct
 366     pointers.
 367
 368     \param[in] ptrField Field to fill.
 369  */
 370 void
 371 OSBRootElement::mapPtrField(const PtrFieldInfo &ptrField)
 372 {
 373     OSG_OSB_LOG(("OSBRootElement::mapPtrField\n"));
 374
 375     PtrFieldInfo::PtrIdStoreConstIt   idIt       = ptrField.beginIdStore();
 376     PtrFieldInfo::PtrIdStoreConstIt   idEnd      = ptrField.endIdStore  ();
 377
 378     PtrFieldInfo::BindingStoreConstIt bindingIt  = ptrField.beginBindingStore();
 379     PtrFieldInfo::BindingStoreConstIt bindingEnd = ptrField.endBindingStore  ();
 380
 381     const FieldContainerIdMap        &idMap      = getIdMap();
 382           FieldContainerIdMapConstIt  idMapIt;
 383           FieldContainerIdMapConstIt  idMapEnd   = idMap.end();
 384
 385     if(bindingIt != bindingEnd)
 386     {
 387         if(ptrField.getHandledField() == true)
 388         {
 389             FieldContainer    *fieldCon = ptrField.getContainer();
 390             UInt32             fieldId  = ptrField.getFieldId();
 391
 392             EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);
 393
 394             EditMapFieldHandlePtr sfMapField =
 395                 boost::dynamic_pointer_cast<EditMapFieldHandle>(fHandle);
 396
 397             if(sfMapField == NULL || sfMapField->isValid() == false)
 398                 return;
 399
 400             sfMapField->fillFrom(ptrField.getBindingStore(),
 401                                  ptrField.getIdStore     (),
 402                                  idMap);
 403         }
 404         else
 405         {
 406             Attachment          *att    = NULL;
 407             AttachmentContainer *attCon =
 408                 dynamic_cast<AttachmentContainer *>(ptrField.getContainer());
 409
 410             for(; (idIt != idEnd) && (bindingIt != bindingEnd); ++idIt,
 411                                                                 ++bindingIt)
 412             {
 413                 if(*idIt != 0)
 414                 {
 415                     idMapIt = idMap.find(*idIt);
 416
 417                     if(idMapIt != idMapEnd)
 418                     {
 419                         att = dynamic_cast<Attachment *>(
 420                             FieldContainerFactory::the()->getContainer(
 421                                 idMapIt->second));
 422                     }
 423                     else
 424                     {
 425                         FWARNING(("OSBRootElement::mapPtrField: could not find "
 426                                   "FieldContainer with id [%u]\n", *idIt));
 427                         att = NULL;
 428                     }
 429                 }
 430                 else
 431                 {
 432                     att = NULL;
 433                 }
 434
 435                 if(att != NULL)
 436                 {
 437                     OSG_OSB_LOG(("OSBRootElement::mapPtrField: adding "
 438                             "attchment [%u] [%u]\n",
 439                             att->getType().getGroupId(), *bindingIt));
 440                 }
 441
 442                 attCon->addAttachment(att, *bindingIt);
 443             }
 444         }
 445     }
 446     else
 447     {
 448         FieldContainer    *fc       = NULL;
 449         FieldContainer    *fieldCon = ptrField.getContainer();
 450         UInt32             fieldId  = ptrField.getFieldId();
 451
 452         EditFieldHandlePtr fHandle  = fieldCon->editField(fieldId);
 453
 454         FieldContainerPtrSFieldBase::EditHandlePtr pSFHandle =
 455             boost::dynamic_pointer_cast<
 456                 FieldContainerPtrSFieldBase::EditHandle>(fHandle);
 457
 458         FieldContainerPtrMFieldBase::EditHandlePtr pMFHandle =
 459             boost::dynamic_pointer_cast<
 460                 FieldContainerPtrMFieldBase::EditHandle>(fHandle);
 461
 462         for(; idIt != idEnd; ++idIt)
 463         {
 464             if(*idIt != 0)
 465             {
 466                 idMapIt = idMap.find(*idIt);
 467
 468                 if(idMapIt != idMapEnd)
 469                 {
 470                     fc = FieldContainerFactory::the()->getContainer(
 471                         idMapIt->second);
 472                 }
 473                 else
 474                 {
 475                     FWARNING(("OSBRootElement::mapPtrField: could not find "
 476                               "FieldContainer with (file) id [%u]\n", *idIt));
 477                     fc = NULL;
 478                 }
 479             }
 480             else
 481             {
 482                 fc = NULL;
 483             }
 484
 485             if(pSFHandle != NULL && pSFHandle->isValid())
 486             {
 487                 pSFHandle->set(fc);
 488             }
 489             else if(pMFHandle != NULL && pMFHandle->isValid())
 490             {
 491                 pMFHandle->add(fc);
 492             }
 493             else
 494             {
 495                 FWARNING(("OSBRootElement::mapPtrField: FieldHandles invalid, "
 496                           "can not set pointer - target fc [%u][%s] "
 497                           "fieldId [%u][%s] file id [%u] system id [%u]\n",
 498                           (fc != NULL ? fc->getId() : 0),
 499                           (fc != NULL ? fc->getType().getCName() : ""),
 500                           fieldId,
 501                           (fc != NULL ?
 502                           fc->getType().getFieldDesc(fieldId)->getCName() : ""),
 503                           *idIt,
 504                           (idMapIt != idMapEnd ? idMapIt->second : 0) ));
 505             }
 506         }
 507     }
 508 }
 509
 510 /*! Prints the map showing the relation between FieldContainer ids in the file
 511     and the system, which is used by mapPtrField to fill in the right pointers.
 512  */
 513 void
 514 OSBRootElement::dumpIdMap(void) const
 515 {
 516     OSG_OSB_LOG(("OSBRootElement::dumpIdMap\n"));
 517
 518     FieldContainerIdMapConstIt mapIt  = getIdMap().begin();
 519     FieldContainerIdMapConstIt mapEnd = getIdMap().end  ();
 520
 521     for(; mapIt != mapEnd; ++mapIt)
 522     {
 523         OSG_OSB_LOG(("  file id  %u  ->  %u  system id\n", mapIt->first, mapIt->second));
 524     }
 525 }