DC.h

Go to the documentation of this file.

#include <vector>
#include <algorithm>
#include <map>
#include <iostream>
#include <vapor/MyBase.h>
 
#ifndef _DC_H_
    #define _DC_H_
 
namespace VAPoR {
 
class VDF_API DC : public Wasp::MyBase {
public:
    //
    enum XType { INVALID = -1, FLOAT, DOUBLE, UINT8, INT8, INT32, INT64, TEXT };
 
    class Dimension {
    public:
        Dimension()
        {
            _name.clear();
            _lengths.clear();
        }
 
        Dimension(std::string name, std::vector<size_t> lengths)
        {
            _name = name;
            _lengths = lengths;
        };
 
        Dimension(std::string name, size_t length)
        {
            _name = name;
            _lengths.clear();
            _lengths.push_back(length);
        };
 
        virtual ~Dimension(){};
 
        //
        string GetName() const { return (_name); };
 
        size_t GetLength() const { return (_lengths.size() ? _lengths[0] : 0); };
 
        size_t GetLength(size_t index) const { return (index < _lengths.size() ? _lengths[index] : 0); };
 
        //
        bool IsTimeVarying() const { return (_lengths.size() > 1); }
 
        friend std::ostream &operator<<(std::ostream &o, const Dimension &dimension);
 
    private:
        string              _name;
        std::vector<size_t> _lengths;
    };
 
    class Mesh {
    public:
        //
        enum Type {
            STRUCTURED,         
            UNSTRUC_2D,         
            UNSTRUC_LAYERED,    
            UNSTRUC_3D          
        };
 
        //
        enum Location {
            NODE,     
            EDGE,     
            FACE,     
            VOLUME    
        };
 
        Mesh()
        {
            _name.clear();
            _dim_names.clear();
            _coord_vars.clear();
            _max_nodes_per_face = 0;
            _max_faces_per_node = 0;
            _node_dim_name.clear();
            _face_dim_name.clear();
            _layers_dim_name.clear();
            _face_node_var.clear();
            _node_face_var.clear();
            _face_edge_var.clear();
            _face_face_var.clear();
            _edge_dim_name.clear();
            _edge_node_var.clear();
            _edge_face_var.clear();
            _mtype = STRUCTURED;
        }
 
        Mesh(std::string name, std::vector<string> dim_names, std::vector<string> coord_vars);
 
        Mesh(std::string name, size_t max_nodes_per_face, size_t max_faces_per_node, std::string node_dim_name, std::string face_dim_name, std::vector<std::string> coord_vars,
             std::string face_node_var, std::string node_face_var);
 
        //
        Mesh(std::string name, size_t max_nodes_per_face, size_t max_faces_per_node, std::string node_dim_name, std::string face_dim_name, std::string layers_dim_name,
             std::vector<std::string> coord_vars, std::string face_node_var, std::string node_face_var);
 
        //
        Mesh(std::string name, int max_nodes_per_face, int max_faces_per_node, std::string node_dim_name, std::string face_dim_name, std::vector<string> coord_vars);
 
        Mesh::Type GetMeshType() const { return (_mtype); }
 
        //
        string GetName() const { return (_name); };
 
        //
        std::vector<string> GetDimNames() const { return (_dim_names); };
 
        //
        std::vector<string> GetCoordVars() const { return (_coord_vars); };
        void                SetCoordVars(std::vector<string> coord_vars) { _coord_vars = coord_vars; };
 
        //
        size_t GetGeometryDim() const { return (_coord_vars.size()); }
 
        size_t GetMaxNodesPerFace() const { return (_max_nodes_per_face); };
 
        size_t GetMaxFacesPerNode() const { return (_max_faces_per_node); };
 
        string GetNodeDimName() const { return (_node_dim_name); };
 
        string GetFaceDimName() const { return (_face_dim_name); };
 
        string GetLayersDimName() const { return (_layers_dim_name); };
 
        string GetFaceNodeVar() const { return (_face_node_var); }
        void   SetFaceNodeVar(std::string face_node_var)
        {
            if (_mtype == STRUCTURED) return;
            _face_node_var = face_node_var;
        }
 
        string GetNodeFaceVar() const { return (_node_face_var); }
        void   SetNodeFaceVar(std::string node_face_var)
        {
            if (_mtype == STRUCTURED) return;
            _node_face_var = node_face_var;
        }
 
        void SetEdgeDimName(std::string edge_dim_name)
        {
            if (_mtype == STRUCTURED) return;
            _edge_dim_name = edge_dim_name;
        }
 
        std::string GetEdgeDimName() const { return (_edge_dim_name); }
 
        void SetEdgeNodeVar(std::string edge_node_var)
        {
            if (_mtype == STRUCTURED) return;
            _edge_node_var = edge_node_var;
        }
 
        //
        std::string GetEdgeNodeVar() const { return (_edge_node_var); }
 
        //
        void SetFaceEdgeVar(std::string face_edge_var)
        {
            if (_mtype == STRUCTURED) return;
            _face_edge_var = face_edge_var;
        }
 
        //
        std::string GetFaceEdgeVar() const { return (_face_edge_var); }
 
        //
        void SetFaceFaceVar(std::string face_face_var)
        {
            if (_mtype == STRUCTURED) return;
            _face_face_var = face_face_var;
        }
 
        //
        std::string GetFaceFaceVar() const { return (_face_face_var); }
 
        //
        void SetEdgeFaceVar(std::string edge_face_var)
        {
            if (_mtype == STRUCTURED) return;
            _edge_face_var = edge_face_var;
        }
 
        //
        std::string GetEdgeFaceVar() const { return (_edge_face_var); }
 
        //
        size_t GetTopologyDim() const;
 
        //
        static string MakeMeshName(std::vector<string> s);
 
        friend std::ostream &operator<<(std::ostream &o, const Mesh &mesh);
 
    private:
        string              _name;
        std::vector<string> _dim_names;
        std::vector<string> _coord_vars;
        size_t              _max_nodes_per_face;
        size_t              _max_faces_per_node;
        string              _node_dim_name;
        string              _face_dim_name;
        string              _layers_dim_name;
        string              _face_node_var;
        string              _node_face_var;
        string              _face_edge_var;
        string              _face_face_var;
        string              _edge_dim_name;
        string              _edge_node_var;
        string              _edge_face_var;
        Mesh::Type          _mtype;
 
        void _Mesh(string name, std::vector<string> coord_vars, int max_nodes_per_face, int max_faces_per_node, Type type);
    };
 
    class Attribute {
    public:
        Attribute()
        {
            _name = "";
            _type = FLOAT;
            _values.clear();
        };
 
        //
        Attribute(string name, XType type, const std::vector<float> &values);
        Attribute(string name, XType type, const std::vector<double> &values);
        Attribute(string name, XType type, const std::vector<int> &values);
        Attribute(string name, XType type, const std::vector<long> &values);
        Attribute(string name, XType type, const string &values);
        Attribute(string name, XType type)
        {
            _name = name;
            _type = type;
            _values.clear();
        };
        virtual ~Attribute(){};
 
        //
        string GetName() const { return (_name); };
 
        //
        XType GetXType() const { return (_type); };
 
        VDF_API void GetValues(std::vector<float> &values) const;
        VDF_API void GetValues(std::vector<double> &values) const;
        VDF_API void GetValues(std::vector<int> &values) const;
        VDF_API void GetValues(std::vector<long> &values) const;
        VDF_API void GetValues(string &values) const;
 
        void SetValues(const std::vector<float> &values);
        void SetValues(const std::vector<double> &values);
        void SetValues(const std::vector<int> &values);
        void SetValues(const std::vector<long> &values);
        void SetValues(const string &values);
 
        friend std::ostream &operator<<(std::ostream &o, const Attribute &attr);
 
    private:
        string _name;
        XType  _type;
        union podunion {
            float  f;
            double d;
            int    i;
            long   l;
            char   c;
        };
        std::vector<podunion> _values;
    };
 
    //
    class BaseVar {
    public:
        BaseVar()
        {
            _name.clear();
            _units.clear();
            _type = FLOAT;
            _wname.clear();
            _cratios.clear();
            _periodic.clear();
            _atts.clear();
        }
 
        BaseVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic)
        : _name(name), _units(units), _type(type), _wname(wname), _cratios(cratios), _periodic(periodic)
        {
            if (_cratios.size() == 0) _cratios.push_back(1);
        };
 
        BaseVar(string name, string units, XType type, std::vector<bool> periodic);
 
        virtual ~BaseVar(){};
 
        //
        string GetName() const { return (_name); };
        void   SetName(string name) { _name = name; };
 
        //
        string GetUnits() const { return (_units); };
        void   SetUnits(string units) { _units = units; };
 
        //
        XType GetXType() const { return (_type); };
        void  SetXType(XType type) { _type = type; };
 
        //
        string GetWName() const { return (_wname); };
        void   SetWName(string wname) { _wname = wname; };
 
        //
        std::vector<size_t> GetCRatios() const { return (_cratios); };
 
        void SetCRatios(std::vector<size_t> cratios)
        {
            _cratios = cratios;
            if (_cratios.size() == 0) _cratios.push_back(1);
        };
 
        //
        std::vector<bool> GetPeriodic() const { return (_periodic); };
        void              SetPeriodic(std::vector<bool> periodic) { _periodic = periodic; };
 
        //
        const std::map<string, Attribute> &GetAttributes() const { return (_atts); };
        void                               SetAttributes(std::map<string, Attribute> &atts) { _atts = atts; };
 
        bool GetAttribute(string name, Attribute &att) const
        {
            std::map<string, Attribute>::const_iterator itr = _atts.find(name);
            if (itr == _atts.end()) return (false);
            att = itr->second;
            return (true);
        }
 
        void SetAttribute(const Attribute &att) { _atts[att.GetName()] = att; }
 
        //
        bool IsCompressed() const { return (!_wname.empty()); };
 
        friend std::ostream &operator<<(std::ostream &o, const BaseVar &var);
 
    private:
        string                      _name;
        string                      _units;
        XType                       _type;
        string                      _wname;
        std::vector<size_t>         _cratios;
        std::vector<bool>           _periodic;
        std::map<string, Attribute> _atts;
    };
 
    //
    class CoordVar : public BaseVar {
    public:
        CoordVar()
        {
            _dim_names.clear();
            _time_dim_name.clear();
            _axis = 0;
            _uniform = true;
        }
 
        //
        CoordVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic, std::vector<string> dim_names, string time_dim_name, int axis,
                 bool uniform)
        : BaseVar(name, units, type, wname, cratios, periodic), _dim_names(dim_names), _time_dim_name(time_dim_name), _axis(axis), _uniform(uniform)
        {
        }
 
        //
        CoordVar(string name, string units, XType type, std::vector<bool> periodic, int axis, bool uniform, std::vector<string> dim_names, string time_dim_name)
        : BaseVar(name, units, type, periodic), _dim_names(dim_names), _time_dim_name(time_dim_name), _axis(axis), _uniform(uniform)
        {
        }
 
        virtual ~CoordVar(){};
 
        //
        std::vector<string> GetDimNames() const { return (_dim_names); };
        void                SetDimNames(std::vector<string> dim_names) { _dim_names = dim_names; };
 
        //
        string GetTimeDimName() const { return (_time_dim_name); };
        void   SetTimeDimName(string time_dim_name) { _time_dim_name = time_dim_name; };
 
        //
        int  GetAxis() const { return (_axis); };
        void SetAxis(int axis) { _axis = axis; };
 
        //
        bool GetUniform() const { return (_uniform); };
        void SetUniform(bool uniform) { _uniform = uniform; };
 
        friend std::ostream &operator<<(std::ostream &o, const CoordVar &var);
 
    private:
        std::vector<string> _dim_names;
        string              _time_dim_name;
        int                 _axis;
        bool                _uniform;
    };
 
    class DataVar : public BaseVar {
    public:
        DataVar()
        {
            _mesh.clear();
            _time_coord_var.clear();
            _location = Mesh::NODE;
            _maskvar.clear();
            _has_missing = false;
            _missing_value = 0.0;
        }
 
        DataVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location,
                double missing_value)
        : BaseVar(name, units, type, wname, cratios, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(""), _has_missing(true), _missing_value(missing_value)
        {
        }
 
        DataVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location,
                double missing_value, string maskvar)
        : BaseVar(name, units, type, wname, cratios, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(maskvar), _has_missing(true), _missing_value(missing_value)
        {
        }
 
        DataVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location)
        : BaseVar(name, units, type, wname, cratios, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(""), _has_missing(false), _missing_value(0.0)
        {
        }
 
        DataVar(string name, string units, XType type, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location, double missing_value)
        : BaseVar(name, units, type, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(""), _has_missing(true), _missing_value(missing_value)
        {
        }
 
        DataVar(string name, string units, XType type, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location, double missing_value, string maskvar)
        : BaseVar(name, units, type, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(maskvar), _has_missing(true), _missing_value(missing_value)
        {
        }
 
        DataVar(string name, string units, XType type, std::vector<bool> periodic, string mesh, string time_coord_var, Mesh::Location location)
        : BaseVar(name, units, type, periodic), _mesh(mesh), _time_coord_var(time_coord_var), _location(location), _maskvar(""), _has_missing(false), _missing_value(0.0)
        {
        }
 
        virtual ~DataVar(){};
 
        //
        string GetMeshName() const { return (_mesh); };
        void   SetMeshName(string mesh) { _mesh = mesh; };
 
        //
        string GetTimeCoordVar() const { return (_time_coord_var); }
        void   SetTimeCoordVar(string time_coord_var) { _time_coord_var = time_coord_var; }
 
        //
        Mesh::Location GetSamplingLocation() const { return (_location); }
 
        //
        string GetMaskvar() const { return (_maskvar); };
        void   SetMaskvar(string maskvar) { _maskvar = maskvar; };
 
        //
        bool GetHasMissing() const { return (_has_missing); };
        void SetHasMissing(bool has_missing) { _has_missing = has_missing; };
 
        //
        double GetMissingValue() const { return (_missing_value); };
        void   SetMissingValue(double missing_value) { _missing_value = missing_value; };
 
        VDF_API friend std::ostream &operator<<(std::ostream &o, const DataVar &var);
 
    private:
        string         _mesh;
        string         _time_coord_var;
        Mesh::Location _location;
        string         _maskvar;
        bool           _has_missing;
        double         _missing_value;
    };
 
    class AuxVar : public BaseVar {
    public:
        AuxVar()
        {
            _dim_names.clear();
            _offset = 0;
        }
 
        AuxVar(string name, string units, XType type, string wname, std::vector<size_t> cratios, std::vector<bool> periodic, std::vector<string> dim_names)
        : BaseVar(name, units, type, wname, cratios, periodic), _dim_names(dim_names), _offset(0)
        {
        }
 
        virtual ~AuxVar(){};
 
        //
        std::vector<string> GetDimNames() const { return (_dim_names); };
        void                SetDimNames(std::vector<string> dim_names) { _dim_names = dim_names; };
 
        //
        long GetOffset() const { return (_offset); };
        void SetOffset(long offset) { _offset = offset; };
 
        VDF_API friend std::ostream &operator<<(std::ostream &o, const AuxVar &var);
 
    private:
        std::vector<string> _dim_names;
        long                _offset;
    };
 
    DC();
 
    virtual ~DC(){};
 
    //
    virtual int Initialize(const std::vector<string> &paths, const std::vector<string> &options = std::vector<string>()) { return (initialize(paths, options)); }
 
    virtual bool GetDimension(string dimname, DC::Dimension &dimension, long ts) const { return (getDimension(dimname, dimension, ts)); }
 
    virtual std::vector<string> GetDimensionNames() const { return (getDimensionNames()); }
 
    virtual std::vector<string> GetMeshNames() const { return (getMeshNames()); }
 
    virtual bool GetMesh(string mesh_name, DC::Mesh &mesh) const { return (getMesh(mesh_name, mesh)); }
 
    //
    virtual bool GetMeshDimLens(const string &mesh_name, std::vector<size_t> &dims, long ts = -1) const;
 
    //
    virtual bool GetMeshDimNames(const string &mesh_name, std::vector<string> &dimnames) const;
 
    virtual bool GetCoordVarInfo(string varname, DC::CoordVar &cvar) const { return (getCoordVarInfo(varname, cvar)); }
 
    virtual bool GetDataVarInfo(string varname, DC::DataVar &datavar) const { return (getDataVarInfo(varname, datavar)); }
 
    //
    virtual bool GetAuxVarInfo(string varname, DC::AuxVar &var) const { return (getAuxVarInfo(varname, var)); }
 
    //
    virtual bool GetBaseVarInfo(string varname, DC::BaseVar &var) const { return (getBaseVarInfo(varname, var)); }
 
    //
    virtual std::vector<string> GetDataVarNames() const { return (getDataVarNames()); }
 
    //
    virtual std::vector<string> GetCoordVarNames() const { return (getCoordVarNames()); }
 
    //
    virtual std::vector<string> GetAuxVarNames() const { return (getAuxVarNames()); }
 
    //
    virtual size_t GetNumRefLevels(string varname) const { return (getNumRefLevels(varname)); }
 
    //
    virtual bool GetAtt(string varname, string attname, vector<double> &values) const { return (getAtt(varname, attname, values)); }
 
    virtual bool GetAtt(string varname, string attname, vector<long> &values) const { return (getAtt(varname, attname, values)); }
 
    virtual bool GetAtt(string varname, string attname, string &values) const { return (getAtt(varname, attname, values)); }
 
    //
    virtual std::vector<string> GetAttNames(string varname) const { return (getAttNames(varname)); }
 
    virtual XType GetAttType(string varname, string attname) const { return (getAttType(varname, attname)); }
 
    //
    virtual int GetDimLensAtLevel(string varname, int level, std::vector<size_t> &dims_at_level, std::vector<size_t> &bs_at_level, long ts = -1) const
    {
        return (getDimLensAtLevel(varname, level, dims_at_level, bs_at_level, ts));
    }
 
    virtual int GetDimLens(string varname, std::vector<size_t> &dims, long ts = -1)
    {
        vector<size_t> dummy;
        return (GetDimLensAtLevel(varname, -1, dims, dummy, ts));
    }
 
    //
    virtual string GetMapProjection() const { return (getMapProjection()); }
 
    //
    virtual int OpenVariableRead(size_t ts, string varname, int level = 0, int lod = 0) { return (_openVariableRead(ts, varname, level, lod)); }
 
    //
    virtual int CloseVariable(int fd) { return (_closeVariable(fd)); }
 
    //
    int virtual Read(int fd, float *data) { return (_readTemplate(fd, data)); }
    int virtual Read(int fd, double *data) { return (_readTemplate(fd, data)); }
    int virtual Read(int fd, int *data) { return (_readTemplate(fd, data)); }
 
    virtual int ReadSlice(int fd, float *slice) { return (_readSliceTemplate(fd, slice)); }
    virtual int ReadSlice(int fd, double *slice) { return (_readSliceTemplate(fd, slice)); }
    virtual int ReadSlice(int fd, int *slice) { return (_readSliceTemplate(fd, slice)); }
 
    //
    virtual int ReadRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, float *region) { return (readRegion(fd, min, max, region)); }
    virtual int ReadRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, double *region) { return (readRegion(fd, min, max, region)); }
    virtual int ReadRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, int *region) { return (readRegion(fd, min, max, region)); }
 
 
    //
    virtual int GetVar(string varname, int level, int lod, float *data) { return (_getVarTemplate(varname, level, lod, data)); }
    virtual int GetVar(string varname, int level, int lod, double *data) { return (_getVarTemplate(varname, level, lod, data)); }
    virtual int GetVar(string varname, int level, int lod, int *data) { return (_getVarTemplate(varname, level, lod, data)); }
 
    //
    virtual int GetVar(size_t ts, string varname, int level, int lod, float *data) { return (_getVarTemplate(ts, varname, level, lod, data)); }
    virtual int GetVar(size_t ts, string varname, int level, int lod, double *data) { return (_getVarTemplate(ts, varname, level, lod, data)); }
    virtual int GetVar(size_t ts, string varname, int level, int lod, int *data) { return (_getVarTemplate(ts, varname, level, lod, data)); }
 
    //
    virtual bool VariableExists(size_t ts, string varname, int reflevel = 0, int lod = 0) const { return (variableExists(ts, varname, reflevel, lod)); };
 
    virtual int GetHyperSliceInfo(string varname, int level, std::vector<size_t> &dims, size_t &nslice, long ts = -1);
 
    //
    virtual std::vector<string> GetDataVarNames(int ndim) const;
 
    //
    //
    virtual bool GetVarDimensions(string varname, bool spatial, vector<DC::Dimension> &dimensions, long ts) const;
 
    //
    //
    virtual bool GetVarDimLens(string varname, bool spatial, vector<size_t> &dimlens, long ts = -1) const;
 
    //
    virtual bool GetVarDimLens(string varname, vector<size_t> &sdimlens, size_t &time_dimlen, long ts = -1) const;
 
    //
    virtual bool GetVarDimNames(string varname, bool spatial, vector<string> &dimnames) const;
 
    //
    virtual bool GetVarDimNames(string varname, vector<string> &sdimnames, string &time_dimname) const;
 
    //
    virtual size_t GetVarTopologyDim(string varname) const;
 
    //
    virtual size_t GetVarGeometryDim(string varname) const;
 
    virtual bool IsTimeVarying(string varname) const;
 
    //
    virtual bool IsCompressed(string varname) const;
 
    //
    virtual int GetNumTimeSteps(string varname) const;
 
    //
    virtual std::vector<size_t> GetCRatios(string varname) const;
 
    virtual bool IsDataVar(string varname) const
    {
        vector<string> names = GetDataVarNames();
        return (find(names.begin(), names.end(), varname) != names.end());
    }
 
    virtual bool IsCoordVar(string varname) const
    {
        vector<string> names = GetCoordVarNames();
        return (find(names.begin(), names.end(), varname) != names.end());
    }
 
    virtual bool IsAuxVar(string varname) const
    {
        vector<string> names = GetAuxVarNames();
        return (find(names.begin(), names.end(), varname) != names.end());
    }
 
    //
    virtual bool GetVarCoordVars(string varname, bool spatial, std::vector<string> &coord_vars) const;
 
    bool GetVarConnVars(string varname, string &face_node_var, string &node_face_var, string &face_edge_var, string &face_face_var, string &edge_node_var, string &edge_face_var) const;
 
    virtual size_t GetNumDimensions(string varname) const;
 
    std::vector<string> GetTimeCoordVarNames() const;
 
    class VDF_API FileTable {
    public:
        FileTable();
        virtual ~FileTable();
 
        class FileObject {
        public:
            FileObject() : _ts(0), _varname(""), _level(0), _lod(0), _slice(0), _aux(0) {}
 
            FileObject(size_t ts, string varname, int level = 0, int lod = 0, int aux = 0) : _ts(ts), _varname(varname), _level(level), _lod(lod), _slice(0), _aux(aux) {}
 
            size_t GetTS() const { return (_ts); }
            string GetVarname() const { return (_varname); }
            int    GetLevel() const { return (_level); }
            int    GetLOD() const { return (_lod); }
            int    GetSlice() const { return (_slice); }
            void   SetSlice(int slice) { _slice = slice; }
            int    GetAux() const { return (_aux); }
 
        private:
            size_t _ts;
            string _varname;
            int    _level;
            int    _lod;
            int    _slice;
            int    _aux;
        };
 
        int         AddEntry(FileObject *obj);
        FileObject *GetEntry(int fd) const;
        void        RemoveEntry(int fd);
        vector<int> GetEntries() const;
 
    private:
        std::vector<FileTable::FileObject *> _table;
    };
 
protected:
    DC::FileTable _fileTable;
 
    //
    virtual int initialize(const std::vector<string> &paths, const std::vector<string> &options = std::vector<string>()) = 0;
 
    //
    virtual bool getDimension(string dimname, DC::Dimension &dimension) const = 0;
 
    //
    virtual bool getDimension(string dimname, DC::Dimension &dimension, long ts) const { return getDimension(dimname, dimension); };
 
    //
    virtual std::vector<string> getDimensionNames() const = 0;
 
    //
    virtual std::vector<string> getMeshNames() const = 0;
 
    //
    virtual bool getMesh(string mesh_name, DC::Mesh &mesh) const = 0;
 
    //
    virtual bool getCoordVarInfo(string varname, DC::CoordVar &cvar) const = 0;
 
    //
    virtual bool getDataVarInfo(string varname, DC::DataVar &datavar) const = 0;
 
    //
    virtual bool getAuxVarInfo(string varname, DC::AuxVar &var) const = 0;
 
    //
    virtual bool getBaseVarInfo(string varname, DC::BaseVar &var) const = 0;
 
    //
    virtual std::vector<string> getDataVarNames() const = 0;
 
    //
    virtual std::vector<string> getCoordVarNames() const = 0;
 
    //
    virtual std::vector<string> getAuxVarNames() const = 0;
 
    //
    virtual size_t getNumRefLevels(string varname) const = 0;
 
    //
    virtual bool getAtt(string varname, string attname, vector<double> &values) const = 0;
 
    //
    virtual bool getAtt(string varname, string attname, vector<long> &values) const = 0;
 
    //
    virtual bool getAtt(string varname, string attname, string &values) const = 0;
 
    //
    virtual std::vector<string> getAttNames(string varname) const = 0;
 
    //
    virtual XType getAttType(string varname, string attname) const = 0;
 
    //
    virtual vector<size_t> getBlockSize() const { return (vector<size_t>()); }
 
    //
    virtual int getDimLensAtLevel(string varname, int level, std::vector<size_t> &dims_at_level, std::vector<size_t> &bs_at_level) const = 0;
 
    //
    virtual int getDimLensAtLevel(string varname, int level, std::vector<size_t> &dims_at_level, std::vector<size_t> &bs_at_level, long ts) const
    {
        return getDimLensAtLevel(varname, level, dims_at_level, bs_at_level);
    };
 
    //
    virtual string getMapProjection() const = 0;
 
    //
    virtual int openVariableRead(size_t ts, string varname, int level = 0, int lod = 0) = 0;
 
    //
    virtual int closeVariable(int fd) = 0;
 
    //
    virtual int readRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, float *region) = 0;
 
    virtual int readRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, double *region) = 0;
 
    virtual int readRegion(int fd, const vector<size_t> &min, const vector<size_t> &max, int *region) = 0;
 
    //
    virtual bool variableExists(size_t ts, string varname, int reflevel = 0, int lod = 0) const = 0;
 
private:
    virtual bool _getCoordVarDimensions(string varname, bool spatial, vector<DC::Dimension> &dimensions, long ts) const;
 
    virtual bool _getDataVarDimensions(string varname, bool spatial, vector<DC::Dimension> &dimensions, long ts) const;
 
    virtual bool _getAuxVarDimensions(string varname, vector<DC::Dimension> &dimensions, long ts) const;
 
    vector<size_t> _getBlockSize() const;
 
    virtual int _openVariableRead(size_t ts, string varname, int level = 0, int lod = 0);
 
    virtual int _closeVariable(int fd);
 
    template<class T> int _readSliceTemplate(int fd, T *slice);
 
    template<class T> int _readTemplate(int fd, T *data);
 
    template<class T> int _getVarTemplate(string varname, int level, int lod, T *data);
 
    template<class T> int _getVarTemplate(size_t ts, string varname, int level, int lod, T *data);
};
};    // namespace VAPoR
 
#endif