mi32/hdf4.h

Go to the documentation of this file.

#ifndef  INC_MI32_HDF4_H
#define  INC_MI32_HDF4_H

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

#ifndef INC_MI32_FIXEDSTRCHAR_H
#include <mi32/fixedstrchar.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class FILEPATH;
class BITSET;
#endif


enum HDF4_OBJTYPE {
   HDF4_OBJTYPE_Group =    0,    
   HDF4_OBJTYPE_Array =    1,    
   HDF4_OBJTYPE_Table =    2,    
   HDF4_OBJTYPE_Raster =   3,    
   HDF4_OBJTYPE_NUMTYPES
   };

enum HDF4_VALTYPE {
   HDF4_VALTYPE_None =     0,
   HDF4_VALTYPE_UCHAR8 =   3,    
   HDF4_VALTYPE_CHAR8 =    4,    
   HDF4_VALTYPE_FLOAT32 =  5,
   HDF4_VALTYPE_FLOAT64 =  6,
   HDF4_VALTYPE_INT8 =     20,
   HDF4_VALTYPE_UINT8 =    21,
   HDF4_VALTYPE_INT16 =    22,
   HDF4_VALTYPE_UINT16 =   23,
   HDF4_VALTYPE_INT32 =    24,
   HDF4_VALTYPE_UINT32 =   25,
   HDF4_VALTYPE_INT64 =    26,
   HDF4_VALTYPE_UINT64 =   27,
   };


#ifndef GENERATING_DOXYGEN_OUTPUT
class HDF4_FILE_PRIV;
class HDF4_RECORD;
#endif 

class HDF4_NAME : public FIXEDSTRCHAR<256> {
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      char * GetStr () { return (m_String); }

      friend class HDF4_GROUP;
      friend class HDF4_ARRAY;
      friend class HDF4_RASTER;
      friend class HDF4_TABLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class HDF4_FILE {
   public:

      HDF4_FILE (
         ): m_pPriv(0) { }

      HDF4_FILE (
         const HDF4_FILE& rhs
         );

      ~HDF4_FILE (
         );

      HDF4_FILE& operator= (
         const HDF4_FILE& rhs
         );

      void Close (
         );

      bool IsOpen (
         ) const { return (m_pPriv != 0); };

      ERRVALUE Open (
         const FILEPATH& filepath
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      HDF4_FILE_PRIV *m_pPriv;

      friend class HDF4_GROUP;
      friend class HDF4_ARRAY;
      friend class HDF4_RASTER;
      friend class HDF4_TABLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_ATTRIB {
   public:

      HDF4_ATTRIB (
         );

      int GetCount (
         ) const { return (m_count); }

      const char *GetName (
         ) const { return (m_name); }

      ERRVALUE GetString (
         SIMPLE_ARRAY<char>& string
         ) const;

      HDF4_VALTYPE GetType (
         ) const { return (m_type); }

      ERRVALUE GetValue (
         int pos,                      
         double& value                 
         ) const;

      bool IsNumeric (
         ) const { return (m_type != HDF4_VALTYPE_None && m_type != HDF4_VALTYPE_UCHAR8 && m_type != HDF4_VALTYPE_CHAR8); }

      bool IsString (
         ) const { return (m_type == HDF4_VALTYPE_UCHAR8 || m_type == HDF4_VALTYPE_CHAR8); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<char> m_buf;
      HDF4_NAME m_name;
      HDF4_VALTYPE m_type;
      int m_count;

      ERRVALUE Set (
         int type,
         int count
         );

      friend class HDF4_FILE;
      friend class HDF4_GROUP;
      friend class HDF4_ARRAY;
      friend class HDF4_RASTER;
      friend class HDF4_TABLE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_OBJECT {
   public:

      HDF4_OBJECT (
         ) { }

      virtual ~HDF4_OBJECT (
         ) = 0;

      virtual int FindAttrib (
         const char *name
         ) const = 0;

      virtual ERRVALUE GetAttrib (
         int index,
         HDF4_ATTRIB& attrib
         ) const = 0;

      virtual ERRVALUE GetName (
         HDF4_NAME& name                  
         ) const = 0;

      virtual int GetNumAttribs (
         ) const = 0;

      bool IsOpen (
         ) const { return (m_file.IsOpen()); };

   protected:

      HDF4_FILE m_file;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      HDF4_OBJECT (const HDF4_OBJECT&);
      HDF4_OBJECT& operator= (const HDF4_OBJECT&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_GROUP : public HDF4_OBJECT {
   public:

      HDF4_GROUP (
         );

      virtual ~HDF4_GROUP (
         );

      void Close (
         );

      virtual int FindAttrib (
         const char *name                 
         ) const;

      int FindObject (
         HDF4_OBJTYPE type,               
         const char *path                 
         ) const;

      int FindObjectByClass (
         HDF4_OBJTYPE type,               
         const char *classname            
         ) const;

      virtual ERRVALUE GetAttrib (
         int index,                       
         HDF4_ATTRIB& attrib              
         ) const;

      ERRVALUE GetClass (
         HDF4_NAME& classname             
         ) const;

      virtual ERRVALUE GetName (
         HDF4_NAME& name                  
         ) const;

      virtual int GetNumAttribs (
         ) const;

      ERRVALUE GetObjIdxs (
         HDF4_OBJTYPE objtype,            
         SIMPLE_ARRAY<INT32>& objidxs     
         ) const;

      ERRVALUE Open (
         const HDF4_FILE& file,           
         int index                        
         );

      ERRVALUE OpenRoot (
         const HDF4_FILE& file
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_groupid;
      bool m_isroot;

      ERRVALUE CheckInSubGroup (HDF4_OBJTYPE objtype, BITSET& bitset) const;

      HDF4_GROUP (const HDF4_GROUP&);
      HDF4_GROUP& operator= (const HDF4_GROUP&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_ARRAY : public HDF4_OBJECT {
   public:

      class INFO;

      HDF4_ARRAY (
         );

      virtual ~HDF4_ARRAY (
         );

      void Close (
         );

      virtual int FindAttrib (
         const char *name                 
         ) const;

      virtual ERRVALUE GetAttrib (
         int index,                       
         HDF4_ATTRIB& attrib              
         ) const;

      ERRVALUE GetInfo (
         INFO& info                       
         ) const;

      virtual ERRVALUE GetName (
         HDF4_NAME& name                  
         ) const;

      virtual int GetNumAttribs (
         ) const;

      ERRVALUE Open (
         const HDF4_FILE& file,
         int index
         );

      ERRVALUE Read (
         const INT32 *start,
         const INT32 *stride,
         const INT32 *count,
         void *buffer
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_arrayid;
      int m_numdims;
      int m_valuesize;

      HDF4_ARRAY (const HDF4_ARRAY&);
      HDF4_ARRAY& operator= (const HDF4_ARRAY&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

class HDF4_ARRAY::INFO {
   public:

      int GetDim (
         int axis
         ) const { return (m_dims[axis]); }

      double GetNullValue (
         ) const { return (m_NullValue); }

      int GetNumDims (
         ) const { return (m_dims.GetNumItems()); }

      HDF4_VALTYPE GetType (
         ) const { return (m_valtype); }

      bool HasNullValue (
         ) const { return (m_HasNull); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<INT32> m_dims;
      HDF4_VALTYPE m_valtype;
      bool m_HasNull;
      double m_NullValue;
      #endif // GENERATING_DOXYGEN_OUTPUT

      friend class HDF4_ARRAY;
   };


class HDF4_RASTER : public HDF4_OBJECT {
   public:

      class INFO;

      enum INTERLACE {
         INTERLACE_Pixel = 0,
         INTERLACE_Line = 1,
         INTERLACE_Component = 2
         };

      HDF4_RASTER (
         );

      virtual ~HDF4_RASTER (
         );

      void Close (
         );

      virtual int FindAttrib (
         const char *name                 
         ) const;

      virtual ERRVALUE GetAttrib (
         int index,                       
         HDF4_ATTRIB& attrib              
         ) const;

      ERRVALUE GetInfo (
         INFO& info                       
         ) const;

      virtual ERRVALUE GetName (
         HDF4_NAME& name                  
         ) const;

      virtual int GetNumAttribs (
         ) const;

      ERRVALUE Open (
         const HDF4_FILE& file,
         int index
         );

      ERRVALUE Read (
         INT32 ystart,                    
         INT32 xstart,                    
         INT32 ycount,                    
         INT32 xcount,                    
         void *buffer                     
         ) const;

      ERRVALUE SetInterlace (
         INTERLACE interlace
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_rasterid;
      int m_valuesize;

      HDF4_RASTER (const HDF4_RASTER&);
      HDF4_RASTER& operator= (const HDF4_RASTER&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_RASTER::INFO {
   public:

      INT32 GetNumColumns (
         ) const { return (m_NumColumns); }

      INT32 GetNumComponents (
         ) const { return (m_NumComponents); }

      INT32 GetNumLines (
         ) const { return (m_NumLines); }

      HDF4_VALTYPE GetType (
         ) const { return (m_valtype); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      INT32 m_NumComponents;
      INT32 m_NumColumns;
      INT32 m_NumLines;
      HDF4_VALTYPE m_valtype;
      #endif // GENERATING_DOXYGEN_OUTPUT

      friend class HDF4_RASTER;
   };


class HDF4_TABLE : public HDF4_OBJECT {
   public:

      class FIELDINFO {
         public:

            const HDF4_NAME& GetName (
               ) const { return (m_name); }

            int GetOffset (
               ) const { return (m_offset); }

            int GetSize (
               ) const { return (m_size); }

            HDF4_VALTYPE GetType (
               ) const { return (m_type); }

            bool IsString (
               ) const { return (m_type == HDF4_VALTYPE_UCHAR8 || m_type == HDF4_VALTYPE_CHAR8); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            HDF4_NAME m_name;
            HDF4_VALTYPE m_type;
            int m_size;
            int m_offset;
            #endif // GENERATING_DOXYGEN_OUTPUT

            friend class HDF4_TABLE;
         };

      HDF4_TABLE (
         );

      virtual ~HDF4_TABLE (
         );

      void Close (
         );

      virtual int FindAttrib (
         const char *name                 
         ) const;

      virtual ERRVALUE GetAttrib (
         int index,                       
         HDF4_ATTRIB& attrib              
         ) const;

      ERRVALUE GetClass (
         HDF4_NAME& classname             
         ) const;

      const SIMPLE_ARRAY<FIELDINFO>& GetFieldInfo (
         ) const { return (m_FieldInfo); }

      const FIELDINFO& GetFieldInfo (
         int fieldnum                     
         ) const { return (m_FieldInfo[fieldnum]); }

      virtual ERRVALUE GetName (
         HDF4_NAME& name                  
         ) const;

      virtual int GetNumAttribs (
         ) const;

      int GetNumFields (
         ) const { return (m_FieldInfo.GetNumItems()); }

      int GetNumRecords (
         ) const { return (m_NumRecords); }

      ERRVALUE Open (
         const HDF4_FILE& file,           
         int index                        
         );

      ERRVALUE Read (
         HDF4_RECORD& record              
         ) const;

      ERRVALUE Seek (
         int recordnum                    
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      int m_tableid;
      int m_NumRecords;
      int m_RecSize;
      SIMPLE_ARRAY<FIELDINFO> m_FieldInfo;

      HDF4_TABLE (const HDF4_TABLE&);
      HDF4_TABLE& operator= (const HDF4_TABLE&);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class HDF4_RECORD {
   public:

      HDF4_RECORD (
         );

      const char *GetString (
         INT32 FieldNum                   
         ) const;

      double GetValue (
         INT32 FieldNum                   
         ) const;
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      const HDF4_TABLE *m_pTable;
      SIMPLE_ARRAY<UINT8> m_buffer;
      #endif // GENERATING_DOXYGEN_OUTPUT

      friend class HDF4_TABLE;
   };



#endif   

---