HDFSP.h

//  This file is part of the hdf4 data handler for the OPeNDAP data server.
//  TRMM version 7 Level2
//  TRMM version 7 Level3
 
 
 
//#include <libdap/InternalErr.h>
#ifndef _HDFSP_H
#define _HDFSP_H
 
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <list>
#include "mfhdf.h"
#include "hdf.h"
 
#include "HDFSPEnumType.h"
 
#define MAX_FULL_PATH_LEN 1024
//#define EOS_DATA_PATH "Data Fields"
//#define EOS_GEO_PATH "Geolocation Fields"
 
#define _HDF_CHK_TBL_CLASS "_HDF_CHK_TBL_"
#define CERE_META_NAME "CERES_metadata"
#define CERE_META_FIELD_NAME "LOCALGRANULEID"
#define SENSOR_NAME "Sensor Name"
#define PRO_NAME "Product Name"
#define CER_AVG_NAME "CER_AVG"
#define CER_ES4_NAME "CER_ES4"
#define CER_CDAY_NAME "CER_ISCCP-D2like-Day"
#define CER_CGEO_NAME "CER_ISCCP-D2like-GEO"
#define CER_SRB_NAME "CER_SRBAVG3"
#define CER_SYN_NAME "CER_SYN"
#define CER_ZAVG_NAME "CER_ZAVG"
 
 
 
 
 
namespace HDFSP
{
    class File;
    class SD;
    class VDATA;
 
    class Exception:public std::exception
    {
         public:
 
            explicit Exception (const std::string & msg)
                : message (msg)
            {
            }
 
            ~ Exception () throw () override = default;
 
            const char *what () const throw () override
            {
                return this->message.c_str ();
            }
 
            virtual void setException (const std::string &exception_message)
            {
                this->message = exception_message;
            }
 
 
        private:
            std::string message;
    };
 
 
    class Dimension
    {
        public:
 
            const std::string & getName () const
            {
                return this->name;
            }
 
            int32 getSize () const
            {
                return this->dimsize;
            }
 
            int32 getType () const
            {
                return this->dimtype;
            }
 
        protected:
            Dimension (const std::string & dim_name, int32 hdf4_dimsize, int32 hdf4_dimtype)
                : name (dim_name), dimsize (hdf4_dimsize), dimtype (hdf4_dimtype)
            {
            }
 
        private:
            // dimension name
            std::string name;
 
            // dimension size
            int32 dimsize;
 
            int32 dimtype;
 
        friend class SD;
        friend class File;
        friend class SDField;
    };
 
    class Attribute
    {
        public:
 
            const std::string & getName () const
            {
                return this->name;
            }
 
            const std::string & getNewName () const
            {
                return this->newname;
            }
 
            int32 getType () const
            {
                return this->type;
            }
 
            int32 getCount () const
            {
                return this->count;
            }
 
            const std::vector < char >&getValue () const
            {
                return this->value;
            }
 
        private:
 
            std::string name;
 
            std::string newname;
 
            int32 type;
 
            int32 count;
 
            std::vector < char >value;
 
        friend class SD;
        friend class VDATA;
        friend class File;
        friend class Field;
        friend class VDField;
    };
 
    class AttrContainer {
 
        public:
            AttrContainer() = default;
            ~AttrContainer();
 
 
            const std::string & getName () const
            {
                return this->name;
            }
 
#if 0
            // const std::string & getNewName () const
            //{
            //       return this->newname;
            //}
#endif
            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }
 
        private:
 
            // The name of this attribute container(an attribute container is a DAP DAS table)
            std:: string name;
 
            // The attributes in this attribute container
            std::vector < Attribute * >attrs;
        friend class SD;
        friend class File;
 
    };
 
 
    // This field class describes SDS or Vdata fields. 
    class Field
    {
        public:
            Field () = default;
            
            virtual ~ Field ();
 
            const std::string & getName () const
            {
                return this->name;
            }
 
            const std::string & getNewName () const
            {
                return this->newname;
            }
 
            int32 getRank () const
            {
                return this->rank;
            }
 
            int32 getType () const
            {
                return this->type;
            }
 
            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }
 
 
        protected:
 
            std::string newname;
 
            std::string name;
 
            int32 type = -1;
 
            int32 rank = -1;
 
            std::vector < Attribute * >attrs;
 
        friend class SD;
        friend class VDATA;
        friend class File;
    };
 
 
    class SDField:public Field
    {
         public:
            SDField () = default;
            ~SDField () override;
 
 
            const std::vector < Dimension * >&getCorrectedDimensions () const
            {
                return this->correcteddims;
            }
 
            std::vector < Dimension * >*getCorrectedDimensionsPtr ()
            {
                return &(this->correcteddims);
            }
 
            void setCorrectedDimensions (const std::vector < Dimension * > &cor_dims)
            {
                correcteddims = cor_dims;
            }
 
            std::string getCoordinate () const
            {
                return this->coordinates;
            }
 
            void setCoordinates (const std::string& coor)
            {
                coordinates = coor;
            }
 
            std::string getUnits () const
            {
                return this->units;
            }
 
            // Set the "units" attribute
            void setUnits (const std::string &uni)
            {
                units = uni;
            }
 
            // Get the field type
            int getFieldType () const
            {
                return this->fieldtype;
            }
        
            // Get the SDS reference number
            int32 getFieldRef () const
            {
                return this->fieldref;
            }
 
            const std::vector < Dimension * >&getDimensions () const
            {
                return this->dims;
            }
 
            const std::vector < AttrContainer * >&getDimInfo () const
            {
                return this->dims_info;
            }
 
 
            bool IsDimNoScale() const
            {
                return is_noscale_dim;
            }
 
            bool IsDimScale() const
            {
                return is_dim_scale;
            }
 
            std::string getSpecFullPath() const 
            {
                return special_product_fullpath;
            }
        private:
 
            std::vector < Dimension * >dims;
 
            std::vector < Dimension * >correcteddims;
 
            std::vector<AttrContainer *>dims_info;
 
            std::string coordinates;
 
            int fieldtype = 0;
 
            std::string units;
 
            std::string special_product_fullpath;
 
            int32 fieldref = -1;
 
#if 0
            bool condenseddim = false;
#endif
 
            bool is_noscale_dim = false;
 
            bool is_dim_scale = false;
 
            std::string rootfieldname;
 
        friend class File;
        friend class SD;
    };
 
    class VDField:public Field
    {
        public:
            VDField () = default;
            ~VDField () override = default;
 
            int32 getFieldOrder ()const
            {
                return this->order;
            }
 
            int32 getFieldsize () const
            {
                return this->size;
            }
 
            int32 getNumRec () const
            {
                return this->numrec;
            }
 
            const std::vector < char >&getValue () const
            {
                return this->value;
            }
 
            void ReadAttributes (int32 vdata_id, int32 fieldindex) throw (Exception);
 
        private:
 
            int32 order = -1;
 
            int32 numrec = -1;
 
            int32 size = -1;
 
            std::vector < char >value;
 
        friend class File;
        friend class VDATA;
    };
 
    class SD
    {
        public:
 
            static SD *Read (int32 sdfileid, int32 hfileid) throw (Exception);
 
            static SD *Read_Hybrid (int32 sdfileid, int32 hfileid) throw (Exception);
 
#if 0
            const std::string & getPath () const
            {
                return this->path;
            }
#endif
 
            const std::vector < SDField * >&getFields () const
            {
                return this->sdfields;
            }
 
            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }
 
            void obtain_noneos2_sds_path(int32,char*,int32) throw(Exception);
 
 
            ~SD ();
 
            SD() = default;
#if 0
            SD (int32 sdfileid, int32 hfileid)
                : sdfd (sdfileid), fileid (hfileid)
            {
            }
#endif
 
        private:
            std::vector < SDField * >sdfields;
 
            std::vector < Attribute * >attrs;
 
            std::list <int32> sds_ref_list;
 
            std::map < int32, int >refindexlist;
 
            std::map < std::string, int32 > n1dimnamelist;
 
            std::map < std::string, std::string > n2dimnamelist;
 
            std::set < std::string > fulldimnamelist;
 
            std::set < std::string > nonmisscvdimnamelist;
 
            std::map < std::string, std::string > dimcvarlist;
 
#if 0
        private:
 
            int32 sdfd;
            int32 fileid;
#endif
        friend class File;
    };
 
    class VDATA
    {
        public:
 
            ~VDATA ();
 
            static VDATA *Read (int32 vdata_id, int32 obj_ref) throw (Exception);
 
            void ReadAttributes (int32 vdata_id) throw (Exception);
 
            const std::string & getNewName () const
            {
                return this->newname;
            }
 
            const std::string & getName () const
            {
                return this->name;
            }
 
            const std::vector < VDField * >&getFields () const
            {
                return this->vdfields;
            }
 
            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }
 
            bool getTreatAsAttrFlag () const
            {
                return TreatAsAttrFlag;
            }
 
            int32 getObjRef () const
            {
                return vdref;
            }
 
#if 0
            VDATA (int32 vdata_myid, int32 obj_ref)
                :vdref(obj_ref),vdata_id (vdata_myid) {
            }
#endif
            VDATA (int32 obj_ref)
                :vdref(obj_ref){
            }
 
        private:
            std::string newname;
 
            std::string name;
 
            std::vector < VDField * >vdfields;
 
            std::vector < Attribute * >attrs;
 
            int32 vdref;
 
            bool TreatAsAttrFlag = true;
 
#if 0
            int32 vdata_id;
#endif
 
        friend class File;
    };
 
    class File
    {
        public:
 
            static File *Read (const char *path, int32 sdid,int32 fileid) throw (Exception);
 
            static File *Read_Hybrid (const char *path, int32 sdid,
                                                   int32 fileid) throw (Exception);
 
            void Prepare() throw(Exception);
 
            bool Check_update_special(const std::string &gridname) throw(Exception);
 
            void Handle_AIRS_L23() throw(Exception);
 
 
            SPType getSPType () const
            {
                return this->sptype;
            }
 
 
            bool Has_Dim_NoScale_Field() const
            {
                return this->OTHERHDF_Has_Dim_NoScale_Field;
            }
 
            // Destructor
            ~File ();
 
            const std::string & getPath () const
            {
                return this->path;
            }
 
            SD *getSD () const
            {
                return this->sd;
            }
 
            const std::vector < VDATA * >&getVDATAs () const
            {
                return this->vds;
            }
 
            const std::vector<AttrContainer *> &getVgattrs () const
            {
                return this->vg_attrs;
            }
 
 
 
        protected:
            explicit File (const char *hdf4file_path)
                : path (hdf4file_path)
            {
            }
 
 
#if 0
            std::string path;
 
            SD *sd;
 
            std::vector < VDATA * >vds;
 
            std::vector<AttrContainer *>vg_attrs;
#endif
 
            void handle_sds_fakedim_names() throw(Exception);
 
            void create_sds_dim_name_list();
 
            void handle_sds_missing_fields();
 
            void handle_sds_final_dim_names() throw(Exception);
 
            void handle_sds_names(bool & COARDFLAG , std::string & lldimname1, std::string &lldimname2) throw(Exception);
 
            void handle_sds_coords(bool & COARDFLAG, std::string &lldimname1,std::string &lldimname2) throw(Exception);
 
            void handle_vdata() throw(Exception);
 
            void CheckSDType () throw (Exception);
 
            void PrepareTRMML2_V6 () throw (Exception);
 
            void PrepareTRMML3A_V6 () throw (Exception);
 
            void PrepareTRMML3B_V6 () throw (Exception);
 
            void PrepareTRMML3C_V6 () throw (Exception);
 
            void Obtain_TRMML3S_V7_latlon_size(int &latsize, int&lonsize);
 
            bool Obtain_TRMM_V7_latlon_name(const SDField* sdfield, const int latsize, const int lonsize, std::string& latname, std::string& lonname) throw(Exception);
 
            void PrepareTRMML2_V7 () throw (Exception);
 
            void PrepareTRMML3S_V7 () throw (Exception);
 
            void PrepareTRMML3M_V7 () ;
 
 
            void PrepareCERAVGSYN () throw (Exception);
 
            void PrepareCERES4IG () throw (Exception);
 
            void PrepareCERSAVGID () throw (Exception);
 
            void PrepareCERZAVG () throw (Exception);
 
            void PrepareOBPGL2 () throw (Exception);
 
            void PrepareOBPGL3 () throw (Exception);
 
            void PrepareMODISARNSS () throw (Exception);
 
            void PrepareOTHERHDF () throw (Exception);
 
            void ReadLoneVdatas(File*) throw(Exception);
 
            void ReadHybridNonLoneVdatas(File*) throw(Exception);
 
            void ReadVgattrs(int32 vgroup_id, const char *fullpath) throw(Exception);
 
            void InsertOrigFieldPath_ReadVgVdata () throw (Exception);
 
            void obtain_path (int32 file_id, int32 sd_id, char *full_path, int32 pobj_ref) throw (Exception);
 
            void obtain_vdata_path(int32 file_id, char *full_path, int32 pobj_ref) throw (Exception);
 
 
        private:
 
            std::string path;
 
            SD *sd = nullptr;
 
            std::vector < VDATA * >vds;
 
            std::vector<AttrContainer *>vg_attrs;
 
 
            int32 sdfd = -1;    
 
            int32 fileid = -1;
 
            SPType sptype = OTHERHDF;
 
            bool OTHERHDF_Has_Dim_NoScale_Field = false;
 
            bool EOS2Swathflag = false;
    };
 
}
 
 
#endif