include/terrainDbFactory/tdbMetafile.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 1998 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: tdbMetafile.h,v $ $Revision: 1.20 $ $State: Exp $
*******************************************************************************/
#ifndef tdbMetafile_H_
#define tdbMetafile_H_

// \file tdbMetafile.h
// \brief Contains the DtTdbMetafile class declaration.

#include "terrainDbFactory/terrainDbFactoryDefines.h"
#include <vlutil/vlFilename.h>
#include <iosfwd>
#include <vlutil/vlConfig.h>
#include <list>
#include <vector>

class DtTerrainMetafileRecord;
class DtGdbProcessingMetafileRecord;
class DtTerrainDescriptorRecord;
class DtExtentMetafileRecord;
class DtTdbMetafileFactory;
class DtMetafileRecord;
class DtVectorDataRecord;
class DtPaperMapRecord;
class DtAdditionalDataRecord;
class Dt3DViewMetafileRecord;
class DtTerrainIntersectorRecord;

//
// Instances of this class are accessors to Mak terrain database metafiles.
// Certain database formats require the use of a metafile as the top-level
// file.  Example: gdf, dted
class DT_DLL_terrainDbFactory DtTdbMetafile
{

public:
   // Includes both terrain and extent metafiles
   typedef std::list<DtMetafileRecord*> DtTerrainMfRecContainer;
   typedef DtTerrainMfRecContainer::iterator DtTerrainMfRecIter;
   typedef DtTerrainMfRecContainer::const_iterator DtTerrainMfRecConstIter;

   // Holds all vector records
   typedef std::list<DtVectorDataRecord*> DtVecMfRecContainer;
   typedef DtVecMfRecContainer::iterator DtVecMfRecIter;
   typedef DtVecMfRecContainer::const_iterator DtVecMfRecConstIter;

   // Holds all papermap records
   typedef std::list<DtPaperMapRecord*> DtPaperMapRecContainer;
   typedef DtPaperMapRecContainer::iterator DtPaperMapRecIter;
   typedef DtPaperMapRecContainer::const_iterator DtPaperMapRecConstIter;

   // Holds all additional records.
   typedef std::list<DtAdditionalDataRecord*> DtAdditionalMetafileRecordContainer;

   // default constructor.
   DtTdbMetafile(DtTdbMetafileFactory *factory);

   // destructor
   virtual ~DtTdbMetafile();

   // Load the metafile from the given filename.
   virtual bool init(const DtFilename& filename);

   virtual void setFilename(const DtFilename & name);
   virtual const DtFilename & filename() const;

   // For now the metafile factory requires a string hash look up to 
   // create the metafiles. Would be nice if this was perhaps an unsigned int
   // but for now strings are the way it is done.

   // Creates any metafile
   virtual DtMetafileRecord * createMetafileRecord(const DtString & recordString);

   // Creates a particular type of metafile
   virtual DtTerrainMetafileRecord* createTerrainMetafile(const DtString& recordString);
   virtual DtVectorDataRecord* createVectorRecord(const DtString& recordString);
   virtual DtPaperMapRecord* createPaperMapRecord(const DtString& recordString);

   virtual DtGdbProcessingMetafileRecord* createTerrainProcessingRecord();

   // Returns a pointer to the terrain processing record.
   virtual const DtGdbProcessingMetafileRecord* terrainProcessingRecord() const;
   virtual DtGdbProcessingMetafileRecord* terrainProcessingRecord();

   // Sets the terrain record pointer
   virtual void setTerrainProcessingRecord(DtGdbProcessingMetafileRecord* processMfRec);

   // Returns a pointer to the terrain intersector record.
   virtual const DtTerrainIntersectorRecord* terrainIntersectorRecord() const;
   virtual DtTerrainIntersectorRecord* terrainIntersectorRecord();

   // Sets the terrain intersector pointer.  Note that a clone of the record coming
   // in is created, so, delete any memory allocated for the record passed into this
   // routine
   virtual void setTerrainIntersectorRecord(DtTerrainIntersectorRecord* processMfRec);

   // Returns a pointer to the terrain descriptor record. This record holds the 
   // file name for the Mak Terrain Descriptor file and whether the terrain it 
   // describes has been altered since it was imported
   virtual const DtTerrainDescriptorRecord* terrainDescriptorRecord() const;
   virtual DtTerrainDescriptorRecord* terrainDescriptorRecord();

   // Sets the terrain record pointer
   virtual void setTerrainDescriptorRecord(DtTerrainDescriptorRecord* terrainDescriptorMfRec);

   // Returns the list of terrain and extent Metafile Records
   virtual const DtTerrainMfRecContainer& terrainMetafileRecordList() const;
   virtual DtTerrainMfRecContainer& terrainMetafileRecordList();

   // Add a terrain data record
   virtual void addTerrainMfRec(DtMetafileRecord* rec);

   // Returns the list of papermaps.
   virtual const DtPaperMapRecContainer& paperMapMetafileRecordList() const;
   virtual DtPaperMapRecContainer& paperMapMetafileRecordList();

   // Add a paperMap data record
   virtual void addPaperMapMfRec(DtPaperMapRecord* paperRec);

   // Returns the list of vectorData Metafile Records
   virtual const DtVecMfRecContainer& vectorDataMetafileRecordList() const;
   virtual DtVecMfRecContainer& vectorDataMetafileRecordList();

   // Returns the list of terrain records that are marked as importable
   virtual DtTerrainMfRecContainer importableTerrainMetafileRecordList();

   // Returns the type of the vector files used
   virtual const unsigned int vectorFilesType();

   // Add a vector data record
   virtual void addVectorDataMfRec(DtVectorDataRecord* vecRec);

   // These are records that may not be any of the above types.  For use by
   // plugins, and other arbitrary pieces of data to be stored in a metafile.
   virtual const DtAdditionalMetafileRecordContainer& additionalMetafileRecordList() const;
   virtual DtAdditionalMetafileRecordContainer& additionalMetafileRecordList();
   virtual void addAdditionalMfRec(DtAdditionalDataRecord* rec);

   // Sets the key value of this record, and adds it to the appropriate
   // list based on the recordCategory().  The DtMetafileRecord takes
   // ownership of this record.  If it cannot be places in a list,
   // false is returned and the record is not deleted.
   virtual bool addRecord(DtMetafileRecord* record);

   // Look up a metafile record by its key.
   virtual DtMetafileRecord * findRecord(unsigned int key);

   // Removes a metafile record that matches the given key
   virtual bool removeRecord(unsigned int key);

   // Write self to the given filename
   virtual bool put(const DtFilename& filename);

   // Write self to stream.
   virtual bool put(std::ostream& stream) const;

   // Read self from stream.
   virtual bool get(std::istream& stream);

   // Returns a pointer to the 3DView record (if exists) or null otherwise.
   virtual const Dt3DViewMetafileRecord* threeDViewMetafileRecord() const;
   virtual Dt3DViewMetafileRecord* threeDViewMetafileRecord();

   // Sets the 3DView record pointer
   virtual void setThreeDViewMetafileRecord(Dt3DViewMetafileRecord* extMfRec);

   // Deprecated--These supported a single extent or terrain record for the 
   // terrain database. We need to support multiple terrain records. There's no real
   // reason not to. For now these will return the first on their kind.

   // Returns a pointer to the extent record.
   virtual const DtExtentMetafileRecord* extentMetafileRecord() const;
   virtual DtExtentMetafileRecord* extentMetafileRecord();

   // Sets the extent record pointer
   virtual void setExtentMfRecord(DtExtentMetafileRecord* extMfRec);

   // Returns a pointer to the terrain record.
   virtual const DtTerrainMetafileRecord* terrainMetafileRecord() const;
   virtual DtTerrainMetafileRecord* terrainMetafileRecord();

   // Sets the terrain record pointer
   virtual void setTerrainMfRecord(DtTerrainMetafileRecord* terrainMfRec);
   // End functions to deprecate

   static int nextUniqueRecordKey();

   virtual void emptyAllRecords();

   // Return a list of metafile records of the specified type (as matched by recordTypeName)
   virtual std::vector<DtMetafileRecord*> recordsOfType(const std::string& type) const;

private:

   // copy constructor
   DtTdbMetafile(const DtTdbMetafile& orig);

   // assignment operator
   DtTdbMetafile& operator=(const DtTdbMetafile& rhs);

protected:

   DtTdbMetafile();

   // Removes and deletes all entries in myVectorDataMetafileRecordList.
   // Non-virtual because it is called from the destructor.
   void emptyTerrainMetafileRecordList();

   // Removes and deletes all entries in myPaperMapMetafileRecordList.
   // Non-virtual because it is called from the destructor.
   void emptyPaperMapMetafileRecordList();

   // Removes and deletes all entries in myVectorDataMetafileRecordList.
   // Non-virtual because it is called from the destructor.
   void emptyVectorDataMetafileRecordList();

   // Removes and deletes all entries in myAdditionalMetafileRecordList.
   // Non-virtual because it is called from the destructor.
   void emptyAdditionalMetafileRecordList();


   DtTdbMetafileFactory*         myFactory;

   DtFilename                    myFilename;

   DtGdbProcessingMetafileRecord* myGdbOptionsRecord;

   DtTerrainDescriptorRecord *   myTerrainDescriptorRecord;

   DtTerrainMfRecContainer       myTerrainMetafileRecordList;
   
   DtPaperMapRecContainer        myPaperMapMetafileRecordList;

   DtVecMfRecContainer           myVectorDataMetafileRecordList;

   Dt3DViewMetafileRecord*       my3DViewMetafileRecord;

   DtTerrainIntersectorRecord*   myTerrainIntersectorRecord;

   DtAdditionalMetafileRecordContainer myAdditionalMetafileRecordList;

   // Deprecated-- These imposed a single terrain record. 
   // We need to support multiple terrain records.
   DtExtentMetafileRecord*       myExtentMetafileRecord;
   DtTerrainMetafileRecord*      myTerrainMetafileRecord;

   unsigned int               myVectorFilesType;

   // This is the next available unique record key
   static int           myNextRecordKey;
};

#endif