Source/System/FileIO/Base/OSGSceneFileHandler.h

   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 #ifndef _OSGSCENEFILEHANDLER_H_
  40 #define _OSGSCENEFILEHANDLER_H_
  41 #ifdef  __sgi
  42 #pragma  once
  43 #endif
  44
  45 #include <string>
  46 #include <list>
  47 #include <map>
  48 #include <iostream>
  49
  50 #include <boost/function.hpp>
  51
  52 #include "OSGSystemDef.h"
  53 #include "OSGBaseTypes.h"
  54 #include "OSGSceneFileType.h"
  55 #include "OSGPathHandler.h"
  56 #include "OSGSingletonHolder.h"
  57
  58 OSG_BEGIN_NAMESPACE
  59
  60 class GraphOpSeq;
  61
  62 /*! \brief Brief OSGSceneFileHandler
  63     \ingroup GrpSystemFileIOBase
  64     \ingroup GrpLibOSGSystem
  65  */
  66
  67 class OSG_SYSTEM_DLLMAPPING SceneFileHandlerBase
  68 {
  69     /*==========================  PUBLIC  =================================*/
  70
  71     typedef NodeTransitPtr (*FileIOReadCBF )(SceneFileType         *type,
  72                                              std::istream          &is,
  73                                              Char8           const *ext );
  74
  75     typedef bool           (*FileIOWriteCBF)(SceneFileType *        type,
  76                                              Node          * const  node,
  77                                              std::ostream          &os,
  78                                              Char8           const *ext,
  79                                              bool                   compress);
  80
  81
  82     typedef SceneFileType::Resolver Resolver;
  83
  84   public:
  85
  86     /*---------------------------------------------------------------------*/
  87     /*! \name                   Get                                        */
  88     /*! \{                                                                 */
  89
  90     virtual SceneFileType *getFileType(const Char8 *fileNameOrExtension);
  91
  92     virtual int getSuffixList(std::list<const Char8*> &suffixList,
  93                               UInt32                   flags = (
  94                                   SceneFileType::OSG_READ_SUPPORTED |
  95                                   SceneFileType::OSG_WRITE_SUPPORTED));
  96
  97     /*! \}                                                                 */
  98     /*---------------------------------------------------------------------*/
  99     /*! \name                   Progress                                   */
 100     /*! \{                                                                 */
 101
 102     typedef void (*progresscbfp) (      UInt32  p    );
 103     typedef void (*filenamecbfp) (const Char8  *fname);
 104
 105     void          setReadProgressCB (progresscbfp fp,
 106                                      bool         use_thread = true);
 107     progresscbfp  getReadProgressCB (void                          );
 108
 109     void          setReadBeginCB    (filenamecbfp fp               );
 110     filenamecbfp  getReadBeginCB    (void                          );
 111
 112     void          setReadEndCB      (filenamecbfp fp               );
 113     filenamecbfp  getReadEndCB      (void                          );
 114
 115     void          updateReadProgress(void                          );
 116     void          updateReadProgress(UInt32       p                );
 117
 118     void         setWriteProgressCB (progresscbfp fp               );
 119     progresscbfp getWriteProgressCB (void                          );
 120
 121     void         setWriteBeginCB    (filenamecbfp fp               );
 122     filenamecbfp getWriteBeginCB    (void                          );
 123
 124     void         setWriteEndCB      (filenamecbfp fp               );
 125     filenamecbfp getWriteEndCB      (void                          );
 126
 127     void         updateWriteProgress(UInt32       p                );
 128
 129     /*! \}                                                                 */
 130     /*---------------------------------------------------------------------*/
 131     /*! \name                   Read                                       */
 132     /*! \{                                                                 */
 133
 134     virtual NodeTransitPtr read(      std::istream &is,
 135                                 const Char8        *ext,
 136                                       GraphOpSeq   *graphOpSeq =
 137                                                            _defaultgraphOpSeq,
 138                                        Resolver     resolver   = NULL);
 139
 140     virtual NodeTransitPtr read(const  Char8       *fileName,
 141                                        GraphOpSeq  *graphOpSeq =
 142                                                            _defaultgraphOpSeq,
 143                                        Resolver     resolver      = NULL,
 144                                        bool         bWarnNotFound = true      );
 145
 146     /*! \}                                                                 */
 147     /*---------------------------------------------------------------------*/
 148     /*! \name                   Read Callback                              */
 149     /*! \{                                                                 */
 150
 151     void          setReadCB(FileIOReadCBF fp);
 152     FileIOReadCBF getReadCB(void            );
 153
 154     /*! \}                                                                 */
 155     /*---------------------------------------------------------------------*/
 156     /*! \name                   Write                                      */
 157     /*! \{                                                                 */
 158
 159     virtual bool write(Node         * const  node,
 160                        std::ostream         &os,
 161                        Char8          const *ext,
 162                        bool                  compress = false);
 163
 164     virtual bool write(Node         * const  node,
 165                        Char8          const *fileName,
 166                        bool                  compress = false);
 167     /*! \}                                                                 */
 168     /*---------------------------------------------------------------------*/
 169     /*! \name               Write Callback                                 */
 170     /*! \{                                                                 */
 171
 172     void           setWriteCB(FileIOWriteCBF fp);
 173     FileIOWriteCBF getWriteCB(void             );
 174
 175     /*! \}                                                                 */
 176     /*---------------------------------------------------------------------*/
 177     /*! \name                   PathHandler                                */
 178     /*! \{                                                                 */
 179
 180     virtual PathHandler* getPathHandler(void                    );
 181     virtual void         setPathHandler(PathHandler *pathHandler);
 182
 183     /*! \}                                                                 */
 184     /*---------------------------------------------------------------------*/
 185     /*! \name                   PathHandler                                */
 186     /*! \{                                                                 */
 187
 188     Resolver getGlobalResolver(void              ) const;
 189     void     setGlobalResolver(Resolver oResolver);
 190
 191     /*! \}                                                                 */
 192     /*---------------------------------------------------------------------*/
 193     /*! \name                   DefaultGraphOp                             */
 194     /*! \{                                                                 */
 195
 196     virtual GraphOpSeq *getDefaultGraphOp(void                  );
 197     virtual void        setDefaultGraphOp(GraphOpSeq *graphOpSeq);
 198
 199     /*! \}                                                                 */
 200     /*---------------------------------------------------------------------*/
 201     /*! \name Options                                                      */
 202     /*! \{                                                                 */
 203
 204     template <class ValueTypeT>
 205     bool              setOptionAs(const std::string &suffix,
 206                                   const std::string &name,
 207                                   const ValueTypeT  &value         );
 208     bool              setOption  (const std::string &suffix,
 209                                   const std::string &name,
 210                                   const std::string &value         );
 211
 212     bool              unsetOption(const std::string &suffix,
 213                                   const std::string &name          );
 214
 215     template <class ValueTypeT>
 216     bool              getOptionAs(const std::string &suffix,
 217                                   const std::string &name,
 218                                         ValueTypeT  &value         );
 219     bool              getOption  (const std::string &suffix,
 220                                   const std::string &name,
 221                                         std::string &value         );
 222
 223     void              pushOptions(const std::string &suffix,
 224                                         bool         copyTop = true);
 225     void              popOptions (const std::string &suffix        );
 226
 227 #if defined(OSG_1_COMPAT)
 228     void setOptions(const std::string &suffix,
 229                     const std::string &osg1Options);
 230 #endif
 231
 232     /*! \}                                                                 */
 233     /*---------------------------------------------------------------------*/
 234     /*! \name                   Debug                                      */
 235     /*! \{                                                                 */
 236
 237     void print (void);
 238
 239     /*! \}                                                                 */
 240     /*=========================  PROTECTED  ===============================*/
 241
 242   protected:
 243
 244     typedef std::list<             SceneFileType *> FileTypeList;
 245     typedef std::map <std::string, FileTypeList  *> FileTypeMap;
 246
 247     struct FindOverride
 248     {
 249         UInt32 uiRefPriority;
 250
 251         bool operator() (SceneFileType *fileTypeP);
 252     };
 253
 254     /*---------------------------------------------------------------------*/
 255     /*! \name                      Member                                  */
 256     /*! \{                                                                 */
 257
 258     FileTypeMap _suffixTypeMap;
 259
 260
 261     bool         addSceneFileType(SceneFileType &fileType);
 262     bool         subSceneFileType(SceneFileType &fileType);
 263
 264     /*! \}                                                                 */
 265     /*---------------------------------------------------------------------*/
 266     /*! \name                   Constructors                               */
 267     /*! \{                                                                 */
 268
 269     SceneFileHandlerBase(void);
 270
 271     /*! \}                                                                 */
 272     /*---------------------------------------------------------------------*/
 273     /*! \name                   Destructors                                */
 274     /*! \{                                                                 */
 275
 276     virtual ~SceneFileHandlerBase(void);
 277
 278     /*! \}                                                                 */
 279     /*---------------------------------------------------------------------*/
 280     /*! \name                   Destructors                                */
 281     /*! \{                                                                 */
 282
 283     static bool terminateSceneFileTypes  (void);
 284            bool doTerminateSceneFileTypes(void);
 285
 286     /*! \}                                                                 */
 287     /*---------------------------------------------------------------------*/
 288     /*! \name                   Destructors                                */
 289     /*! \{                                                                 */
 290
 291     void triggerReadBegin (const Char8 *fname);
 292     void triggerReadEnd   (const Char8 *fname);
 293
 294     void triggerWriteBegin(const Char8 *fname);
 295     void triggerWriteEnd  (const Char8 *fname);
 296
 297
 298     /*! \}                                                                 */
 299     /*==========================  PRIVATE  ================================*/
 300
 301   private:
 302
 303     friend class SceneFileType;
 304
 305     template <class SingletonT>
 306     friend class SingletonHolder;
 307
 308     std::string initPathHandler(const Char8        *fileName);
 309
 310     /*! \nohierarchy
 311      */
 312
 313     struct progressS
 314     {
 315         ThreadRefPtr  thread;
 316         UInt64        length;
 317         std::istream *is;
 318
 319         progressS(void) : thread(NULL), length(0), is(NULL) {}
 320
 321       private:
 322
 323         progressS(const progressS &other);
 324         void operator =(const progressS &rhs);
 325     };
 326
 327            void initReadProgress     (std::istream &is);
 328            void terminateReadProgress(void            );
 329     static void readProgress         (void *data      );
 330
 331            progresscbfp   _readProgressFP;
 332            filenamecbfp   _readBeginFP;
 333            filenamecbfp   _readEndFP;
 334
 335            progressS      _progressData;
 336            bool           _readReady;
 337            bool           _useProgressThread;
 338
 339            progresscbfp   _writeProgressFP;
 340            filenamecbfp   _writeBeginFP;
 341            filenamecbfp   _writeEndFP;
 342
 343            PathHandler   *_pathHandler;
 344            PathHandler    _defaultPathHandler;
 345     static GraphOpSeq    *_defaultgraphOpSeq;
 346
 347            FileIOReadCBF  _readFP;
 348            FileIOWriteCBF _writeFP;
 349
 350            Resolver       _oGlobalResolver;
 351
 352     /*!\brief prohibit default function (move to 'public' if needed) */
 353     void operator =(const SceneFileHandlerBase &source);
 354     /*!\brief prohibit default function (move to 'public' if needed) */
 355     SceneFileHandlerBase(const SceneFileHandlerBase &source);
 356 };
 357
 358 #if defined(WIN32)
 359 OSG_SYSTEM_EXPIMP_TMPL
 360 template class OSG_SYSTEM_DLLMAPPING SingletonHolder<SceneFileHandlerBase>;
 361 #endif
 362
 363 /*! \typedef OSG::SingletonHolder<OSG::SceneFileHandlerBase> SceneFileHandler;
 364     \ingroup GrpSystemFileIOBase
 365     \relatesalso OSG::SceneFileHandlerBase
 366  */
 367
 368 typedef SingletonHolder<SceneFileHandlerBase> SceneFileHandler;
 369
 370 typedef SceneFileHandler* SceneFileHandlerP;
 371
 372 OSG_END_NAMESPACE
 373
 374 #include "OSGSceneFileHandler.inl"
 375
 376 #endif // OSGIMAGEFILEHANDLER_CLASS_DECLARATION