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