mi32/geocat.h

Go to the documentation of this file.

#ifndef INC_MI32_GEOCAT_H
#define INC_MI32_GEOCAT_H

#ifndef INC_RVC_DBTABLE_H
#include <rvc/dbtable.h>
#endif

#ifndef INC_MI32_FILEPATHLIST_H
#include <mi32/filepathlist.h>
#endif

#ifndef INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif

#ifndef INC_MI32_FILETEXT_H
#include <mi32/filetext.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class STATUSCONTEXT;
namespace RVC {
   class OBJITEM;
   }
#endif


class GEOCAT {
   public:

      class RECORD {
         public:

            RECORD (
               );

            RECORD (
               const RECORD& rhs
               );

            ~RECORD (
               );

            RECORD& operator= (
               const RECORD& rhs
               );

            UINT32 GetID (
               ) const {
               return (m_ID);
               }

            double GetAccuracy (
               ) const {
               return (m_Accuracy);
               }

            const MISTRING& GetCRS (
               ) const {
               return (m_CRS);
               }

            const MISTRING& GetDataType (
               ) const {
               return (m_DataType);
               }

            const MISTRING& GetDescription (
               ) const {
               return (m_Description);
               }

            const MISTRING& GetFormat (
               ) const {
               return (m_Format);
               }

            void GetLatLonExtents (
               DRECT2D& extents
               ) const;

            double GetLatitudeNorth (
               ) const {
               return (m_LatitudeNorth);
               }

            double GetLatitudeSouth (
               ) const {
               return (m_LatitudeSouth);
               }

            const MISTRING& GetLocation (
               ) const {
               return (m_Location);
               }

            double GetLongitudeEast (
               ) const {
               return (m_LongitudeEast);
               }

            double GetLongitudeWest (
               ) const {
               return (m_LongitudeWest);
               }

            UINT32 GetNumCols (
               ) const {
               return (m_NumCols);
               }

            UINT32 GetNumLins (
               ) const {
               return (m_NumLins);
               }

            RVC::OBJTYPE GetObjectType (
               ) const {
               return (m_objtype);
               }

            void GetProjectionExtents (
               DRECT2D& extents
               ) const;

            double GetProjectionMinX (
               ) const {
               return (m_ProjectionMinX);
               }

            double GetProjectionMaxX (
               ) const {
               return (m_ProjectionMaxX);
               }

            double GetProjectionMinY (
               ) const {
               return (m_ProjectionMinY);
               }

            double GetProjectionMaxY (
               ) const {
               return (m_ProjectionMaxY);
               }

            const DATETIME& GetTimeObjModified (
               ) const {
               return (m_TimeObjModified);
               }

            const DATETIME& GetTimeRecCreated (
               ) const {
               return (m_TimeRecCreated);
               }

            const DATETIME& GetTimeRecModified (
               ) const {
               return (m_TimeRecModified);
               }

            const MISTRING& GetTitle (
               ) const {
               return (m_Title);
               }

            double GetXScale (
               ) const {
               return (m_XScale);
               }

            double GetYScale (
               ) const {
               return (m_YScale);
               }

            void SetAccuracy (
               double accuracy
               ) { m_Accuracy = accuracy; }

            void SetCRS (
               const MISTRING& crs
               ) { m_CRS = crs; }

            void SetDataType (
               const MISTRING& datatype
               ) { m_DataType = datatype; }

            void SetDescription (
               const MISTRING& desc
               ) { m_Description = desc; }

            void SetFormat (
               const MISTRING& format
               ) { m_Format = format; }

            void SetLatitudeNorth (
               double val
               ) { m_LatitudeNorth = val; }

            void SetLatitudeSouth (
               double val
               ) { m_LatitudeSouth = val; }

            void SetLocation (
               const MISTRING& location
               ) { m_Location = location; }

            void SetLongitudeEast (
               double val
               ) { m_LongitudeEast = val; }

            void SetLongitudeWest (
               double val
               ) { m_LongitudeWest = val; }

            void SetNumCols (
               UINT32 NumCols
               ) { m_NumCols = NumCols; }

            void SetNumLins (
               UINT32 NumLins
               ) { m_NumLins = NumLins; }

            void SetObjectType (
               RVC::OBJTYPE objtype
               ) { m_objtype = objtype; }

            void SetProjectionMinX (
               double val
               ) { m_ProjectionMinX = val; }

            void SetProjectionMaxX (
               double val
               ) { m_ProjectionMaxX = val; }

            void SetProjectionMinY (
               double val
               ) { m_ProjectionMinY = val; }

            void SetProjectionMaxY (
               double val
               ) { m_ProjectionMaxY = val; }

            void SetTitle (
               const MISTRING& title
               ) { m_Title = title; }

            void SetXScale (
               double xscale
               ) { m_XScale = xscale; }

            void SetYScale (
               double yscale
               ) { m_YScale = yscale; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            void SetID (
               UINT32 id
               ) {
               m_ID = id;
               return;
               }

            void SetTimeObjModified (
               ) {
               time_t modtime;
               RVC::OBJITEM objitem;
               objitem.SetCombinedPath(m_Location);
               objitem.GetFilePath().GetTimeModified(&modtime);
               m_TimeObjModified = modtime;
               return;
               }

            UINT32 m_ID;
            MISTRING m_Location;
            MISTRING m_Format;
            RVC::OBJTYPE m_objtype;
            MISTRING m_Title;
            MISTRING m_Description;
            DATETIME m_TimeRecCreated;
            DATETIME m_TimeRecModified;
            DATETIME m_TimeObjModified;
            double m_LongitudeWest;
            double m_LongitudeEast;
            double m_LatitudeSouth;
            double m_LatitudeNorth;
            MISTRING m_CRS;
            double m_ProjectionMinX;
            double m_ProjectionMaxX;
            double m_ProjectionMinY;
            double m_ProjectionMaxY;
            double m_Accuracy;
            UINT32 m_NumCols;
            UINT32 m_NumLins;
            double m_XScale;
            double m_YScale;
            MISTRING m_DataType;
            
            friend class GEOCAT;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class CONST_ITERATOR {
         public:
            explicit CONST_ITERATOR (
               const GEOCAT *cat = 0
               ):
               m_cat(cat)
               { }

            ~CONST_ITERATOR (
               );

            const RECORD& operator* (
               ) const {
               return (m_record);
               }

            const RECORD* operator-> (
               ) const {
               return (&m_record);
               }

            CONST_ITERATOR& operator++ (
               );

            bool operator== (
               const CONST_ITERATOR& rhs
               ) const {
               return (m_cat == rhs.m_cat && (m_itRecObject.Done() == rhs.m_itRecObject.Done() || m_record.GetID() == rhs.m_record.GetID()));
               }
               
            bool operator!= (
               const CONST_ITERATOR& rhs
               ) const {
               return (!operator==(rhs));
               }

            ERRVALUE GetObject (
               RVC::OBJITEM& objitem,
               bool findnow = false
               ) const;

            bool IsDone (
               ) const { return (m_itRecObject.Done()); }

            ERRVALUE ShowProgress (
               STATUSCONTEXT& scontext,            
               UINT16 line = 0                     
               );
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            const GEOCAT* m_cat;
            RVC::DBTABLE::CONST_RECORDITERATOR m_itRecObject;
            RECORD m_record;

            friend class GEOCAT;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      // XXX If need non-const ITERATOR insert it here...
      
      static const SPATREF::COORDREFSYS& GetCoordRefSys (
         );

      GEOCAT (
         );

      ~GEOCAT (
         );

      ERRVALUE AddMedia (
         const MISTRING& desc
         );

      ERRVALUE BuildIndex (
         );

      ERRVALUE Close (
         );

      ERRVALUE ExcludeFolders (
         const FILEPATHLIST& list,
         bool AddExcludeFile
         );

      void GetExcludeFolders (
         FILEPATHLIST& list
         ) {
         list = m_ExcludeList;
         }

      void GetExcludeAllFolders (
         FILEPATHLIST& list
         ) {
         list = m_ExcludeAllList;
         }

      const FILEPATH& GetFilePath (
         ) const {
         return (m_filepath);
         }

      ERRVALUE GetMediaList (
         MISTRINGLIST& list
         );

      ERRVALUE GetRecord (
         UINT32 id,
         RECORD& FileRecord
         ) const;

      ERRVALUE GetRecord (
         const MISTRING& filepath,
         RECORD& record
         ) const;

      void GetScanFolders (
         FILEPATHLIST& list
         )  {
         list = m_ScanList;
         }

      void IteratorBegin (
         CONST_ITERATOR& iterator
         ) const;

      ERRVALUE Make (
         const FILEPATH& catalog
         );

      ERRVALUE Open (
         const FILEPATH& catalog,
         bool bCreateIfNotFound = false,
         bool bOpenForWrite = false
         );
      
      ERRVALUE PrescanDirectory (
         const FILEPATH& dir,
         STATUSCONTEXT& StatusContext,
         bool bScanSubDirs = true
         ) const;

      ERRVALUE Remove (
         const FILEPATH& file
         );

      ERRVALUE Remove (
         const RECORD& record
         );

      ERRVALUE ScanDirectory (
         const FILEPATH& dir,
         STATUSCONTEXT* StatusContext = 0,
         bool bScanSubDirs = true
         );

      ERRVALUE ScanFile (
         const FILEPATH& file
         );

      ERRVALUE SetScanFolders (
         const FILEPATHLIST& list
         );

      ERRVALUE Write (
         RECORD& record
         );
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE ExtractRecord (
         const RVC::DBTABLE::RECORD& RecObject,
         RECORD& record
         ) const;

      ERRVALUE Read (
         INT32 RecNum,
         RECORD& record
         ) const;

      ERRVALUE Read (
         CONST_ITERATOR& it,
         RECORD& record
         ) const;

      ERRVALUE ScanFolder (
         RVC::OBJECT& ObjParent
         );

      ERRVALUE ScanObject (
         RVC::OBJECT& Object
         );

      UINT32 m_OpenCount;
      FILE_TEXT m_errorlog;
      FILE_TEXT m_scanlog;
      FILEPATH m_filepath;
      FILEPATH m_lastfilepath;
      FILEPATHLIST m_ExcludeList;
      FILEPATHLIST m_ExcludeAllList;
      FILEPATHLIST m_ScanList;
      RVC::DBASE m_ObjDb;
      RVC::DBTABLE m_Table;
      RVC::DBTABLE m_MediaTable;
      RVC::DBTABLE m_ExcludeTable;
      RVC::DBTABLE m_ExcludeAllTable;
      RVC::DBTABLE m_ScanTable;
      bool m_HasNewFields;
      bool m_HasError;
      mutable RVC::DBTABLE::RECORD m_Record;
      mutable RVC::DBTABLE::RECORD m_ExcludeRecord;
      mutable RVC::DBTABLE::RECORD m_ExcludeAllRecord;
      mutable RVC::DBTABLE::RECORD m_ScanRecord;

      // UNIMPLEMENTED / UNSUPPORTED
      GEOCAT (const GEOCAT&);
      GEOCAT& operator= (const GEOCAT&);

      friend class CONST_ITERATOR;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


#endif

---