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;
            }

 
            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;
 

            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);
 
        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) ;

            static SD *Read_Hybrid (int32 sdfileid, int32 hfileid) ;
 

            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) ;
 

            ~SD ();
 
            SD() = default;
 
        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;
 
        friend class File;
    };

    class VDATA
    {
        public:
 
            ~VDATA ();

            static VDATA *Read (int32 vdata_id, int32 obj_ref) ;

            void ReadAttributes (int32 vdata_id) ;

            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;
            }
 
            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;
 
        friend class File;
    };

    class File
    {
        public:

            static File *Read (const char *path, int32 sdid,int32 fileid);

            static File *Read_Hybrid (const char *path, int32 sdid,
                                                   int32 fileid);

            void Prepare() ;
 
            bool Check_update_special(const std::string &gridname) const;
 
            void Handle_AIRS_L23();
 

            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)
            {
            }
 

            void handle_sds_fakedim_names();

            void create_sds_dim_name_list();

            void handle_sds_missing_fields() const;

            void handle_sds_final_dim_names();

            void handle_sds_names(bool & COARDFLAG , std::string & lldimname1, std::string &lldimname2);

            void handle_sds_coords(bool COARDFLAG, const std::string &lldimname1,const std::string &lldimname2);

            void handle_vdata() const;

            void CheckSDType () ;

            void PrepareTRMML2_V6 () ;

            void PrepareTRMML3A_V6 () ;

            void PrepareTRMML3B_V6 () ;

            void PrepareTRMML3C_V6 () ;

            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);

            void PrepareTRMML2_V7 () ;

            void PrepareTRMML3S_V7 () ;

            void PrepareTRMML3M_V7 () ;
 

            void PrepareCERAVGSYN () ;

            void PrepareCERES4IG () ;

            void PrepareCERSAVGID () ;

            void PrepareCERZAVG () ;

            void PrepareOBPGL2 () ;

            void PrepareOBPGL3 () ;

            void PrepareMODISARNSS () ;

            void PrepareOTHERHDF () ;

            void ReadLoneVdatas(File*) const;

            void ReadHybridNonLoneVdatas(const File*);

            void ReadVgattrs(int32 vgroup_id, const char *fullpath);

            void InsertOrigFieldPath_ReadVgVdata () ;

            void obtain_path (int32 file_id, int32 sd_id, char *full_path, int32 pobj_ref) ;

            void obtain_vdata_path(int32 file_id, char *full_path, int32 pobj_ref) ;
 
 
        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