// This code implementation is the intellectual property of
// the GEANT4 collaboration.
//
// By copying, distributing or modifying the Program (or any work
// based on the Program) you indicate your acceptance of this statement,
// and all its terms.
//
// $Id: G4PGeometryObjectMap.ddl,v 1.7 2000/11/22 15:29:39 morita Exp $
// GEANT4 tag $Name: geant4-03-00 $
//

// class description:
//
//	This is a class which is responsible for keeping track of the 
//	persistent geometry object in storing and retrieving geometry.
//	This class inherits HepPersObj and is persistent-capable. 
//

// Note:
// =====
//      This class contains pointers of some transient classes.
//      As a result, ooddlx compiler will issue warnings as follows.
//      The value of the pointers are used only in transient case
//      in this class, and you can safely ignore these warnings.
// ----
// "include/G4PGeometryObjectMap.ddl", line 136: warning: persistent-capable
//           class member type is pointer
//         G4VPhysVolRefArray*  transPhysVolPtrs;
//                              ^
// ----
//
// History:
// 98.06.20 Y.Morita  Initial version

#ifndef G4PGeometryObjectMap_h
#define G4PGeometryObjectMap_h 1

#include "G4Pglobals.hh"

#include "G4VPhysicalVolume.hh"
#include "G4LogicalVolume.hh"
#include "G4VSolid.hh"
#include "G4PersistentTypes.hh"
#include "G4PersistentSchema.hh"
#include "HepODBMS/odbms/HepODBMS.h"

class G4PVPhysicalVolume;
#pragma ooclassref G4PVPhysicalVolume "G4PVPhysicalVolume_ref.hh"
class G4PLogicalVolume;
#pragma ooclassref G4PLogicalVolume "G4PLogicalVolume_ref.hh"
class G4PVSolid;
#pragma ooclassref G4PVSolid "G4PVSolid_ref.hh"

class G4VPhysVolRefArray;
class G4LogVolRefArray;
class G4VSolidRefArray;

typedef d_Varray< d_Ref<G4PVPhysicalVolume> > G4PVPhysVolRefVArray;
typedef d_Varray< d_Ref<G4PLogicalVolume> >   G4PLogVolRefVArray;
typedef d_Varray< d_Ref<G4PVSolid> >          G4PVSolidRefVArray;

class G4PGeometryObjectMap 
 : public HepPersObj
{
  public:
      G4PGeometryObjectMap();
  public: // with description
      G4PGeometryObjectMap( const G4String theGeometryName );
      ~G4PGeometryObjectMap();
      //  The constructor and the destructor.

  public: // with description
      HepRef(G4PVPhysicalVolume) LookUp(         G4VPhysicalVolume* aPhysVol );
      G4VPhysicalVolume*         LookUp( HepRef(G4PVPhysicalVolume) aPhysVol );
      HepRef(G4PLogicalVolume)   LookUp(         G4LogicalVolume*   aLogVol);
      G4LogicalVolume*           LookUp( HepRef(G4PLogicalVolume)   aLogVol);
      HepRef(G4PVSolid)          LookUp(         G4VSolid*          aSolid);
      G4VSolid*                  LookUp( HepRef(G4PVSolid)          persSolid);
      // Method LookUp() will check if the pair of transient/persistent
      // geometry objects is already registered in the geometry map.
      // It returns the pointer of the pairing object if the pair exists.

  public: // with description
      void Add( G4VPhysicalVolume*         aPhysVol,
                HepRef(G4PVPhysicalVolume) persPhysVol );
      void Add( HepRef(G4PVPhysicalVolume) persPhysVol,
                G4VPhysicalVolume*         aPhysVol );
      void Add( G4LogicalVolume*           aLogVol,
                HepRef(G4PLogicalVolume)   persLogVol );
      void Add( HepRef(G4PLogicalVolume)   persLogVol,
                G4LogicalVolume*           aLogVol );
      void Add( G4VSolid*                  aSolid,
                HepRef(G4PVSolid)          persSolid );
      void Add( HepRef(G4PVSolid)          persSolid,
                G4VSolid*                  aSolid );
      // Method Add() will register the transient and persistent geometry
      // objects into the geometry map.

  public: // with description
      inline void SetWorldVolume( const HepRef(G4PVPhysicalVolume) aWorld )
            { thePersistentWorldVolume = aWorld; }
      inline HepRef(G4PVPhysicalVolume) GetWorldVolume()
            { return thePersistentWorldVolume; }
      // Set and Get methods for setting and getting a smart pointer
      // for the persistent world volume of the geometry.

  public: // with description
      inline G4int GetNoPhysVol() const { return noPhysVol; }
      inline G4int GetNoLogVol()  const { return noLogVol; }
      inline G4int GetNoSolids()  const { return noSolids; }
      // returns the number of the registered transient/persistent pairs
      // in the geometry map.

  public: // with description
      G4VSolid*         GetSolid(G4int n);
      HepRef(G4PVSolid) GetPSolid(G4int n);
      // returns the pointer of n-th transient/persistent solid.

  public:
      void InitTransientMap();

  private:
      // World Volume of this Geometry object tree
      d_Ref<G4PVPhysicalVolume> thePersistentWorldVolume;

      // Physics Volume Pointer Array
      G4Pint noPhysVol;
      G4VPhysVolRefArray*  transPhysVolPtrs;
      G4PVPhysVolRefVArray persPhysVolPtrs;

      // Logical Volume Pointer Array
      G4Pint noLogVol;
      G4LogVolRefArray*  transLogVolPtrs;
      G4PLogVolRefVArray persLogVolPtrs;

      // Solid Pointer Array
      G4Pint noSolids;
      G4VSolidRefArray*  transSolidPtrs;
      G4PVSolidRefVArray persSolidPtrs;

};

#endif