Source/System/FileIO/OSG/OSGOSGWriter.cpp

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *                     Copyright 2000-2002 by OpenSG Forum                   *
   6  *                                                                           *
   7  *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
   8  *                                                                           *
   9 \*---------------------------------------------------------------------------*/
  10 /*---------------------------------------------------------------------------*\
  11  *                                License                                    *
  12  *                                                                           *
  13  * This library is free software; you can redistribute it and/or modify it   *
  14  * under the terms of the GNU Library General Public License as published    *
  15  * by the Free Software Foundation, version 2.                               *
  16  *                                                                           *
  17  * This library is distributed in the hope that it will be useful, but       *
  18  * WITHOUT ANY WARRANTY; without even the implied warranty of                *
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
  20  * Library General Public License for more details.                          *
  21  *                                                                           *
  22  * You should have received a copy of the GNU Library General Public         *
  23  * License along with this library; if not, write to the Free Software       *
  24  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
  25  *                                                                           *
  26 \*---------------------------------------------------------------------------*/
  27 /*---------------------------------------------------------------------------*\
  28  *                                Changes                                    *
  29  *                                                                           *
  30  *                                                                           *
  31  *                                                                           *
  32  *                                                                           *
  33  *                                                                           *
  34  *                                                                           *
  35 \*---------------------------------------------------------------------------*/
  36
  37 //---------------------------------------------------------------------------
  38 //  Includes
  39 //---------------------------------------------------------------------------
  40
  41 #include "OSGOSGWriter.h"
  42 //#include "OSGAttachment.h"
  43 //#include "OSGSimpleAttachments.h"
  44 //#include "OSGVRMLNodeDescs.h"
  45
  46 #include "OSGAttachmentMapSFields.h"
  47 #include "OSGAttachment.h"
  48 #include "OSGNameAttachment.h"
  49
  50 #include <boost/bind.hpp>
  51
  52 OSG_USING_NAMESPACE
  53
  54 #define WFC
  55
  56 #if 0
  57 #if defined(OSG_WIN32_ICL)
  58 #pragma warning (disable : 383)
  59 #endif
  60
  61 #if defined(OSG_WIN32_ICL)
  62 #pragma warning (default : 383)
  63 #endif
  64 #endif
  65
  66 const UInt32 OSGWriter::DefaultSFWidth = TypeTraits<UInt32>::getMax();
  67 const UInt32 OSGWriter::DefaultMFWidth = 60;
  68
  69 /*-------------------------------------------------------------------------*/
  70 /*                             Constructor                                 */
  71
  72 /*! Constructor. Set members to initial values.
  73  */
  74 OSGWriter::FCInfoHelper::FCInfoHelper(void) :
  75     written      (false),
  76     hasName      (false),
  77     containerName(     )
  78 {
  79 }
  80
  81 /*! Constructor. Set members to initial values.
  82  */
  83 OSGWriter::OSGWriter(OutStream &stream, UInt32 indentStep) :
  84     _visitedFCMap(                 ),
  85     _outStream   (stream           )
  86 {
  87 }
  88
  89 /*-------------------------------------------------------------------------*/
  90 /*                             Destructor                                  */
  91
  92 /*! Destructor. There are no dynamic members to destroy.
  93  */
  94 OSGWriter::~OSGWriter(void)
  95 {
  96 }
  97
  98 /*-------------------------------------------------------------------------*/
  99 /*                             Methods                                     */
 100
 101 /*! Write a single FieldContainer with all its "children", i.e. everything
 102  *  that can be reached via Ptr-Fields.
 103  */
 104 void OSGWriter::write(FieldContainer *container)
 105 {
 106     _visitedFCMap.clear();
 107 //    _indent.setIndent(0);
 108
 109     _outStream << "#OSG V1.0 ";
 110     _outStream << "\n";
 111
 112     visitContainer(container);
 113     writeContainer(container, true);
 114 }
 115
 116
 117 /*! Write all FieldContainers in containers with their "children",
 118  *  i.e. everything that can be reached via Ptr-Fields.
 119  */
 120 void OSGWriter::write(std::vector<FieldContainer *> containers)
 121 {
 122     _visitedFCMap.clear();
 123 //    _indent.setIndent(0);
 124
 125     _outStream << "#OSG V1.0 " << "\n";
 126
 127     std::vector<FieldContainer *>::reverse_iterator iter;
 128
 129     for(iter = containers.rbegin(); iter != containers.rend(); ++iter)
 130     {
 131         visitContainer(*iter);
 132     }
 133
 134     for(iter = containers.rbegin(); iter != containers.rend(); ++iter)
 135     {
 136         writeContainer(*iter, true);
 137     }
 138 }
 139
 140
 141 /*! Set the name by which this FieldContainer is referenced. If available
 142  *  a NameAttachment is used, otherwise the name is constructed from
 143  *  the type name and the container id.
 144  */
 145
 146 void OSGWriter::FCInfoHelper::setName(FieldContainer * const pFC)
 147 {
 148     AttachmentContainer *pAttCon = dynamic_cast<AttachmentContainer *>(pFC);
 149
 150     if(pAttCon != NULL)
 151     {
 152         const Char8 *szName = getName(pAttCon);
 153
 154         if(szName != NULL)
 155         {
 156             containerName = szName;
 157             return;
 158         }
 159     }
 160
 161     //no NameAttachment. Build name from Type and Id
 162     containerName = pFC->getTypeName();
 163
 164     TypeTraits<UInt32>::putToString(pFC->getId(), containerName);
 165 }
 166
 167
 168 void OSGWriter::visitContainer(FieldContainer * const pFC)
 169 {
 170
 171     if(pFC == NULL)
 172     {
 173         return;
 174     }
 175
 176     typedef std::pair<FCInfoHelperMap::iterator, bool> MapInsertInfo;
 177
 178           std::string         containerName;
 179 //    const FieldContainerType &fcType    = pFC->getType();
 180           UInt32              numFields = pFC->getNumFields();
 181           MapInsertInfo       insertInfo;
 182
 183     insertInfo = _visitedFCMap.insert(std::make_pair(pFC, FCInfoHelper()));
 184
 185     if(insertInfo.second == true)
 186     {
 187         //the FC was NOT visited before
 188         for(UInt32 field = 1; field <= numFields; field++)
 189         {
 190             GetFieldHandlePtr fHandle = pFC->getField(field);
 191
 192             if(fHandle == NULL || (fHandle != NULL && fHandle->isInternal()))
 193             {
 194                 continue;
 195             }
 196
 197             visitField(fHandle);
 198         }
 199     }
 200     else
 201     {
 202         //the FC was in the map => FC is shared
 203
 204         FCInfoHelperMap::iterator iter = _visitedFCMap.find(pFC);
 205
 206         if(iter == _visitedFCMap.end())
 207         {
 208             SWARNING << "OSGWriter::visitContainer(): FieldContainer * "
 209                      << "not found in map" << std::endl;
 210             return;
 211         }
 212         if(iter->second.hasName == false)
 213         {
 214             iter->second.setName(pFC);
 215             iter->second.hasName = true;
 216         }
 217     }
 218 }
 219
 220 void OSGWriter::visitField(GetFieldHandlePtr hF)
 221 {
 222     if(hF->isValid() == false)
 223     {
 224         return;
 225     }
 226
 227 //    const FieldType &fType       = hF->getType();
 228
 229     GetMapFieldHandlePtr sfMap =
 230         boost::dynamic_pointer_cast<
 231             GetMapFieldHandle>(hF);
 232
 233     if(sfMap != NULL && sfMap->isValid() == true)
 234     {
 235         sfMap->traverse(boost::bind(&OSGWriter::visitContainer, this, _1));
 236     }
 237     else
 238     {
 239         FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 240             boost::dynamic_pointer_cast<
 241                 FieldContainerPtrSFieldBase::GetHandle>(hF);
 242
 243         FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 244             boost::dynamic_pointer_cast<
 245                 FieldContainerPtrMFieldBase::GetHandle>(hF);
 246
 247         if(sfFCPtr != NULL && sfFCPtr->isValid() == true)
 248         {
 249             visitContainer((*sfFCPtr)->getValue());
 250         }
 251         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 252         {
 253             SizeT mfSize = (*mfFCPtr)->size();
 254
 255             for(SizeT i = 0; i < mfSize; i++)
 256             {
 257                 visitContainer((**mfFCPtr)[i]);
 258             }
 259         }
 260     }
 261 }
 262
 263
 264 void OSGWriter::writeContainer(FieldContainer * const pFC,
 265                                bool                   bIndent)
 266 {
 267     if(pFC == NULL)
 268     {
 269         return;
 270     }
 271
 272     UInt32 numFields = pFC->getNumFields();
 273
 274     FCInfoHelperMap::iterator iter = _visitedFCMap.find(pFC);
 275
 276     if(iter == _visitedFCMap.end())
 277     {
 278         SWARNING << "OSGWriter::writeContainer(): FieldContainer * "
 279                  << "not found in map" << std::endl;
 280         return;
 281     }
 282
 283     if(!iter->second.written)
 284     {
 285         //FC is not written yet
 286         iter->second.written = true;
 287
 288         if(bIndent == true)
 289         {
 290             _outStream << BeginElem;
 291         }
 292
 293         if(iter->second.hasName)
 294         {
 295             _outStream << "DEF "
 296                        << iter->second.containerName
 297                        << " "
 298                        << pFC->getTypeName()
 299                        << EndElemNL
 300                        << BeginElem
 301                        << "{"
 302                        << EndElemNL;
 303         }
 304         else
 305         {
 306             _outStream <<  pFC->getTypeName()
 307                        << EndElemNL
 308                        << BeginElem
 309                        << "{"
 310                        << EndElemNL;
 311         }
 312
 313         _outStream << IncIndent;
 314
 315         for(UInt32 field = numFields; field > 0; field--)
 316         {
 317             GetFieldHandlePtr fHandle = pFC->getField(field);
 318
 319             if(fHandle == NULL || (fHandle != NULL && fHandle->isInternal()))
 320             {
 321                 continue;
 322             }
 323
 324             writeField(fHandle);
 325         }
 326
 327         _outStream << DecIndent;
 328
 329         _outStream << BeginElem
 330                    << "}"
 331                    << EndElemNL;
 332     }
 333     else
 334     {
 335         //FC is already written -> its shared -> write reference
 336         if(!iter->second.hasName)
 337         {
 338             SWARNING << "OSGWriter::writeContainer(): FieldContainer is "
 339                      << "shared, but not named"
 340                      << std::endl;
 341             return;
 342         }
 343
 344         if(bIndent == true)
 345         {
 346             _outStream << BeginElem;
 347         }
 348
 349         _outStream << "USE "
 350                    << iter->second.containerName
 351                    << EndElemNL;
 352     }
 353
 354 }
 355
 356
 357 void OSGWriter::writeField(GetFieldHandlePtr hF)
 358 {
 359     if(hF->isValid() == false)
 360     {
 361         return;
 362     }
 363
 364 //    const FieldType& fType = hF->getType();
 365
 366     GetMapFieldHandlePtr sfMap =
 367         boost::dynamic_pointer_cast<
 368             GetMapFieldHandle>(hF);
 369
 370     FieldContainerPtrSFieldBase::GetHandlePtr sfFCPtr =
 371         boost::dynamic_pointer_cast<FieldContainerPtrSFieldBase::GetHandle>(hF);
 372
 373     FieldContainerPtrMFieldBase::GetHandlePtr mfFCPtr =
 374         boost::dynamic_pointer_cast<FieldContainerPtrMFieldBase::GetHandle>(hF);
 375
 376     if(sfMap != NULL && sfMap->isValid() == true)
 377     {
 378         _outStream << BeginElem
 379                    << hF->getName();
 380
 381         //if the Attachment Map is empty write [] as its content
 382         if(sfMap->empty() == true)
 383         {
 384             _outStream << " [ ] " << EndElemNL;
 385         }
 386         else
 387         {
 388             _outStream << EndElemNL
 389                        << BeginElem
 390                        << "["
 391                        << EndElemNL;
 392
 393             _outStream << IncIndent;
 394
 395             EditMapFieldHandle::MapList fcList;
 396
 397             sfMap->flatten(fcList);
 398
 399             EditMapFieldHandle::MapList::iterator iter = fcList.begin();
 400             EditMapFieldHandle::MapList::iterator end  = fcList.end  ();
 401
 402             for(; iter!=end; ++iter)
 403             {
 404                 _outStream << BeginElem
 405                            << "MapHelper"
 406                            << EndElemNL
 407                            << BeginElem
 408                            << "{"
 409                            << EndElemNL;
 410
 411                 _outStream << IncIndent;
 412
 413                 _outStream << BeginElem
 414                            << "keys"
 415                            << EndElemNL
 416                            << BeginElem
 417                            << "["
 418                            << EndElemNL;
 419
 420                 _outStream << IncIndent;
 421
 422                 std::vector<std::string>::const_iterator kIt  =
 423                     iter->first.begin();
 424
 425                 std::vector<std::string>::const_iterator kEnd =
 426                     iter->first.end();
 427
 428                 for(; kIt != kEnd; ++kIt)
 429                 {
 430                     _outStream << BeginElem
 431                                << "\""
 432                                << *kIt
 433                                << "\""
 434                                << EndElemNL;
 435                 }
 436
 437                 _outStream << DecIndent;
 438
 439                 _outStream << BeginElem
 440                            << "]"
 441                            << EndElemNL;
 442
 443                 _outStream << BeginElem
 444                            << "container ";
 445
 446                 if(iter->second == NULL)
 447                 {
 448                     _outStream << "NULL"
 449                                << EndElemNL;
 450                 }
 451                 else
 452                 {
 453                     writeContainer(iter->second, false);
 454                     _outStream << EndElemNL;
 455                 }
 456
 457                 _outStream << DecIndent;
 458
 459                 _outStream << BeginElem
 460                            << "}"
 461                            << EndElemNL;
 462             }
 463
 464             _outStream << DecIndent;
 465
 466             _outStream << BeginElem
 467                        << "]"
 468                        << EndElemNL;
 469         }
 470     }
 471     else if(sfFCPtr != NULL || mfFCPtr != NULL)
 472     {
 473         //this Field points to FC
 474
 475         if(hF->getDescription()->isDynamic() == true)
 476         {
 477             _outStream << BeginElem
 478                        << "field "
 479                        << hF->getType().getCName()
 480                        << " "
 481                        << hF->getName();
 482         }
 483         else
 484         {
 485             _outStream << BeginElem
 486                        << hF->getName();
 487         }
 488
 489         if(sfFCPtr != NULL && sfFCPtr->isValid() == true)
 490         {
 491             if((*sfFCPtr)->getValue() == NULL)
 492             {
 493                 _outStream << " NULL" << EndElemNL;
 494             }
 495             else
 496             {
 497                 _outStream << " ";
 498                 writeContainer((*sfFCPtr)->getValue(), false);
 499             }
 500         }
 501         else if(mfFCPtr != NULL && mfFCPtr->isValid() == true)
 502         {
 503             _outStream << EndElemNL
 504                        << BeginElem
 505                        << "["
 506                        << EndElemNL;
 507
 508             _outStream << IncIndent;
 509
 510             SizeT mfSize = (*mfFCPtr)->size();
 511
 512             for(SizeT i = 0; i < mfSize; i++)
 513             {
 514                 if((*(*mfFCPtr))[i] == NULL)
 515                 {
 516                     _outStream << BeginElem
 517                                << "NULL"
 518                                << EndElemNL;
 519                 }
 520                 else
 521                 {
 522                     writeContainer((*(*mfFCPtr))[i], true);
 523                 }
 524             }
 525
 526             _outStream << DecIndent;
 527
 528             _outStream << BeginElem
 529                        << "]"
 530                        << EndElemNL;
 531         }
 532     }
 533     else
 534     {
 535         //this Field contains data -> write it out
 536
 537         if(hF->getDescription()->isDynamic() == true)
 538         {
 539             _outStream << BeginElem
 540                        << "field "
 541                        << hF->getType().getCName()
 542                        << " "
 543                        << hF->getName();
 544         }
 545         else
 546         {
 547             _outStream << BeginElem << hF->getName();
 548         }
 549
 550         //to access the content of a field via a Field*
 551         //one must know the cardinality
 552         if(hF->getCardinality() == FieldType::SingleField)
 553         {
 554             _outStream << " ";
 555
 556             hF->pushValueToStream(_outStream);
 557
 558             _outStream << EndElemNL;
 559         }
 560         else if(hF->getCardinality() == FieldType::MultiField)
 561         {
 562             _outStream << " #";
 563
 564             hF->pushSizeToStream(_outStream);
 565
 566             _outStream << EndElemNL
 567                        << BeginElem
 568                        << "["
 569                        << EndElemNL;
 570
 571             _outStream << IncIndent;
 572
 573 #ifdef WFC
 574             hF->pushValueToStream(_outStream);
 575
 576             _outStream << EndElemNL;
 577 #endif
 578
 579
 580             _outStream << DecIndent;
 581
 582             _outStream << BeginElem
 583                        << "]"
 584                        << EndElemNL;
 585         }
 586     }
 587 }