Source/System/State/Base/OSGChunkBlockMapFields.h

   1 /*---------------------------------------------------------------------------*\
   2  *                                OpenSG                                     *
   3  *                                                                           *
   4  *                                                                           *
   5  *           Copyright (C) 2003 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 _OSGCHUNKBLOCKMAPFIELDS_H_
  40 #define _OSGCHUNKBLOCKMAPFIELDS_H_
  41 #ifdef __sgi
  42 #pragma once
  43 #endif
  44
  45 #include "OSGSystemDef.h"
  46 #include "OSGSField.h"
  47 #include "OSGFieldTraits.h"
  48 #include "OSGContainerForwards.h"
  49 #include "OSGRenderPropertiesPool.h"
  50
  51 #include "map"
  52
  53 OSG_BEGIN_NAMESPACE
  54
  55 class ChunkBlock;
  56
  57 /*! \ingroup GrpSystemStateFieldTraits
  58  */
  59
  60 typedef RenderPropertiesPool::Singleton::ValueType ChunkBlockMapKey;
  61
  62 /*! \ingroup GrpSystemStateFieldTraits
  63  */
  64 typedef std::map<ChunkBlockMapKey, ChunkBlock *>  ChunkBlockMap;
  65
  66 #ifndef DOXYGEN_SHOULD_SKIP_THIS
  67 /*! \ingroup GrpSystemStateFieldSFields
  68  */
  69 typedef SField<ChunkBlockMapKey> SFChunkBlockMapKey;
  70
  71 /*! \ingroup GrpSystemStateFieldMFields
  72  */
  73 typedef MField<ChunkBlockMapKey> MFChunkBlockMapKey;
  74 #else
  75 /*! \ingroup GrpSystemStateFieldSFields \ingroup GrpLibOSGSystem
  76  */
  77 struct SFChunkBlockMapKey : public SField<ChunkBlockMapKey> {};
  78
  79 /*! \ingroup GrpSystemStateFieldMFields \ingroup GrpLibOSGSystem
  80  */
  81 struct MFChunkBlockMapKey : public MField<ChunkBlockMapKey> {};
  82 #endif
  83
  84 /*! \ingroup GrpSystemStateFieldTraits
  85     \ingroup GrpLibOSGSystem
  86  */
  87
  88 template <>
  89 struct FieldTraits<ChunkBlockMap> :
  90     public FieldTraitsTemplateBase<ChunkBlockMap>
  91 {
  92   private:
  93
  94     static  DataType                                 _type;
  95
  96   public:
  97
  98     typedef FieldTraits<ChunkBlockMap>  Self;
  99
 100     typedef RenderPropertiesPool        KeyPool;
 101
 102     enum             { Convertible = Self::NotConvertible                  };
 103
 104     static OSG_SYSTEM_DLLMAPPING
 105                  DataType &getType      (void);
 106
 107     static const Char8    *getSName     (void)
 108     {
 109         return "SFChunkBlockPtrMap";
 110     }
 111
 112     static const Char8    *getMName     (void)
 113     {
 114         return "MFChunkBlockPtrMap";
 115     }
 116
 117     static OSG_SYSTEM_DLLMAPPING SizeT getBinSize(const ChunkBlockMap &aMap);
 118
 119     static SizeT  getBinSize(const ChunkBlockMap *aMaps,
 120                                    SizeT          numObjects)
 121     {
 122         SizeT size = 0;
 123
 124         // defaut: individual field sizes
 125         for(SizeT i = 0; i < numObjects; ++i)
 126         {
 127             size += getBinSize(aMaps[i]);
 128         }
 129
 130         return size;
 131     }
 132
 133     static OSG_SYSTEM_DLLMAPPING void copyToBin(      BinaryDataHandler &pMem,
 134                                                 const ChunkBlockMap     &aMap);
 135
 136     static void copyToBin(      BinaryDataHandler &pMem,
 137                           const ChunkBlockMap     *aMaps,
 138                                 SizeT              numObjects)
 139     {
 140         for(SizeT i = 0; i < numObjects; ++i)
 141         {
 142             copyToBin(pMem, aMaps[i]);
 143         }
 144     }
 145
 146     static OSG_SYSTEM_DLLMAPPING void copyFromBin(BinaryDataHandler &pMem,
 147                                                   ChunkBlockMap     &aMap );
 148
 149     static void copyFromBin(BinaryDataHandler &pMem,
 150                             ChunkBlockMap     *aMaps,
 151                             SizeT              numObjects)
 152     {
 153         for(SizeT i = 0; i < numObjects; ++i)
 154         {
 155             copyFromBin(pMem, aMaps[i]);
 156         }
 157     }
 158 };
 159
 160 #ifndef DOXYGEN_SHOULD_SKIP_THIS
 161 /*! \ingroup GrpSystemStateFieldSFields
 162  */
 163 typedef SField<ChunkBlockMap> SFChunkBlockPtrMap;
 164 #else
 165 /*! \ingroup GrpSystemStateFieldSFields \ingroup GrpLibOSGSystem
 166  */
 167 struct SFChunkBlockPtrMap : public SField<ChunkBlockMap> {};
 168 #endif
 169
 170 /*! \ingroup GrpSystemStateFieldHandle
 171  */
 172
 173 template<>
 174 class OSG_SYSTEM_DLLMAPPING GetSFieldHandle<SFChunkBlockPtrMap> :
 175     public GetMapFieldHandle
 176 {
 177     /*=========================  PROTECTED  ===============================*/
 178
 179   protected:
 180
 181     typedef GetMapFieldHandle Inherited;
 182     typedef GetFieldHandle    Base;
 183
 184     /*==========================  PUBLIC  =================================*/
 185
 186   public:
 187
 188     typedef boost::shared_ptr<GetSFieldHandle> Ptr;
 189     typedef FieldTraits<ChunkBlockMap>         MapFieldTraits;
 190     typedef MapFieldTraits::KeyPool            KeyPool;
 191     typedef KeyPool::Singleton::ValueType      KeyType;
 192
 193     /*---------------------------------------------------------------------*/
 194
 195     GetSFieldHandle(const GetSFieldHandle       &source);
 196     GetSFieldHandle(const SFChunkBlockPtrMap    *pField,
 197                     const FieldDescriptionBase  *pDescription,
 198                           FieldContainer        *pContainer  );
 199
 200     /*---------------------------------------------------------------------*/
 201
 202     virtual const FieldType &getType       (void) const;
 203     virtual       bool       isPointerField(void) const;
 204
 205     /*---------------------------------------------------------------------*/
 206
 207     virtual void traverse(TraverseCallback oCallBack);
 208
 209     /*---------------------------------------------------------------------*/
 210
 211     virtual bool empty  (void                );
 212     virtual void flatten(MapList       &vList);
 213     virtual void flatten(ContainerList &vList);
 214
 215     /*---------------------------------------------------------------------*/
 216
 217     virtual void pushValueToStream(OutStream &str) const;
 218     virtual void pushSizeToStream (OutStream &str) const;
 219
 220     /*---------------------------------------------------------------------*/
 221
 222     virtual bool equal(Base::Ptr rhs) const;
 223
 224     /*---------------------------------------------------------------------*/
 225
 226     SFChunkBlockPtrMap const * operator ->(void);
 227     SFChunkBlockPtrMap const & operator * (void);
 228 };
 229
 230 /*! \ingroup GrpSystemStateFieldHandle
 231  */
 232
 233 template<>
 234 class OSG_SYSTEM_DLLMAPPING
 235     EditSFieldHandle<SFChunkBlockPtrMap> : public EditMapFieldHandle
 236 {
 237     /*=========================== PRIVATE  ================================*/
 238
 239   private:
 240
 241     void operator =(const EditSFieldHandle &rhs);
 242
 243     /*=========================  PROTECTED  ===============================*/
 244
 245   protected:
 246
 247     typedef EditMapFieldHandle Inherited;
 248     typedef EditFieldHandle    Base;
 249
 250     typedef boost::function<void(ChunkBlock       * const,
 251                                  ChunkBlockMapKey        )> AddMethod;
 252
 253     /*==========================  PUBLIC  =================================*/
 254
 255     FieldContainer *_pContainer;
 256     AddMethod       _fAddMethod;
 257
 258   public:
 259
 260     typedef boost::shared_ptr<EditSFieldHandle> Ptr;
 261     typedef FieldTraits<ChunkBlockMap>          MapFieldTraits;
 262     typedef MapFieldTraits::KeyPool             KeyPool;
 263     typedef KeyPool::Singleton::ValueType       KeyType;
 264
 265     /*---------------------------------------------------------------------*/
 266
 267     EditSFieldHandle(const EditSFieldHandle     &source      );
 268     EditSFieldHandle(      SFChunkBlockPtrMap   *pField,
 269                      const FieldDescriptionBase *pDescription,
 270                            FieldContainer       *pContainer  );
 271
 272     /*---------------------------------------------------------------------*/
 273
 274     virtual const FieldType &getType       (void) const;
 275     virtual       bool       isPointerField(void) const;
 276
 277     /*---------------------------------------------------------------------*/
 278
 279     virtual void add(      FieldContainer *rhs,
 280                      const std::string    &szBindings);
 281
 282     /*---------------------------------------------------------------------*/
 283
 284     virtual void traverse(TraverseCallback oCallBack);
 285
 286     /*---------------------------------------------------------------------*/
 287
 288     virtual bool empty  (void                );
 289     virtual void flatten(MapList       &vList);
 290     virtual void flatten(ContainerList &vList);
 291
 292     /*---------------------------------------------------------------------*/
 293
 294     virtual bool loadFromBin(      BinaryDataHandler        *pMem,
 295                                    UInt32                    uiNumElements,
 296                                    bool                      hasBindingInfo,
 297                                    std::vector<UInt16>      &vBindings,
 298                                    std::vector<UInt32>      &vIds          );
 299
 300     virtual void fillFrom   (const std::vector<UInt16>      &vBindings,
 301                              const std::vector<UInt32>      &vIds,
 302                              const std::map<UInt32, UInt32> &vIdMap       );
 303
 304     /*---------------------------------------------------------------------*/
 305
 306     virtual void pushValueToStream(OutStream &str) const;
 307     virtual void pushSizeToStream (OutStream &str) const;
 308
 309     /*---------------------------------------------------------------------*/
 310
 311     void         setAddMethod(AddMethod      fMethod);
 312
 313     virtual bool equal       (Base::Ptr rhs    ) const;
 314
 315     /*---------------------------------------------------------------------*/
 316
 317     virtual void pushValueFromCString(const Char8             *str   );
 318
 319     virtual void copyValues          (      GetFieldHandlePtr  source) const;
 320     virtual void shareValues         (      GetFieldHandlePtr  source) const;
 321
 322     /*---------------------------------------------------------------------*/
 323
 324     virtual void cloneValues(
 325               GetFieldHandlePtr  pSrc,
 326         const TypePtrVector     &shareTypes     = TypePtrVector(),
 327         const TypePtrVector     &ignoreTypes    = TypePtrVector(),
 328         const TypeIdVector      &shareGroupIds  = TypeIdVector (),
 329         const TypeIdVector      &ignoreGroupIds = TypeIdVector ()) const;
 330
 331 };
 332
 333 OSG_END_NAMESPACE
 334
 335 #include "OSGChunkBlockMapFields.inl"
 336
 337 #endif /* _OSGCHUNKBLOCKMAPFIELDS_H_ */