mie/format.h

Go to the documentation of this file.

#ifndef INC_MIE_FORMAT_H
#define INC_MIE_FORMAT_H

#ifndef INC_MIE_MIE2_H
   #include <mie/mie2.h>
#endif

#ifndef INC_MIE_FEATURES_H
   #include <mie/features.h>
#endif

#ifndef INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

#ifndef INC_MI32_MISTRING_H
   #include <mi32/mistring.h>
#endif

#ifndef INC_MI32_STRUTF8_H
   #include <mi32/strutf8.h>
#endif

#ifndef INC_MI32_SMLBASE_H
   #include <mi32/smlbase.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class FILEPATH;
class GETFILEFILTER;
namespace RVC {
   class GETOBJFILTER;
   class OBJITEM;
   class OBJITEMLIST;
   }
namespace SPATREF {
   class COORDREFSYS;
   }
namespace MIE {
   class JOB_IMPORT;
   class JOB_EXPORT;
   }
#endif // GENERATING_DOXYGEN_OUTPUT

namespace MIE {

// ************************************************************************

class FORMAT {
   public:

      enum TESTRESULT {
         TESTRESULT_No = 0,         
         TESTRESULT_Yes = 1,        
         TESTRESULT_Unknown = 2,    
         TESTRESULT_CannotTest = 3, 
         TESTRESULT_CantOpen = 4,   
         TESTRESULT_YesPreferred = 5, 
         TESTRESULT_YesLowPriority = 6, 
         };

      enum SORTMETHOD {
         SORT_ByName = 0,
         SORT_ByDesc = 1,
         SORT_ByExtn = 2
         };

      //---------------------------------------------------------------------------
      static int  AddFormatsAll ();
      static int  AddFormatsCAD ();
      static int  AddFormatsDatabase ();
      static int  AddFormatsRaster ();
      static int  AddFormatsShape ();
      static int  AddFormatsTIN ();
      static int  AddFormatsVector ();

      static void EnableSML();

      static int SortFormatList (
         SORTMETHOD sort = SORT_ByName,
         bool forward = true
         );

      static const FORMAT* GetFormat (
         FORMATTYPE FormatType
         );

      static ERRVALUE GetFormatList (
         SIMPLE_ARRAY<const FORMAT*>& formats,
         MODE mode,     // MODE_Import, MODE_Export, MODE_Edit
         OBJTYPEFLAG ObjectType  // Object types to allow
         );

      static bool FindFormats (
         SIMPLE_ARRAY<const FORMAT*>& FormatList,
         const FILEPATH& filepath,
         MODE mode = MODE_Import,
         OBJTYPEFLAG ObjType = OBJTYPEFLAG_ALL
         );

      static const FORMAT* FindFormat (
         const FILEPATH& filepath,
         MODE mode = MODE_Import,
         OBJTYPEFLAG ObjType = OBJTYPEFLAG_ALL
         );

      virtual ~FORMAT ();

      JOB_IMPORT* AllocJobImport (
         OBJTYPEFLAG ObjectType,
         const SETTINGS& settings
         ) const { return v_AllocJobImport(ObjectType, settings); }

      JOB_EXPORT* AllocJobExport (
         const SETTINGS& settings
         ) const { return v_AllocJobExport(settings); }

      SETTINGS* AllocSettings (
         MODE mode,
         OBJTYPEFLAG ObjType = OBJTYPEFLAG_ALL
         ) const;

      UI_BASE* AllocUserInterface (
         SETTINGS& settings
         ) const;

      ERRVALUE AnalyzeObjects (
         const RVC::OBJITEMLIST& objects,
         SETTINGS* settings
         ) const { return v_AnalyzeObjects(objects, settings); }

      ERRVALUE AnalyzeSources (
         const MISTRINGLIST& sourcelist,
         SETTINGS* settings
         ) const { return v_AnalyzeSources(sourcelist, settings); }

      bool CanExport (
         RVC::OBJTYPE objtype
         ) const;

      bool CanExportSupportCRS (
         const SPATREF::COORDREFSYS& crs
         ) const { return (v_CanExportSupportCRS(crs)); }

      bool CanExportToSingleFile (
         const RVC::OBJITEMLIST& objects
         ) const { return (v_CanExportToSingleFile(objects)); }

      bool CanImport (
         RVC::OBJTYPE objtype
         ) const;

      bool FeatureIsOptional (
         FEATURE feature
         ) const { return m_OptionalFeatureSet.Contains(feature); }

      const char* GetDefaultFileExtn (
         ) const { return v_GetDefaultFileExtn(); }

      OBJTYPEFLAG GetEditObjType() const { return v_GetEditObjType(); }

      void GetExportDefaultCRS (
         SPATREF::COORDREFSYS& crs,
         const DRECT3D& Extents
         ) const { v_GetExportDefaultCRS(crs, Extents); }

      RVC::GETOBJFILTER* GetExportObjectFilter (
         ) const { return (m_pExportObjectFilter); }
      
      OBJTYPEFLAG GetExportObjTypes (
         ) const; 

      const MISTRING* GetFixedSource (
         ) const { return v_GetFixedSource(); }

      void GetFormatDesc(MISTRING& str) const { v_GetFormatDesc(str); }

      const char* GetFormatName() const { return m_FormatName; }

      FORMATTYPE GetFormatType (
         ) const {
         return m_FormatType;
         }

      GETFILEFILTER* GetImportFileFilter (
         ) const { return (m_pImportFileFilter); }

      const char* GetImportFilePrompt (
         ) const { return v_GetImportFilePrompt(); }

      TEXTID GetImportFilePromptTEXTID (
         ) const { return v_GetImportFilePromptTEXTID(); }

      OBJTYPEFLAG GetImportObjTypes (
         ) const;

      OBJTYPEFLAG GetIntermediateObjType (
         OBJTYPEFLAG PreferredObjType
         ) const { return v_GetIntermediateObjType(PreferredObjType); }

      int GetObjItemList (
         const MISTRING& source,
         RVC::OBJITEMLIST& items,
         const SETTINGS& settings
         ) const;

      SML::CLASS* GetSMLClass (
         RVC::OBJTYPE ObjType
         ) const;

      SML::CLASSMEMBER* GetSMLClassMembers (
         RVC::OBJTYPE ObjType
         ) const;

      const char* GetSMLClassName (
         RVC::OBJTYPE ObjType
         ) const { return v_GetSMLClassName(ObjType); }

      const STRUTF8& GetSource (
         ) const { return m_source; }

      MISTRING GetDataSourceName (
         const MISTRING& DataSource
         ) const { return v_GetDataSourceName(DataSource); }

      bool HasFeature (
         FEATURE feature
         ) const { return (m_FeatureSet.Contains(feature) || FeatureIsOptional(feature)); }

      ERRVALUE SelectDataSources (
         MISTRINGLIST& sources,
         const RVC::OBJITEMLIST* objitems = 0
         ) const { return v_SelectDataSources(sources, objitems); }

      void SetExportObjectFilter (
         RVC::GETOBJFILTER *pExportObjectFilter
         ) { m_pExportObjectFilter = pExportObjectFilter; }

      void SetImportFileFilter (
         GETFILEFILTER *pImportFileFilter
         ) { m_pImportFileFilter = pImportFileFilter; }

      bool SupportsEncoding (
         CHAR_ENCODING encoding
         ) const { return v_SupportsEncoding(encoding); }

      TESTRESULT TestFile (
         const FILEPATH& filepath,
         bool TestByExtn = true
         ) const;

      TESTRESULT TestObject (
         const RVC::OBJITEM& objitem
         ) const;

      ERRVALUE Import (
         const MISTRING& source,
         RVC::OBJITEMLIST& dest,
         const SETTINGS& settings
         ) const;

      ERRVALUE ImportMulti (
         const MISTRINGLIST& sources,
         const SIMPLE_ARRAY<int>& NumObjectsInFile,
         const RVC::OBJITEMLIST& objitems,
         const SETTINGS& settings,
         MISTRING& ErrorLog                     
         ) const { return v_ImportMulti(sources, NumObjectsInFile, objitems, settings, ErrorLog); }

      ERRVALUE Export (
         const RVC::OBJITEMLIST& sources,
         const MISTRING& dest,
         const SETTINGS& settings
         ) const;

      //-----------------------------------------------------------------------
   protected:
      FEATURESET m_FeatureSet;         
      FEATURESET m_OptionalFeatureSet; 

      FORMAT (
         FORMATTYPE FormatType,
         OBJTYPEFLAG ImportObjType,
         MODE Modes,
         const char* FormatName,    
         const char* source,        
         OBJTYPEFLAG ExportObjType = OBJTYPEFLAG_None    
         );

      void AddFeatures (
         FEATURE features
         ) { m_FeatureSet += features; }

      void SetExportObjTypes (
         OBJTYPEFLAG objtypes
         ) { m_ExportObjType = objtypes; }

      void SetImportObjTypes (
         OBJTYPEFLAG objtypes
         ) { m_ImportObjType = objtypes; }

      void SetFormatName (
         const char* name
         ) { m_FormatName = name; }

      void SetSource (
         const char* source
         ) { m_source = source; }

      OBJTYPEFLAG GetExportObjTypeFlag (
         ) const {
         return m_ExportObjType;
         }

      OBJTYPEFLAG GetImportObjTypeFlag (
         ) const {
         return m_ImportObjType;
         }

      const char* GetSMLBaseClassName (
         RVC::OBJTYPE objtype
         ) const;

      virtual ERRVALUE v_AnalyzeSource (
         const MISTRING& source,
         SETTINGS* settings
         ) const;

      virtual ERRVALUE v_AnalyzeSources (
         const MISTRINGLIST& sourcelist,
         SETTINGS* settings
         ) const;

      virtual ERRVALUE v_ImportMulti (
         const MISTRINGLIST& sources,
         const SIMPLE_ARRAY<int>& NumObjectsInFile,
         const RVC::OBJITEMLIST& objitems,
         const SETTINGS& settings,
         MISTRING& ErrorLog                     
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      FORMATTYPE m_FormatType;         
      int m_FormatIdx;                 
      const char* m_FormatName;
      STRUTF8 m_source;       
      OBJTYPEFLAG m_ImportObjType;
      OBJTYPEFLAG m_ExportObjType;
      MODE m_Modes;
   #define MAX_MIE_CLASSES_PER_FORMAT 8
      SML::CLASS* m_SMLClass[MAX_MIE_CLASSES_PER_FORMAT];
      bool m_bSMLClassesSetup;
      RVC::GETOBJFILTER *m_pExportObjectFilter;
      GETFILEFILTER *m_pImportFileFilter;

      #endif

      static void InstallSMLClasses (
         SML::CALLBACKSTRUCT* cbs,
         void*
         );

      SML::CLASS* SetupSMLClass (
         RVC::OBJTYPE ObjType
         );

      void SetupSMLClasses (
         );

      virtual JOB_IMPORT* v_AllocJobImport (
         OBJTYPEFLAG ObjectType,
         const SETTINGS& settings
         ) const;

      virtual JOB_EXPORT* v_AllocJobExport (
         const SETTINGS& settings
         ) const;

      virtual SETTINGS* v_AllocSettings (
         MODE mode,
         OBJTYPEFLAG ObjType = OBJTYPEFLAG_ALL
         ) const;

      virtual UI_BASE* v_AllocUserInterface (
         SETTINGS& settings
         ) const;

      virtual bool v_CanExport (
         RVC::OBJTYPE objtype
         ) const;

      virtual bool v_CanExportSupportCRS (
         const SPATREF::COORDREFSYS& crs
         ) const;

      virtual bool v_CanExportToSingleFile (
         const RVC::OBJITEMLIST& objects
         ) const;

      virtual bool v_CanImport (
         RVC::OBJTYPE objtype
         ) const;

      virtual const char* v_GetDefaultFileExtn (
         ) const;

      virtual OBJTYPEFLAG v_GetEditObjType () const;

      virtual void v_GetExportDefaultCRS (
         SPATREF::COORDREFSYS& crs,
         const DRECT3D& Extents           
         ) const;

      virtual void v_GetFormatDesc(MISTRING& desc) const = 0;

      virtual const char* v_GetImportFilePrompt (
         ) const;

      virtual TEXTID v_GetImportFilePromptTEXTID (
         ) const;

      OBJTYPEFLAG v_GetIntermediateObjType (
         OBJTYPEFLAG PreferredObjType
         ) const;

      virtual int v_GetObjItemList (
         const MISTRING& source,
         RVC::OBJITEMLIST& items,
         const SETTINGS& settings
         ) const;

      virtual SMLCLASSMEMBER* v_GetSMLClassMembers (
         RVC::OBJTYPE ObjType
         ) const;

      virtual const char* v_GetSMLClassName (
         RVC::OBJTYPE ObjType
         ) const;

      virtual ERRVALUE v_Import (
         const MISTRING& source,
         const SETTINGS& settings,
         const SIMPLE_ARRAY<JOB_IMPORT*>& jobs
         ) const;

      virtual ERRVALUE v_Export (
         const MISTRING& dest,
         const SETTINGS& settings,
         const SIMPLE_ARRAY<JOB_EXPORT*>& jobs     
         ) const;

      virtual TESTRESULT v_TestFile (
         const FILEPATH& filepath
         ) const;

      virtual TESTRESULT v_TestObject (
         const RVC::OBJITEM& objitem
         ) const;

      virtual ERRVALUE v_AnalyzeObjects (
         const RVC::OBJITEMLIST& objects,
         SETTINGS* settings
         ) const;

      virtual DEPRECATED ERRVALUE v_AnalyzeFile (
         const FILEPATH& source,
         SETTINGS* settings
         ) const;

      virtual const MISTRING* v_GetFixedSource (
         ) const;

      virtual MISTRING v_GetDataSourceName (
         const MISTRING& DataSource
         ) const;

      virtual ERRVALUE v_SelectDataSource (
         MISTRING& DataSource,
         const RVC::OBJITEM* objitem = 0
         ) const;

      virtual ERRVALUE v_SelectDataSources (
         MISTRINGLIST& DataSources,
         const RVC::OBJITEMLIST* objitems = 0
         ) const;

      virtual bool v_SupportsEncoding (
         CHAR_ENCODING encoding
         ) const;

      friend class SML_MIEFORMAT;
      friend class FORMATLIST;
   };


}  // End namespace MIE


#endif // ifndef INC_MIE_FORMAT_H

---