terrainDbFactory.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2003 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: terrainDbFactory.h,v $ $Revision: 1.18 $ $State: Exp $
*******************************************************************************/
#ifndef terrainDbFactory_H_
#define terrainDbFactory_H_

// \file terrainFactory.h
// The file contains the terrain database factory, which is used to create 
// the appropriate terrain importers and exporters depending on the types of 
// terrain files to import and export. 
//

#include "terrainDbFactory/terrainDbFactoryDefines.h"
#include <vlutil/vlHashlist.h>
#include <vlutil/vlFilename.h>
#include <vector>

class DtTerrainDatabase;
class DtPaperMapDatabase;
class DtPaperMap;
class DtTerrainReader;
class DtMetafileRecord;
class DtVectorDataReader;
class DtTerrainReaderFactory;
class DtTdbMetafileFactory;
class DtPaperMapFactory;
class DtVectorDataFactory;
class DtTerrainWriterFactory;
class Coordinate_System;

//
// DtTerrainDbFactory are two containers of DtTerrainFactoryEntries and 
// DtPaperMapFactoryEntries indexed by the DtString type that represents the 
// type of file able to load.
class DT_DLL_terrainDbFactory DtTerrainDbFactory
{
public:
   // constructor
   DtTerrainDbFactory();

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

   // assignment operator
   const DtTerrainDbFactory& operator=(const DtTerrainDbFactory& orig);

   // Destructor: deletes factory and any entries on the factory.
   virtual ~DtTerrainDbFactory();


   // creates the factories calling the functions for each one
   // and initialize them with default functions.
   // The functions are used in this order

   // because the last three need a metafile factory.
   virtual void init();


   // function to set/get the factories. 
   // For metafile factory, it replace it into the other factories.
   virtual void setTerrainReaderFactory(DtTerrainReaderFactory* factory);
   virtual DtTerrainReaderFactory *terrainReaderFactory();

   virtual void setTerrainWriterFactory(DtTerrainWriterFactory* factory);
   virtual DtTerrainWriterFactory *terrainWriterFactory();

   virtual void setMetafileFactory(DtTdbMetafileFactory* factory);
   virtual DtTdbMetafileFactory *metafileFactory();

   virtual void setPaperMapFactory(DtPaperMapFactory* factory);
   virtual DtPaperMapFactory *paperMapFactory();

   virtual void setVectorDataFactory(DtVectorDataFactory* factory);
   virtual DtVectorDataFactory *vectorDataFactory();
   
   // creator functions callers
   
   virtual DtTerrainReader* createTerrainReader(const DtString &type);

   virtual DtPaperMap* createPaperMap(const DtString &type);

   virtual DtVectorDataReader* createVectorDataReader(const DtString &type);

   // Loads terrain database file fileName, returning data in terrain.
   // terrain must point to a newly created and initialized 
   // DtTerrainDatabase object before it is passed into this function.
   // Creates and returns a DtPaperMapDatabase object in paperMapDatabase,
   // if paper maps are specified in the incoming terrain database file.
   // searchPaths is a list DtString*s, holding a list of locations in which
   // to search for the given fileName on the file system.
   // If there is not enough memory to load the database, it throws std::bad_alloc
   // \throws std::bad_alloc
   virtual bool loadDatabase(const DtFilename& fileName,
      DtTerrainDatabase* terrain, DtPaperMapDatabase*& paperMapDatabase, 
      const DtList& searchPaths);

   // Loads terrain database file fileName, returning data in terrain.
   // terrain must point to a newly created and initialized 
   // DtTerrainDatabase object before it is passed into this function.
   // Creates and returns a DtPaperMapDatabase object in paperMapDatabase,
   // if paper maps are specified in the incoming terrain database file.
   // If there is not enough memory to load the database, it throws std::bad_alloc
   // \throws std::bad_alloc
   virtual bool loadDatabase(const DtFilename& fileName,
      DtTerrainDatabase* terrain, DtPaperMapDatabase * &paperMapDatabase,const DtFilename & path=DtFilename::nullFilename());

   // Given the specified filename, determines and returns the extension.  
   // @return The extension of the specified filename, which is defined as the 
   // string after, but not containing, the last '.' in the filename.
   // 
   // @note If the filename is "geodetic" then the extension returned will be 
   // "geodetic".
   virtual const DtString determineFileExtension(const DtFilename& filename);

   // Loads the specified .map file into the specified terrain database.
   // @return A boolean indicating success or failure in loading the .map 
   // terrain file.
   // If there is not enough memory to load the database, it throws std::bad_alloc
   // \throws std::bad_alloc
   virtual bool loadMapTerrainFile(DtTerrainDatabase& terrainDb, 
      DtPaperMapDatabase*& paperMapDatabase, const DtFilename& filename, 
      const std::vector<DtFilename>& paths, const DtString& extension);
   
   // Loads the specified non-map (.gdb) file into the specified terrain database.
   // @return A boolean indicating success or failure in loading the terrain file.
   // If there is not enough memory to load the database, it throws std::bad_alloc
   // \throws std::bad_alloc
   virtual bool loadNonMapTerrainFile(DtTerrainDatabase& terrainDb, 
      const DtFilename& filename, const DtString& extension);

   // Apply simple processing to the database, such as reducing vertices
   // and creating a spatial subdivision is none exists.
   virtual bool processTerrainDatabase(DtTerrainDatabase& terrainDb);

   virtual bool saveDatabase(const DtFilename& fileName, DtTerrainDatabase *terrain);

   static DtTerrainDbFactory* create();

   // Calls down to appropriate terrain loader to return optional file flags.  Will not load
   // terrain vectors or polygons
   virtual int optionalFileFlagsFromTerrainMapFile(const DtFilename& filename,
      const std::vector<DtFilename>& searchPaths, const DtString& extension);

   // Calls down to appropriate terrain loader to return optional file flags.  Will not load
   // terrain vectors or polygons
   // @return Optional file flags from file
   virtual int optionalFileFlagsFromTerrainFile(const DtFilename& filename, const DtString& extension);

   // Returns a newly instantiated coordiate system for the specified terrain.  This call should not load
   // any of the underlying vector or polygon information
   virtual Coordinate_System* coordinateSystemFor(const DtFilename& fileName, const DtFilename & path=DtFilename::nullFilename());

   // Figures out the terrain to load then calls coordinateSystemFromTerrainFile
   // @return Coordinate_System that needs to be deleted by caller
   virtual Coordinate_System* coordinateSystemFromTerrainMapFile(const DtFilename& filename,
      const std::vector<DtFilename>& searchPaths, const DtString& extension);

   // Calls down to appropriate terrain loader to return a newly allocated coordinate system.  Will not load
   // terrain vectors or polygons
   // @return Coordinate_System that needs to be deleted by caller
   virtual Coordinate_System* coordinateSystemFromTerrainFile(const DtFilename& filename, const DtString& extension);

   // Returns true if any of the specified flags are set in the database
   // @return True/false depending on whether or not flags are set
   virtual bool hasOptionalFlags(int flags, const DtFilename& filename, const DtFilename & path=DtFilename::nullFilename());

   // Returns the path that contains the filename from the searchpaths
   virtual DtFilename pathFromFilename(const std::vector<DtFilename>& searchPaths, const DtFilename& filename);

protected:

   DtTerrainReaderFactory  *myTerrainReaderFactory;
   DtTerrainWriterFactory  *myTerrainWriterFactory;
   DtTdbMetafileFactory    *myMetafileFactory;
   DtPaperMapFactory       *myPaperMapFactory;
   DtVectorDataFactory     *myVectorDataFactory;
};

#endif