HDF5CF.h

Go to the documentation of this file.

// This file is part of the hdf5_handler implementing for the CF-compliant
// Copyright (c) 2011-2013 The HDF Group, Inc. and OPeNDAP, Inc.
//
// This is free software; you can redistribute it and/or modify it under the
// terms of the GNU Lesser General Public License as published by the Free
// Software Foundation; either version 2.1 of the License, or (at your
// option) any later version.
//
// This software is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
// or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
// License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
// You can contact The HDF Group, Inc. at 1800 South Oak Street,
// Suite 203, Champaign, IL 61820  


#ifndef _HDF5CF_H
#define _HDF5CF_H

#include<sstream>
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <list>
#include "HDF5CFUtil.h"
#include "h5cfdaputil.h"
#include "HDF5GCFProduct.h"
#include "HE5Parser.h"


enum CVType { CV_EXIST,CV_LAT_MISS,CV_LON_MISS,CV_NONLATLON_MISS,CV_FILLINDEX,CV_MODIFY,CV_SPECIAL};
enum EOS5Type {GRID,SWATH,ZA,OTHERVARS};
enum GMPattern {GENERAL_DIMSCALE,GENERAL_LATLON2D,OTHERGMS};
enum EOS5AuraName {OMI,MLS,HIRDLS,TES};
static string FILE_ATTR_TABLE_NAME ="HDF5_GLOBAL";


namespace HDF5CF
{
    class File;
    class GMFile;
    class EOS5File;

    class Exception:public exception
    {
        public:
            Exception (const string & msg)
                : message (msg)
            {
            }

            virtual ~ Exception () throw ()
            {
            }

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


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


        protected:
            std::string message;
    };
    template < typename T, typename U, typename V, typename W, typename X > static void
    _throw5 (const char *fname, int line, int numarg,
                 const T & a1, const U & a2, const V & a3, const W & a4, const X & a5)
    {
        ostringstream ss;
        ss << fname << ":" << line << ":";
        for (int i = 0; i < numarg; ++i) {
            ss << " ";
            switch (i) {
                case 0:
                    ss << a1;
                    break;
                case 1:
                    ss << a2;
                    break;
                case 2:
                    ss << a3;
                    break;
                case 3:
                    ss << a4;
                    break;
                case 4:
                    ss << a5;
                    break;
            }
        }
        throw Exception (ss.str ());
    }

// number of arguments.
#define throw1(a1)  _throw5(__FILE__, __LINE__, 1, a1, 0, 0, 0, 0)
#define throw2(a1, a2)  _throw5(__FILE__, __LINE__, 2, a1, a2, 0, 0, 0)
#define throw3(a1, a2, a3)  _throw5(__FILE__, __LINE__, 3, a1, a2, a3, 0, 0)
#define throw4(a1, a2, a3, a4)  _throw5(__FILE__, __LINE__, 4, a1, a2, a3, a4, 0)
#define throw5(a1, a2, a3, a4, a5)  _throw5(__FILE__, __LINE__, 5, a1, a2, a3, a4, a5)

    struct delete_elem
    {
        template < typename T > void operator () (T * ptr)
        {
            delete ptr;
        }
    };

       
    // It holds only the size of that dimension.
    // Note: currently the unlimited dimension(maxdims) case 
    // doesn't need to be considered.
    class Dimension
    {
        public:
            hsize_t getSize () const
            {
                return this->size;
            }
            const string & getName () const
            {
                return this->name;
            }
            const string & getNewName () const
            {
                return this->newname;
            }


        protected:
            Dimension (hsize_t dimsize)
                : size (dimsize),name(""),newname("")
            {
            }

        protected:
            hsize_t size;
            string name;
            string newname;

            friend class EOS5File;
            friend class GMFile;
            friend class File;
            friend class Var;
            friend class CVar;
            friend class GMCVar;
            friend class EOS5CVar;
            friend class GMSPVar;
    };

    class Attribute
    {

        public:
            Attribute ():dtype(H5UNSUPTYPE)
            {
            }
            ~Attribute ();

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

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

            H5DataType getType () const
            {
                return this->dtype;
            }

            hsize_t getCount () const
            {
                return this->count;
            }

            size_t getBufSize() const
            { 
               return (this->value).size();
            }

            const std::vector < char >&getValue () const
            {
                return this->value;
            }
            
            const std::vector < size_t >&getStrSize () const
            {
                return this->strsize;
            }


         protected:
            string name;
            string newname;
            H5DataType dtype;
            hsize_t count;
            vector <size_t>strsize;
            size_t fstrsize;
            vector < char >value;

            friend class File;
            friend class GMFile;
            friend class EOS5File;
            friend class Var;
            friend class CVar;
            friend class GMCVar;
            friend class GMSPVar;
            friend class EOS5CVar;
    };


    class Var 
    {
        public:
            Var ():
                   dtype (H5UNSUPTYPE), 
                   rank (-1),
                   unsupported_attr_dtype(false),
                   unsupported_dspace(false),
                   dimnameflag(false)
            {
            }
            ~Var ();

        public:

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

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

            const string & getFullPath () const
            {
                return this->fullpath;
            }

            int getRank () const
            {
                return this->rank;
            }

            H5DataType getType () const
            {
                return this->dtype;
            }

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

            const vector < Dimension * >&getDimensions () const
            {
                return this->dims;
            }


        protected:

            std::string newname;
            std::string name;
            std::string fullpath;
            H5DataType dtype;
            int rank;
            bool unsupported_attr_dtype;
            bool unsupported_dspace;
            bool dimnameflag;

            vector < Attribute * >attrs;
            vector < Dimension *>dims;

            friend class CVar;
            friend class GMCVar;
            friend class GMSPVar;
            friend class EOS5CVar;
            friend class File;
            friend class GMFile;
            friend class EOS5File;
    };

    class CVar:public Var {
        public:
            CVar() {}
            ~CVar() { }    
            CVType getCVType () const
            {
                return this->cvartype;
            }

        private:
            // Each coordinate variable has and only has one dimension
            // This assumption is based on the exact match between
            // variables and dimensions
            string  cfdimname;
            CVType cvartype;

       friend class File;
       friend class GMFile;
       friend class EOS5File;
    };

    class GMSPVar:public Var {
        public:
            GMSPVar():otype(H5UNSUPTYPE),
                      sdbit(-1),
                      numofdbits(-1) 
            {
            }
            GMSPVar(Var *var);
            ~GMSPVar() {}
            H5DataType getOriginalType() const {
                return this->otype;
            }

            int getStartBit() const {
                return this->sdbit;
            }

            int getBitNum() const {
                return this->numofdbits;
            }

        private:
            H5DataType otype;
            int sdbit;
            int numofdbits;

        friend class File;
        friend class GMFile;
    };

    class GMCVar:public CVar {
        public:
            GMCVar():product_type(General_Product) {}
            GMCVar(Var*var);
            ~GMCVar() {}

            H5GCFProduct getPtType () const
            {
                return this->product_type;
            }

        private:
            H5GCFProduct product_type;
        friend class GMFile;
    };

    class EOS5CVar: public CVar {
        public:
            EOS5CVar():is_2dlatlon(false) {}
            EOS5CVar(Var *);

            ~EOS5CVar() {}

            EOS5Type getEos5Type() const {
                return this->eos_type;
            }
            float getPointLower() const{
                return this->point_lower;
            }
            float getPointUpper() const{
                return this->point_upper;
            }

            float getPointLeft() const{
                return this->point_left;
            }
            float getPointRight() const{
                return this->point_right;
            }

            EOS5GridPRType getPixelReg() const{
                return this->eos5_pixelreg;
            }
            EOS5GridOriginType getOrigin() const{
                return this->eos5_origin;
            }

            EOS5GridPCType getProjCode() const{
                return this->eos5_projcode;
            }

            int getXDimSize() const {
                return this->xdimsize;
            }

            int getYDimSize() const {
                return this->ydimsize;
            }

        private:
            EOS5Type eos_type;
            bool is_2dlatlon;
            float point_lower;
            float point_upper;
            float point_left;
            float point_right;
            int xdimsize;
            int ydimsize;
            EOS5GridPRType eos5_pixelreg;
            EOS5GridOriginType eos5_origin;
            EOS5GridPCType eos5_projcode;
        friend class EOS5File;
    };


    class Group
    {
        public:
            Group ():unsupported_attr_dtype(false)
            {
            }
            ~Group ();

        public:

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

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

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

        protected:

            string newname;
            string path;

            vector < Attribute * >attrs;
            bool unsupported_attr_dtype;

            friend class File;
            friend class GMFile;
            friend class EOS5File;
    };


    class File
    {
        public:

            virtual void Retrieve_H5_Info (const char *path,
                                           hid_t file_id, bool include_attr) throw (Exception);

            virtual void Retrieve_H5_Supported_Attr_Values() throw (Exception);

            virtual void Handle_Unsupported_Dtype(bool) throw(Exception);
                 
            virtual void Handle_Unsupported_Dspace() throw(Exception);

            virtual void Flatten_Obj_Name(bool) throw(Exception);

            virtual void Add_Supplement_Attrs(bool) throw(Exception);

            virtual void Handle_Coor_Attr() = 0;
                 
            virtual void Handle_CVar() = 0;

            virtual void Handle_SpVar() = 0;

            virtual void Handle_SpVar_Attr() = 0;


            virtual void Adjust_Obj_Name() = 0;

            virtual void Adjust_Dim_Name() = 0;

            virtual void Handle_DimNameClashing() = 0;

            const hid_t getFileID () const
            {
                return this->fileid;
            }

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

            const vector < Var * >&getVars () const
            {
                return this->vars;
            }

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

            const vector < Group * >&getGroups () const
            {
                return this->groups;
            }

            virtual ~File ();

        protected:

            void Retrieve_H5_Obj(hid_t grp_id,const char*gname, bool include_attr) throw(Exception);
            void Retrieve_H5_Attr_Info(Attribute *,hid_t obj_id,const int j, bool& unsup_attr_dtype) throw(Exception);
            void Retrieve_H5_Attr_Value( Attribute *attr, string) throw (Exception);

            void Retrieve_H5_VarType(Var*,hid_t dset_id, const string& varname, bool &unsup_var_dtype) throw(Exception);
            void Retrieve_H5_VarDim(Var*,hid_t dset_id,const string &varname, bool & unsup_var_dspace) throw(Exception);

            void Handle_GeneralObj_NameClashing(bool,set<string> &objnameset) throw(Exception);
            void Handle_Var_NameClashing(set<string> &objnameset) throw(Exception);
            void Handle_RootGroup_NameClashing(set<string> &objnameset) throw(Exception);
            void Handle_Obj_AttrNameClashing() throw(Exception);
            template <typename T> void Handle_General_NameClashing(set <string>&objnameset, vector<T*>& objvec) throw(Exception);

            void Add_One_FakeDim_Name(Dimension *dim) throw(Exception);
            void Adjust_Duplicate_FakeDim_Name(Dimension * dim)throw(Exception);
            void Insert_One_NameSizeMap_Element(string name,hsize_t size) throw(Exception);
            void Insert_One_NameSizeMap_Element2(map<string,hsize_t> &,string name,hsize_t size) throw(Exception);

            virtual string get_CF_string(string);
            virtual void Replace_Var_Info(Var* src, Var *target);
            virtual void Replace_Var_Attrs(Var *src, Var*target);

            void Add_Str_Attr(Attribute* attr,const string &attrname, const string& strvalue) throw(Exception);
            void Add_One_Float_Attr(Attribute* attr,const string &attrname, float float_value) throw(Exception);
            void Change_Attr_One_Str_to_Others(Attribute *attr, Var *var) throw(Exception);
 

        protected:
            File (const char *path, hid_t file_id)
                  : path (string(path)),  
                    fileid (file_id),
                    rootid(-1),
                    unsupported_var_dtype(false),
                    unsupported_attr_dtype(false),
                    unsupported_var_dspace(false),
                    addeddimindex(0)
            {
            }

        protected:

            string path;
            hid_t fileid;
            hid_t rootid;                       

            vector < Var * >vars;

            vector < Attribute * >root_attrs;

            vector < Group* >groups;

            bool unsupported_var_dtype;
            bool unsupported_attr_dtype; 

            bool unsupported_var_dspace;

            set<string> dimnamelist;
            map<string,hsize_t> dimname_to_dimsize;

            map<hsize_t,string> dimsize_to_fakedimname;
            int addeddimindex;

    };

    class GMFile:public File {
        public:
            GMFile(const char*path, hid_t file_id, H5GCFProduct product,GMPattern gproduct_pattern);
            virtual ~GMFile(); 
        public:
            H5GCFProduct getProductType() const {
                return product_type;
            }

            const vector<GMCVar *>&getCVars() const {
                return this->cvars;
            }

            const vector<GMSPVar *>&getSPVars() const {
                return this->spvars;
            }
        
            void Retrieve_H5_Info(const char *path,
                              hid_t file_id, bool include_attr) throw (Exception);

            void Retrieve_H5_Supported_Attr_Values() throw (Exception);

            void Adjust_H5_Attr_Value(Attribute *attr) throw (Exception);

            void Handle_Unsupported_Dtype(bool) throw(Exception);

            void Handle_Unsupported_Dspace() throw(Exception);

            void Add_Dim_Name()throw(Exception);
       
            void Handle_CVar() throw(Exception);

            void Handle_SpVar()throw(Exception);

            void Handle_SpVar_Attr()throw(Exception);


            void Adjust_Obj_Name() throw(Exception);

            void Flatten_Obj_Name(bool include_attr) throw(Exception);

            void Handle_Obj_NameClashing(bool) throw(Exception);


            void Adjust_Dim_Name() throw(Exception);

            void Handle_DimNameClashing() throw(Exception);

            void Add_Supplement_Attrs(bool) throw(Exception);

            void Handle_Coor_Attr();

        protected: 
            void Add_Dim_Name_GPM() throw(Exception);
            void Add_Dim_Name_Mea_SeaWiFS() throw(Exception);
            void Handle_UseDimscale_Var_Dim_Names_Mea_SeaWiFS_Ozone(Var*)throw(Exception);
            void Add_UseDimscale_Var_Dim_Names_Mea_SeaWiFS_Ozone(Var *,Attribute*)throw(Exception);

            void Add_Dim_Name_Mea_Ozonel3z() throw(Exception);
            bool check_cv(string & varname) throw(Exception);


            void Add_Dim_Name_Aqu_L3()throw(Exception);
            void Add_Dim_Name_OBPG_L3()throw(Exception);
            void Add_Dim_Name_SMAP()throw(Exception);
            void Add_Dim_Name_ACOS_L2S()throw(Exception);

            void Add_Dim_Name_General_Product()throw(Exception);
            void Check_General_Product_Pattern() throw(Exception);
            void Add_Dim_Name_Dimscale_General_Product() throw(Exception);
            void Handle_UseDimscale_Var_Dim_Names_General_Product(Var*) throw(Exception);
            void Add_UseDimscale_Var_Dim_Names_General_Product(Var*,Attribute*) throw(Exception);

            void Handle_CVar_GPM_L1() throw(Exception);
            void Handle_CVar_GPM_L3() throw(Exception);
            void Handle_CVar_Mea_SeaWiFS() throw(Exception);
            void Handle_CVar_Aqu_L3() throw(Exception);
            void Handle_CVar_OBPG_L3() throw(Exception);
            void Handle_CVar_SMAP() throw(Exception);
            void Handle_CVar_Mea_Ozone() throw(Exception);
            void Handle_SpVar_ACOS() throw(Exception);
            void Handle_CVar_Dimscale_General_Product() throw(Exception);

            void Adjust_Mea_Ozone_Obj_Name() throw(Exception);
            void Adjust_GPM_L3_Obj_Name() throw(Exception);

            void Handle_GMCVar_NameClashing(set<string> &) throw(Exception);
            void Handle_GMCVar_AttrNameClashing() throw(Exception);
            void Handle_GMSPVar_NameClashing(set<string> &) throw(Exception);
            void Handle_GMSPVar_AttrNameClashing() throw(Exception);
            template <typename T> void GMHandle_General_NameClashing(set <string>&objnameset, vector<T*>& objvec) throw(Exception);
 
            string get_CF_string(string s);

            void Handle_GPM_l1_Coor_Attr() throw(Exception);
            void Add_GPM_Attrs() throw(Exception);
            void Add_Aqu_Attrs() throw(Exception);
            void Add_SeaWiFS_Attrs() throw(Exception);
            void Create_Missing_CV(GMCVar*,const string &) throw(Exception);
            bool Is_netCDF_Dimension(Var *var) throw(Exception);
 
        private:
            H5GCFProduct product_type;
            GMPattern gproduct_pattern;
            vector <GMCVar *>cvars;
            vector <GMSPVar *>spvars;
            bool iscoard;
         
    };

    class EOS5CFGrid {
        public:
            EOS5CFGrid():
                 addeddimindex(0), 
                 has_nolatlon(true),
                 has_1dlatlon(false),
                 has_2dlatlon(false),
                 has_g2dlatlon(false)
            {};
            ~EOS5CFGrid() {};
        protected:
            void Update_Dimnamelist();
        private:
            float point_lower;
            float point_upper;
            float point_left;
            float point_right;
            EOS5GridPRType eos5_pixelreg;
            EOS5GridOriginType eos5_origin;
            EOS5GridPCType eos5_projcode;

            vector <string> dimnames;
            set <string> vardimnames;
            map <string,hsize_t>dimnames_to_dimsizes;
            map <hsize_t,string>dimsizes_to_dimnames;
            int addeddimindex;
        

            map <string,string> dnames_to_1dvnames;
            string name;
            int xdimsize;
            int ydimsize;
            bool has_nodimnames_vars;
            bool has_nolatlon;
            bool has_1dlatlon;
            bool has_2dlatlon;
            bool has_g2dlatlon;

            friend class EOS5File;    
        };
        
    class EOS5CFSwath {
        public:
            EOS5CFSwath():
                addeddimindex(0),
                has_nolatlon(true),
                has_1dlatlon(false),
                has_2dlatlon(false),
                has_g2dlatlon(false)
                {};
            ~EOS5CFSwath() {};

        private:

            vector <string> dimnames;
            set <string> vardimnames;
            map <string,hsize_t>dimnames_to_dimsizes;
            map <hsize_t,string>dimsizes_to_dimnames;
            int addeddimindex;
 
            map <string,string> dnames_to_geo1dvnames;
            string name;
            bool has_nolatlon;
            bool has_1dlatlon;
            bool has_2dlatlon;
            bool has_g2dlatlon;

            friend class EOS5File;    
    };

    class EOS5CFZa {
        public:
            EOS5CFZa():addeddimindex(0) {};
            ~EOS5CFZa() {};
        private:

            vector <string> dimnames;
            set <string> vardimnames;
            map <string,hsize_t>dimnames_to_dimsizes;
            map <hsize_t,string>dimsizes_to_dimnames;
            int addeddimindex;

            map <string,string> dnames_to_1dvnames;
            string name;

            friend class EOS5File;    
    };
   

    class EOS5File:public File {
        public:
            EOS5File(const char*path, hid_t file_id):
                       File(path,file_id),
                       iscoard(false),
                       grids_multi_latloncvs(false),
                       isaura(false),
                       orig_num_grids(0)
                       { };
            virtual ~EOS5File(); 
        public:

            const vector<EOS5CVar *>&getCVars() const{
                return this->cvars;
            }

            void Retrieve_H5_Info(const char *path,
                              hid_t file_id, bool include_attr) throw (Exception);

            void Retrieve_H5_Supported_Attr_Values() throw (Exception);

            void Handle_Unsupported_Dtype(bool) throw(Exception);

            void Handle_Unsupported_Dspace() throw(Exception);

            void Adjust_EOS5Dim_Info(HE5Parser*strmeta_info) throw(Exception);

            void Add_EOS5File_Info(HE5Parser*, bool) throw(Exception);

            void Adjust_Var_NewName_After_Parsing() throw(Exception);

            void Adjust_Obj_Name() throw(Exception);

            void Add_Dim_Name( HE5Parser *)throw(Exception);

            void Check_Aura_Product_Status() throw(Exception);

            void Handle_CVar() throw(Exception);
        
            void Handle_SpVar()throw(Exception) ;

            void Handle_SpVar_Attr()throw(Exception) ;


            void Adjust_Var_Dim_NewName_Before_Flattening() throw(Exception);

            void Flatten_Obj_Name(bool include_attr) throw(Exception);

            void Set_COARDS_Status() throw(Exception);

            void Adjust_Attr_Info() throw(Exception);

//        void Adjust_Special_EOS5CVar_Name() throw(Exception);

            void Handle_Obj_NameClashing(bool) throw(Exception);

            void Add_Supplement_Attrs(bool) throw(Exception);

            void Handle_Coor_Attr();

            void Adjust_Dim_Name() throw(Exception);

            void Handle_DimNameClashing() throw(Exception);

        protected:
            void Adjust_H5_Attr_Value(Attribute *attr) throw (Exception);

            void Adjust_EOS5Dim_List(vector<HE5Dim>&) throw(Exception);
            void Condense_EOS5Dim_List(vector<HE5Dim>&) throw(Exception);
            void Remove_NegativeSizeDims(vector<HE5Dim>&) throw(Exception);
            void Adjust_EOS5VarDim_Info(vector<HE5Dim>&, vector<HE5Dim>&,const string &, EOS5Type) throw(Exception);

            void EOS5Handle_nonlatlon_dimcvars(vector<HE5Var> & eos5varlist,EOS5Type,string groupname, map<string,string>& dnamesgeo1dvnames) throw(Exception);
            template <class T> void EOS5SwathGrid_Set_LatLon_Flags(T* eos5gridswath, vector<HE5Var>& eos5varlist) throw(Exception);

            void Obtain_Var_NewName(Var*) throw(Exception);
            EOS5Type Get_Var_EOS5_Type(Var*) throw(Exception); 

            bool Obtain_Var_Dims(Var*,HE5Parser*) throw(Exception);
            template <class T> bool Set_Var_Dims(T*, Var*,vector<HE5Var>&, const string&, int,EOS5Type) throw(Exception);
            template<class T> void Create_Unique_DimName(T*,set<string>&,  Dimension *,int , EOS5Type ) throw(Exception);

            template <class T> bool Check_All_DimNames(T*,string &, hsize_t);
            string Obtain_Var_EOS5Type_GroupName(Var*,EOS5Type ) throw(Exception);
            int Check_EOS5Swath_FieldType(Var*) throw(Exception);      
            void Get_Unique_Name(set<string>&, string& ) throw(Exception);
        
            template<class T> string Create_Unique_FakeDimName(T*, EOS5Type) throw(Exception);
            template<class T> void Set_NonParse_Var_Dims(T*, Var*,  map<hsize_t,string>& ,int,EOS5Type )throw(Exception);

            void Handle_Grid_CVar(bool) throw(Exception);
            void Handle_Augmented_Grid_CVar() throw(Exception);
            template <class T> void Handle_Single_Augment_CVar(T*,EOS5Type) throw(Exception);
        
            void Handle_Multi_Nonaugment_Grid_CVar() throw(Exception);
            void Handle_Single_Nonaugment_Grid_CVar(EOS5CFGrid*) throw(Exception);
            bool Handle_Single_Nonaugment_Grid_CVar_OwnLatLon(EOS5CFGrid *, set<string>& ) throw(Exception);
            bool Handle_Single_Nonaugment_Grid_CVar_EOS5LatLon(EOS5CFGrid *, set<string>& ) throw(Exception);
            void Handle_NonLatLon_Grid_CVar(EOS5CFGrid *, set<string>& ) throw(Exception);
            void Remove_MultiDim_LatLon_EOS5CFGrid() throw(Exception);
            void Adjust_EOS5GridDimNames(EOS5CFGrid *) throw(Exception);
 
            void Handle_Swath_CVar(bool) throw(Exception);
            void Handle_Single_1DLatLon_Swath_CVar(EOS5CFSwath *cfswath, bool is_augmented) throw(Exception);
            void Handle_Single_2DLatLon_Swath_CVar(EOS5CFSwath *cfswath, bool is_augmented) throw(Exception);
            void Handle_NonLatLon_Swath_CVar(EOS5CFSwath *cfswath, set<string>& tempvardimnamelist) throw(Exception);
            void Handle_Special_NonLatLon_Swath_CVar(EOS5CFSwath *cfswath, set<string>&tempvardimnamelist) throw(Exception);

            void Handle_Za_CVar(bool) throw(Exception);
 
            bool Check_Augmentation_Status() throw(Exception);
            bool Check_Augmented_Var_Attrs(Var *var) throw(Exception);
            template<class T> bool Check_Augmented_Var_Candidate(T* , Var*, EOS5Type ) throw(Exception);

            template <class T>void Adjust_Per_Var_Dim_NewName_Before_Flattening(T*,bool,int,int,int) throw(Exception);
            void Adjust_SharedLatLon_Grid_Var_Dim_Name() throw(Exception);

            void Adjust_Attr_Name() throw(Exception);
            void Adjust_Attr_Value() throw(Exception);
            void Handle_EOS5CVar_Unit_Attr()throw(Exception);
            void Handle_EOS5CVar_Special_Attr() throw(Exception);

            string get_CF_string(string s);
            void   Replace_Var_Info(EOS5CVar *src, EOS5CVar *target);
            void   Replace_Var_Attrs(EOS5CVar *src, EOS5CVar *target);
            void Handle_EOS5CVar_NameClashing(set<string> &) throw(Exception);
            void Handle_EOS5CVar_AttrNameClashing() throw(Exception);
            template <typename T> void EOS5Handle_General_NameClashing(set <string>&objnameset, vector<T*>& objvec) throw(Exception);
            void Adjust_CF_attr() throw(Exception);
            template <typename T> void Create_Missing_CV(T*, EOS5CVar*,const string &, EOS5Type, int) throw(Exception);
            void Create_Added_Var_NewName_FullPath(EOS5Type, const string& , const string& , string &, string &)  throw(Exception);


        private:
             vector <EOS5CVar *>cvars;
             vector <EOS5CFGrid *>eos5cfgrids;
             vector <EOS5CFSwath *>eos5cfswaths;
             vector <EOS5CFZa *>eos5cfzas;
             map <string,string>eos5_to_cf_attr_map;
             bool iscoard;
             EOS5AuraName aura_name;
             bool grids_multi_latloncvs;
             bool isaura;
             int orig_num_grids;
             multimap<string,string>dimname_to_dupdimnamelist;
    };
}
#endif