HDFSP.h

Go to the documentation of this file.

//  This file is part of the hdf4 data handler for the OPeNDAP data server.
//  TRMM version 7 Level2
//  TRMM version 7 Level3



//#include "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:

            Exception (const std::string & msg)
                : message (msg)
            {
            }

            virtual ~ Exception () throw ()
            {
            }

            virtual const char *what () const throw ()
            {
                return this->message.c_str ();
            }

            virtual void setException (std::string message)
            {
                this->message = message;
            }


        protected:
            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 & name, int32 dimsize, int32 dimtype)
                : name (name), dimsize (dimsize), dimtype (dimtype)
            {
            }

        protected:

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

        protected:

            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()
            {
            }
            ~AttrContainer();

        public:

            const std::string & getName () const
            {
                return this->name;
            }

            // const std::string & getNewName () const
            //{
            //       return this->newname;
            //}

            const std::vector < Attribute * >&getAttributes () const
            {
                return this->attrs;
            }

        protected:
            //  std:: string newname;

            // 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 ():type (-1), rank (-1)
            {
            }
            ~Field ();

        public:

            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;

            int32 rank;

            std::vector < Attribute * >attrs;

        friend class SD;
        friend class VDATA;
        friend class File;
    };


    class SDField:public Field
    {
         public:
            SDField ()
                :fieldtype (0), fieldref (-1), condenseddim (false),is_noscale_dim(false),is_dim_scale(false)
            {
            }
            ~SDField ();

        public:


            const std::vector < Dimension * >&getCorrectedDimensions () const
            {
                return this->correcteddims;
            }

            std::vector < Dimension * >*getCorrectedDimensionsPtr ()
            {
                return &(this->correcteddims);
            }

            void setCorrectedDimensions (std::vector < Dimension * >dims)
            {
                correcteddims = dims;
            }

            const std::string getCoordinate () const
            {
                return this->coordinates;
            }

            void setCoordinates (std::string coor)
            {
                coordinates = coor;
            }

            const std::string getUnits () const
            {
                return this->units;
            }

            // Set the "units" attribute
            void setUnits (std::string uni)
            {
                units = uni;
            }

            // Get the field type
            const 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;
            }

            const std::string getSpecFullPath() const 
            {
                return special_product_fullpath;
            }
        protected:

            std::vector < Dimension * >dims;

            std::vector < Dimension * >correcteddims;

            std::vector<AttrContainer *>dims_info;

            std::string coordinates;

            int fieldtype;

            std::string units;

            std::string special_product_fullpath;

            int32 fieldref;

            bool condenseddim;

            bool is_noscale_dim;

            bool is_dim_scale;

            std::string rootfieldname;

        friend class File;
        friend class SD;
    };

    class VDField:public Field
    {
        public:
            VDField ():order (-1), numrec (-1), size (-1)
            {
            }
            ~VDField ();

        public:

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

        protected:

            int32 order;

            int32 numrec;

            int32 size;

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

            const std::string & getPath () const
            {
                return this->path;
            }

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

        protected:
            SD (int32 sdfileid, int32 hfileid)
                : sdfd (sdfileid), fileid (hfileid)
            {
            }

        protected:

            std::string path;

            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;

        private:

            int32 sdfd;
            int32 fileid;
        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;
            }

        protected:
            VDATA (int32 vdata_myid, int32 obj_ref)
                :vdref(obj_ref),TreatAsAttrFlag (true),vdata_id (vdata_myid) {
            }

        protected:

            std::string newname;

            std::string name;

            std::vector < VDField * >vdfields;

            std::vector < Attribute * >attrs;

            int32 vdref;

            bool TreatAsAttrFlag;

        private:

            int32 vdata_id;

        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:
            File (const char *path)
                : path (path), sdfd (-1), fileid (-1), sptype (OTHERHDF),OTHERHDF_Has_Dim_NoScale_Field(false),EOS2Swathflag(false)
            {
            }

        protected:

            std::string path;

            SD *sd;

            std::vector < VDATA * >vds;

            std::vector<AttrContainer *>vg_attrs;

          
            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) throw(Exception);
            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 () throw (Exception);


            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, 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:

            int32 sdfd; 

            int32 fileid;

            SPType sptype;

            bool OTHERHDF_Has_Dim_NoScale_Field;

            bool EOS2Swathflag;
    };

}


#endif