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>
 
namespace libdap {
class BaseType;
class DDS;
class Array;
}
 
class BESDataHandlerInterface;
 
class FoDapCovJsonTransform: public BESObj {
private:
    libdap::DDS *_dds;
    std::string _returnAs;
    std::string _indent_increment;
    std::string atomicVals;
    std::string currDataType;
    std::string domainType;
    std::string coordRefType;
    bool xExists;
    bool yExists;
    bool zExists;
    bool tExists;
    bool isParam;
    bool isAxis;
    bool canConvertToCovJson;
 
    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;
    std::vector<Axis *> axes;
    std::string axis_t_units;
    unsigned int parameterCount;
    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;
 
    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);
    //bool obtain_bound_values_worker(libdap::DDS *dds, libdap::Array *d_a, const std::string & bound_name, std::string &bound_dim_name);
    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);
    // Current only support the double precision for time.
    //std::string cf_time_to_greg(double time);
    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;
    
    bool canConvert();
 
    void getAttributes(std::ostream *strm, libdap::AttrTable &attr_table, std::string name,
        bool *axisRetrieved, bool *parameterRetrieved);
 
    void getAttributes_simple_cf_geographic(std::ostream *strm, libdap::AttrTable &attr_table, std::string name,
        bool *axisRetrieved, bool *parameterRetrieved);
 
   
    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::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(libdap::BaseType *bt, std::string indent, bool sendData);
    
    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);
 
    FoDapCovJsonTransform(libdap::DDS *dds);
 
    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_ */