FoDapCovJsonTransform.h

// -*- mode: c++; c-basic-offset:4 -*-
//
// FoDapCovJsonTransform.h
//
// This file is part of BES CovJSON File Out Module
//
// Copyright (c) 2018 OPeNDAP, Inc.
// Author: Corey Hemphill <hemphilc@oregonstate.edu>
// Author: River Hendriksen <hendriri@oregonstate.edu>
// Author: Riley Rimer <rrimer@oregonstate.edu>
//
// Adapted from the File Out JSON module implemented by Nathan Potter
//
// This library 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 library 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
//
 
#ifndef FODAPNJSONTRANSFORM_H_
#define FODAPNJSONTRANSFORM_H_
 
#include <string>
#include <vector>
#include <map>
 
#include <BESObj.h>
 
enum DSGType {
    UNSUPPORTED_DSG,SPOINT,POINTS,PROFILE
};
namespace libdap {
class BaseType;
class DDS;
class DMR;
class D4Group;
class Array;
}
 
class BESDataHandlerInterface;

class FoDapCovJsonTransform: public BESObj {
private:
    libdap::DDS *_dds;
    libdap::DMR *_dmr;
    std::string _returnAs;
    std::string _indent_increment = "  ";
    std::string atomicVals;
    std::string currDataType;
    std::string domainType = "Unknown";
    std::string coordRefType = "GeographicCRS";
    bool xExists = false;
    bool yExists = false;
    bool zExists = false;
    bool tExists = false;
    bool isParam = false;
    bool isAxis = false;
    bool canConvertToCovJson = false;
 
    struct Axis {
        std::string name;
        std::string values;
    };
 
    struct Parameter {
        std::string id;
        std::string name;
        std::string type;
        std::string dataType;
        std::string unit;
        std::string longName;
        std::string standardName;
        std::string shape;
        std::string values;
    };
 
    unsigned int axisCount = 0;
    std::vector<Axis *> axes;
    std::string axis_t_units;
    std::string axis_z_units;
    std::string axis_z_direction;
    std::string axis_z_standardName;
    
    unsigned int parameterCount = 0;
    std::vector<Parameter *> parameters;
    std::vector<int> shapeVals;
 
#if 0
    std::string axis_x_varname;
    std::string axis_y_varname;
    std::string axis_z_varname;
    std::string axis_t_varname;
#endif
 
    struct axisVar {
        int dim_size;
        std::string name;
        std::string dim_name;
        std::string bound_name;
    };
    axisVar axisVar_x;
    axisVar axisVar_y;
    axisVar axisVar_z;
    axisVar axisVar_t;
 
    std::vector<float> axisVar_x_bnd_val;
    std::vector<float> axisVar_y_bnd_val;
    std::vector<float> axisVar_z_bnd_val;
    std::vector<double> axisVar_t_bnd_val;
 
    std::vector<std::string>bnd_dim_names;
    std::vector<std::string>par_vars;
 
    bool is_simple_cf_geographic = false;
    bool is_dap2_grid = false;
    bool is_geo_dap2_grid = false;
 
    // Discrete Sampling Geometries 
    DSGType dsg_type = UNSUPPORTED_DSG;
    
    // TODO: add more error messages.
#if 0
    std::string err_msg;
    bool err_msg_set = false;
#endif
 
    bool is_cf_grid_mapping_var(libdap::BaseType *v) const;
 
    bool is_supported_vars_by_type(libdap::BaseType*v) const;
    void handle_axisVars_array(libdap::BaseType*v,axisVar & this_axisVar) ;
    void set_axisVar(libdap::BaseType*v,const string &val);
    bool is_simple_dsg(DSGType dsg);
    bool is_simple_dsg_common() const;
    DSGType is_single_point () const;
    DSGType is_point_series () const;
    DSGType is_single_profile () const;
    bool is_valid_single_point_par_var(libdap::BaseType*) const;
    bool is_fake_coor_vars(libdap::Array*) const;
    bool is_valid_array_dsg_par_var(libdap::Array*) const;
    bool is_valid_dsg_par_var(libdap::BaseType *);
    bool obtain_valid_dsg_par_vars(libdap::DDS *);
    bool check_update_simple_dsg(libdap::DDS *);
 
    void check_update_simple_geo(libdap::DDS *dds,bool sendData);
    void check_update_simple_geo_dap4(libdap::D4Group *d4g);
    bool check_add_axis(libdap::Array *d_a, const std::string &, const std::vector<std::string> &, axisVar &, bool is_t_axis);
    void check_bounds(libdap::DDS *dds, std::map<std::string,std::string>& vname_b_name);
    void obtain_bound_values(libdap::DDS *dds, const axisVar& av, std::vector<float>& av_bnd_val,std::string &bnd_dim_name,bool);
    void obtain_bound_values(libdap::DDS *dds, const axisVar& av, std::vector<double>& av_bnd_val,std::string &bnd_dim_name,bool);
    libdap::Array *  obtain_bound_values_worker(libdap::DDS *dds, const std::string & bound_name, std::string &bound_dim_name);
 
 
    bool obtain_valid_vars(libdap::DDS *dds, short axis_var_z_count, short axis_var_t_count);
    bool obtain_valid_vars_dap4(libdap::D4Group *d4g, short axis_var_z_count, short axis_var_t_count);
 
    // Convert CF time to gregorian calendar.
    std::string cf_time_to_greg(long long time);
    void print_bound(std::ostream *strm, const std::vector<std::string> & t_bnd_val,const std::string & indent,bool is_t_axis) const;
    
    // Check DAP2 CF units
    bool check_geo_dap2_grid(libdap::DDS *dds, const vector<string> & dap2_grid_map_names) const;
    short check_cf_unit_attr(libdap::Array *d_a) const;
    // Note we add more accurate checks to see  whether covjson can be supported prior to this function.
    // Currently this function serves as a wrapper of these checks.
    bool canConvert();

    void getAttributes(std::ostream *strm, libdap::AttrTable &attr_table, std::string name,
        bool *axisRetrieved, bool *parameterRetrieved);
 
    // Different types need to be handled differently. Eventually the getAttributes() listed above becomes
    // the wrapper of the functions declared below.
    void getAttributes_simple_cf_geographic_dsg(std::ostream *strm, libdap::AttrTable &attr_table, const std::string& name,
        bool *axisRetrieved, bool *parameterRetrieved);
 
    
   
    // TODO: this function is not necessary. May be removed.
    string sanitizeTimeOriginString(std::string timeOrigin);

    void transform(std::ostream *strm, libdap::DDS *dds, std::string indent, bool sendData, bool testOverride);
 
    void transform(std::ostream *strm, libdap::DMR *dmr, const std::string& indent, bool sendData, bool testOverride);
    
    void transform(std::ostream *strm, libdap::BaseType *bt, std::string indent, bool sendData);
    
    void transform(std::ostream *strm, libdap::Constructor *cnstrctr, std::string indent, bool sendData);
    
    void transform(std::ostream *strm, libdap::Array *a, std::string indent, bool sendData);

    void transformAtomic(ostream *strm, libdap::BaseType *bt, const std::string& indent, bool sendData);
#if 0
    //void transformAtomic(libdap::BaseType *bt, std::string indent, bool sendData);
#endif
    
    void transformNodeWorker(std::ostream *strm, vector<libdap::BaseType *> leaves, vector<libdap::BaseType *> nodes,
        string indent, bool sendData);

    void printCoverage(std::ostream *strm, std::string indent);

    void printDomain(std::ostream *strm, std::string indent);
    
    void printAxes(std::ostream *strm, std::string indent);

    void printReference(std::ostream *strm, std::string indent);
    
    void printParameters(std::ostream *strm, std::string indent);
    
    void printRanges(std::ostream *strm, std::string indent);

    void printCoverageJSON(std::ostream *strm, string indent, bool testOverride);

    template<typename T>
    void covjsonSimpleTypeArray(std::ostream *strm, libdap::Array *a, std::string indent, bool sendData);
    
    void covjsonStringArray(std::ostream *strm, libdap::Array *a, std::string indent, bool sendData);

    template<typename T>
    unsigned int covjsonSimpleTypeArrayWorker(std::ostream *strm, T *values, unsigned int indx,
        std::vector<unsigned int> *shape, unsigned int currentDim, bool is_axis_t_sgeo,libdap::Type a_type);

    void addAxis(std::string name, std::string values);

    void addParameter(std::string id, std::string name, std::string type, std::string dataType, std::string unit,
        std::string longName, std::string standardName, std::string shape, std::string values);
 
    // FOR TESTING PURPOSES ------------------------------------------------------------------------------------
    void setAxesExistence(bool x, bool y, bool z, bool t) {
        this->xExists = x;
        this->yExists = y;
        this->zExists = z;
        this->tExists = t;
    }
 
    void setDomainType(int domainType) {
        this->domainType = domainType;
    }
    // ---------------------------------------------------------------------------------------------------------
 
public:
    virtual void transform(std::ostream &ostrm, bool sendData, bool testOverride);
    virtual void transform_dap4(std::ostream &ostrm, bool sendData, bool testOverride);

    explicit FoDapCovJsonTransform(libdap::DDS *dds);
    explicit FoDapCovJsonTransform(libdap::DMR *dmr);

    virtual ~FoDapCovJsonTransform()
    {
        for (std::vector<Axis *>::const_iterator i = axes.begin(); i != axes.end(); ++i)
            delete (*i);
 
        for (std::vector<Parameter *>::const_iterator i = parameters.begin(); i != parameters.end(); ++i)
            delete (*i);
    }

    virtual void dump(std::ostream &strm) const;
 
    // FOR TESTING PURPOSES ------------------------------------------------------------------------------------
    virtual void addTestAxis(std::string name, std::string values) {
        addAxis(name, values);
    }
 
    virtual void addTestParameter(std::string id, std::string name, std::string type, std::string dataType, std::string unit,
            std::string longName, std::string standardName, std::string shape, std::string values) {
        addParameter(id, name, type, dataType, unit, longName, standardName, shape, values);
    }
 
    virtual void setTestAxesExistence(bool x, bool y, bool z, bool t) {
        setAxesExistence(x, y, z, t);
    }
 
    virtual void setTestDomainType(int domainType) {
        setDomainType(domainType);
    }
 
    virtual void printCoverage(std::ostream &ostrm, std::string indent) {
        printCoverage(&ostrm, indent);
    }
 
    virtual void printDomain(std::ostream &ostrm, std::string indent) {
        printDomain(&ostrm, indent);
    }
 
    virtual void printAxes(std::ostream &ostrm, std::string indent) {
        printAxes(&ostrm, indent);
    }
 
    virtual void printReference(std::ostream &ostrm, std::string indent) {
        printReference(&ostrm, indent);
    }
 
    virtual void printParameters(std::ostream &ostrm, std::string indent) {
        printParameters(&ostrm, indent);
    }
 
    virtual void printRanges(std::ostream &ostrm, std::string indent) {
        printRanges(&ostrm, indent);
    }
    // ---------------------------------------------------------------------------------------------------------
};
 
#endif /* FODAPCOVJSONTRANSFORM_H_ */