OSGFieldContainerFactoryImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------------*\
 *                                OpenSG                                     *
 *                                                                           *
 *                                                                           *
 *             Copyright (C) 2000-2002 by the OpenSG Forum                   *
 *                                                                           *
 *                            www.opensg.org                                 *
 *                                                                           *
 *   contact: dirk@opensg.org, gerrit.voss@vossg.org, jbehr@zgdv.de          *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                License                                    *
 *                                                                           *
 * This library is free software; you can redistribute it and/or modify it   *
 * under the terms of the GNU Library General Public License as published    *
 * by the Free Software Foundation, version 2.                               *
 *                                                                           *
 * This library is distributed in the hope that it will be useful, but       *
 * WITHOUT ANY WARRANTY; without even the implied warranty of                *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         *
 * Library General Public License for more details.                          *
 *                                                                           *
 * You should have received a copy of the GNU Library General Public         *
 * License along with this library; if not, write to the Free Software       *
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.                 *
 *                                                                           *
\*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*\
 *                                Changes                                    *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
 *                                                                           *
\*---------------------------------------------------------------------------*/

#ifndef _OSGFIELDCONTAINERFACTORYIMPL_H_
#define _OSGFIELDCONTAINERFACTORYIMPL_H_
#ifdef __sgi
#pragma once
#endif

#ifdef OSG_DOC_FILES_IN_MODULE

#endif

#include <OSGSystemDef.h>
#include <OSGBaseTypes.h>
#include <OSGIDStringLink.h>
#include <map>
#include <vector>

OSG_BEGIN_NAMESPACE

class Lock;
class FieldContainerType;

//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

struct OSG_SYSTEMLIB_DLLMAPPING FieldContainerMapper
{
    virtual ~FieldContainerMapper();
    
    virtual UInt32 map(UInt32 uiId) = 0;
};

//---------------------------------------------------------------------------
//  Class
//---------------------------------------------------------------------------

class OSG_SYSTEMLIB_DLLMAPPING FieldContainerFactory
{
    /*=========================  PROTECTED  ===============================*/

  protected:

    typedef std::map   <UInt32,       
                        FieldContainerType        *> TypeIdMap;
    typedef std::map   <IDStringLink, 
                        FieldContainerType        *> TypeNameMap;
    typedef std::map   <IDStringLink, 
                        UInt16                     > GroupMap;

    typedef std::vector<FieldContainerType        *> UninitializedTypeStore;
    typedef std::vector<FieldContainerPtr          > FieldContainerStore;

    typedef TypeIdMap             ::iterator         TypeIdMapIt;
    typedef TypeNameMap           ::iterator         TypeNameMapIt;
    typedef GroupMap              ::iterator         GroupMapIt;
    typedef UninitializedTypeStore::iterator         UninitTypeStoreIt;
    typedef FieldContainerStore   ::iterator         FieldContainerStoreIt;

    typedef TypeIdMap             ::const_iterator   TypeIdMapConstIt;
    typedef TypeNameMap           ::const_iterator   TypeNameMapCnstIt;
    typedef GroupMap              ::const_iterator   GroupMapConstIt;


    /*==========================  PUBLIC  =================================*/

  public :

    typedef TypeIdMapIt TypeMapIterator;

    static FieldContainerFactory *the(void);

    /*---------------------------------------------------------------------*/
    FieldContainerType *findType    (      UInt32  uiTypeId) const;
    FieldContainerType *findType    (const Char8  *szName  ) const;
    UInt32              getNumTypes (void                  ) const;


    FieldContainerType *findUninitializedType (const Char8  *szName) const;

    bool                initializePendingTypes(      void          );

    TypeMapIterator     beginTypes            (      void          );
    TypeMapIterator     endTypes              (      void          );

    /*---------------------------------------------------------------------*/
          UInt16  findGroupId  (const Char8  *szName   ) const;
    const Char8  *findGroupName(      UInt16  uiGroupId) const;
        
          UInt16  getNumGroups (      void             ) const;

    /*---------------------------------------------------------------------*/
    void setMapper(FieldContainerMapper *pMapper);

    /*---------------------------------------------------------------------*/
    FieldContainerPtr getContainer      (UInt32 uiFieldContainerId) const;
    FieldContainerPtr getMappedContainer(UInt32 uiFieldContainerId) const;

    /*---------------------------------------------------------------------*/
    FieldContainerPtr createFieldContainer(const Char8 *name) const;
    NodePtr           createNode          (const Char8 *name) const;
    NodeCorePtr       createNodeCore      (const Char8 *name) const;
    AttachmentPtr     createAttachment    (const Char8 *name) const;

    /*---------------------------------------------------------------------*/
    void writeFCD(Char8 *name = NULL, std::ostream *out = NULL);
    
    /*---------------------------------------------------------------------*/
    const FieldContainerStore *getFieldContainerStore(void) const;

    /*=========================  PROTECTED  ===============================*/

  protected:

    static FieldContainerFactory *_the;

    static TypeMapIterator        _defaultTypeMapIt;

    /*---------------------------------------------------------------------*/
    static bool initializeFactory(void);
    static bool terminateFactory (void);

    /*---------------------------------------------------------------------*/
    bool                    _bInitialized;

    TypeIdMap              *_pTypeIdMap;
    TypeNameMap            *_pTypeNameMap;
    GroupMap               *_pGroupMap;
    UninitializedTypeStore *_pUnitTypesStore;
    FieldContainerStore    *_pFieldContainerStore;

    Lock                   *_pStoreLock;
    Lock                   *_pMapLock;

    FieldContainerMapper   *_pMapper;

    /*---------------------------------------------------------------------*/
    FieldContainerFactory(void);

    /*---------------------------------------------------------------------*/
    virtual ~FieldContainerFactory(void); 

    /*---------------------------------------------------------------------*/
    bool   initialize (void);
    bool   terminate  (void);

    void   initTypeMap(void);

    /*---------------------------------------------------------------------*/
    bool   unregisterFieldContainer(const FieldContainerPtr  &pFieldContainer);
    UInt32   registerFieldContainer(const FieldContainerPtr  &pFieldContainer);

    UInt32 registerType            (      FieldContainerType *pType          );
    UInt16 registerGroup           (const Char8              *szName         );
    void   unregisterType          (      FieldContainerType *pType          );

    /*---------------------------------------------------------------------*/
    void writeSingleTypeFCD(std::ostream &out, const FieldContainerType *type);

    /*==========================  PRIVATE  ================================*/

  private:

    friend class FieldContainerType;
    friend class FieldContainer;
    friend class FieldContainerPtrBase;

    FieldContainerFactory(const FieldContainerFactory &source);
    void operator =(const FieldContainerFactory &source);
};

OSG_END_NAMESPACE

#define OSGFIELDCONTAINERFACTORY_HEADER_CVSID "@(#)$Id: $"

#endif /* _OSGFIELDCONTAINERFACTORYIMPL_H_ */

---