TabularFunction.cc

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of bes, A C++ implementation of the OPeNDAP
// Hyrax data server
 
// Copyright (c) 2015 OPeNDAP, Inc.
// Authors: James Gallagher <jgallagher@opendap.org>
//
// 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
//
// You can contact OPeNDAP, Inc. at PO Box 112, Saunderstown, RI. 02874-0112.
 
#include "config.h"
 
#include <cassert>
#include <climits>
 
#include <sstream>
#include <memory>
#include <algorithm>
 
#include <libdap/BaseType.h>
#include <libdap/UInt32.h>
#include <libdap/Array.h>
#include <libdap/Sequence.h>
#include <libdap/D4Sequence.h>
#include <libdap/D4RValue.h>
#include <libdap/Error.h>
#include <libdap/debug.h>
#include <libdap/util.h>
#include <libdap/ServerFunctionsList.h>
 
#include "TabularSequence.h"
#include "TabularFunction.h"
 
using namespace std;
using namespace libdap;
 
namespace functions {

static void read_array_values(Array *a)
{
    a->read();
    a->set_read_p(true);
}

TabularFunction::Shape TabularFunction::array_shape(Array *a)
{
    Shape shape;
 
    for (Array::Dim_iter i = a->dim_begin(), e = a->dim_end(); i != e; ++i) {
        shape.push_back(a->dimension_size(i));
    }
 
    return shape;
}

bool TabularFunction::shape_matches(Array *a, const Shape &shape)
{
    // Same number of dims
    if (shape.size() != a->dimensions()) return false;
 
    // Each dim the same size
    Array::Dim_iter i = a->dim_begin(), e = a->dim_end();
    Shape::const_iterator si = shape.begin(), se = shape.end();
    while (i != e && si != se) {
        assert(a->dimension_size(i) >= 0);
        if (*si != (unsigned long) a->dimension_size(i)) return false;
        ++i;
        ++si;
    }
 
    return true;
}

bool TabularFunction::dep_indep_match(const Shape &dep_shape, const Shape &indep_shape)
{
    // Each of the indep vars dims must match the corresponding dep var dims
    // Start the comparison with the right-most dims (rbegin())
    Shape::const_reverse_iterator di = dep_shape.rbegin();
    for (Shape::const_reverse_iterator i = indep_shape.rbegin(), e = indep_shape.rend(); i != e; ++i) {
        if (di == dep_shape.rend()) return false;   // this was an assert; should be a test. jhrg 11/17/15
        if (*i != *di++) return false;
    }
 
    return true;
}

unsigned long TabularFunction::number_of_values(const Shape &shape)
{
    unsigned long size = 1;
    Shape::const_iterator si = shape.begin(), se = shape.end();
    while (si != se) {
        size *= *si++;
    }
    return size;
}

void TabularFunction::build_columns(unsigned long n, BaseType* btp, vector<Array*>& the_arrays,
        Shape &shape)
{
    if (btp->type() != dods_array_c)
        throw Error("In tabular(): Expected argument '" + btp->name() + "' to be an Array.");
 
    // We know it's an Array; cast, test, save and read the values
    Array *a = static_cast<Array*>(btp);
    // For the first array, record the number of dims and their sizes
    // for all subsequent arrays, test for a match
    if (n == 0)
        shape = array_shape(a);
    else if (!shape_matches(a, shape))
        throw Error("In tabular: Array '" + a->name() + "' does not match the shape of the initial Array.");
 
    read_array_values(a);
 
    the_arrays.at(n) = a;       // small number of Arrays; use the safe method
}

void TabularFunction::read_values(const vector<Array*> &arrays)
{
    // NB: read_array_values is defined at the very top of this file
    for_each(arrays.begin(), arrays.end(), read_array_values);
}

void TabularFunction::build_sequence_values(const vector<Array*> &the_arrays, SequenceValues &sv)
{
    // This can be optimized for most cases because we're storing objects for Byte, Int32, ...
    // values where we could be storing native types. But this is DAP2 code... jhrg 2/3/15
    //
    // NB: SequenceValues == vector< vector<BaseType*> *>, and
    // D4SeqRow, BaseTypeRow == vector<BaseType*>
    for (SequenceValues::size_type i = 0; i < sv.size(); ++i) {
 
        BaseTypeRow *row = new BaseTypeRow(the_arrays.size());
 
        for (BaseTypeRow::size_type j = 0; j < the_arrays.size(); ++j) {
            DBG(cerr << "the_arrays.at(" << j << ") " << the_arrays.at(j) << endl);
            // i == row number; j == column (or array) number
            (*row)[j]/*->at(j)*/= the_arrays[j]/*.at(j)*/->var(i)->ptr_duplicate();
 
            (*row)[j]->set_send_p(true);
            (*row)[j]->set_read_p(true);
        }
 
        sv[i]/*.at(i)*/= row;
    }
}

void TabularFunction::combine_sequence_values(SequenceValues &dep, const SequenceValues &indep)
{
    SequenceValues::const_iterator ii = indep.begin(), ie = indep.end();
    for (SequenceValues::iterator i = dep.begin(), e = dep.end(); i != e; ++i) {
        // When we get to the end of the indep variables, start over
        // This test is at the start of the loop so that we can test ii == ie on exit
        if (ii == ie) ii = indep.begin();
        // This call to insert() copies the pointers, but that will lead to duplicate
        // calls to delete when Sequence deletes the SequenceValues object. Could be
        // replaced with reference counted pointers??? jhrg 3/13/15
        // (*i)->insert((*i)->end(), (*ii)->begin(), (*ii)->end());
        for (BaseTypeRow::iterator btr_i = (*ii)->begin(), btr_e = (*ii)->end(); btr_i != btr_e; ++btr_i) {
            (*i)->push_back((*btr_i)->ptr_duplicate());
        }
        ++ii;
    }
 
    assert(ii == ie);
}

void TabularFunction::add_index_column(const Shape &indep_shape, const Shape &dep_shape,
        vector<Array*> &dep_vars)
{
    assert(dep_vars.size() > 0);
    assert(dep_shape.size() == indep_shape.size() + 1);
 
    // load a vector with values for the new variable
    unsigned long num_indep_values = number_of_values(indep_shape);
    unsigned long num_dep_values = number_of_values(dep_shape);
    vector<dods_uint32> index_vals(num_dep_values);
 
    assert(num_dep_values == num_indep_values * dep_shape.at(0));
 
    // dep_shape.at(0) == the left-most dimension size
    vector<dods_uint32>::iterator iv = index_vals.begin();
    for (Shape::size_type i = 0; i < dep_shape.at(0); ++i) {
        assert(iv != index_vals.end());
        fill(iv, iv + num_indep_values, i);
        iv += num_indep_values;
    }
 
    // Figure out what to call the new variable/column
    string new_column_name = dep_vars.at(0)->dimension_name(dep_vars.at(0)->dim_begin());
    if (new_column_name.empty())
        new_column_name = "index";
 
    // Make the new column var
    Array *a = new Array(new_column_name, new UInt32(new_column_name));
    a->append_dim(num_dep_values, new_column_name);
    a->set_value(index_vals, (int)index_vals.size());
    a->set_read_p(true);
 
    dep_vars.insert(dep_vars.begin(), a);
}

void TabularFunction::function_dap2_tabular(int argc, BaseType *argv[], DDS &, BaseType **btpp)
{
    vector<Array*> the_arrays;
    // collect all of the arrays; separates them from other kinds of parameters
    for (int n = 0; n < argc; ++n) {
        if (argv[n]->type() != dods_array_c)
            throw Error("In function tabular(): Expected an array, but argument " + argv[n]->name()
                    + " is a " + argv[n]->type_name() + ".");
        the_arrays.push_back(static_cast<Array*>(argv[n]));
    }
 
    if (the_arrays.size() < 1)
        throw Error("In function tabular(): Expected at least one Array variable.");
 
    // every var with dimension == min_dim_size is considered an 'independent' var
    unsigned long min_dim_size = ULONG_MAX;   // <climits>
    for (vector<Array*>::iterator i = the_arrays.begin(), e = the_arrays.end(); i != e; ++i) {
        min_dim_size = min((unsigned long) (*i)->dimensions(), min_dim_size);
    }
 
    // collect the independent and dependent variables; size _and_ shape must match
    vector<Array*> indep_vars, dep_vars;
    for (vector<Array*>::iterator i = the_arrays.begin(), e = the_arrays.end(); i != e; ++i) {
        if ((*i)->dimensions() == min_dim_size) {
            indep_vars.push_back(*i);
        }
        else {
            dep_vars.push_back(*i);
        }
    }
 
    Shape indep_shape = array_shape(indep_vars.at(0));
    // Test that all the indep arrays have the same shape
    for (vector<Array*>::iterator i = indep_vars.begin()+1, e = indep_vars.end(); i != e; ++i) {
        if (!shape_matches(*i, indep_shape))
            throw Error("In function tabular(): Expected all of the 'independent' variables to have the same shape.");
    }
 
    // Read the values and load them into a SequenceValues object
    read_values(indep_vars);
    unsigned long num_indep_values = number_of_values(indep_shape);
    SequenceValues indep_sv(num_indep_values);
    build_sequence_values(indep_vars, indep_sv);
 
    // Set the reference to the result. If there are any dependent variables,
    // 'result' will be set to 'dep_vars' once that has been hasked and the
    // indep_vars merged in.
    SequenceValues &result = indep_sv;
 
    // If there are dependent variables, process them
    if (dep_vars.size() > 0) {
        Shape dep_shape = array_shape(dep_vars.at(0));
        // Test that all the dep arrays have the same shape
        for (vector<Array*>::iterator i = dep_vars.begin()+1, e = dep_vars.end(); i != e; ++i) {
            if (!shape_matches(*i, dep_shape))
                throw Error("In function tabular(): Expected all of the 'dependent' variables to have the same shape.");
        }
 
        // Test shapes here. My code assumes that deps are like dep_vars[7][x][y]
        // and indep_vars are [x][y] - the left-most dim is the 'extra' parameter
        // of the dep_vars.
        if (dep_shape.size() > indep_shape.size() + 1)
            throw Error("In function tabular(): The rank of the dependent variables may be at most one more than the rank of the independent variables");
        if (dep_shape.size() < indep_shape.size())
            throw Error("In function tabular(): The rank of the dependent variables cannot be less than the rank of the independent variables");
 
        if (!dep_indep_match(dep_shape, indep_shape))
            throw Error("In function tabular(): The 'independent' array shapes must match the right-most dimensions of the 'dependent' variables.");
 
        read_values(dep_vars);
        unsigned long num_dep_values = number_of_values(dep_shape);
        SequenceValues dep_sv(num_dep_values);
 
        // Add and extra variable for extra dimension's index
        add_index_column(indep_shape, dep_shape, dep_vars);
 
        build_sequence_values(dep_vars, dep_sv);
 
        // Now combine the dependent and independent variables; put the
        // result in the dependent variable vector and assign the 'result'
        // reference to it.
        combine_sequence_values(dep_sv, indep_sv);
        result = dep_sv;
    }
 
    unique_ptr<TabularSequence> response(new TabularSequence("table"));
 
    if (!dep_vars.empty()) {
        // set the columns of the response
        for (auto variable: dep_vars) {
            response->add_var(variable->var());
        }
    }
 
    for (auto variable: indep_vars) {
        response->add_var(variable->var());
    }
 
    // set the values of the response
    response->set_value(result);
    response->set_read_p(true);
 
    *btpp = response.release();
}
 
#if 0
 
// Rework this as time permits. jhrg 3/12/15

BaseType *TabularFunction::function_dap4_tabular(D4RValueList *args, DMR &dmr)
{
    // unique_ptr is not avialable on gcc 4.2. jhrg 2/11/15
    //unique_ptr<D4Sequence> response(new D4Sequence("table"));
    unique_ptr<D4Sequence> response(new D4Sequence("table"));
 
    int num_arrays = args->size();              // Might pass in other stuff...
    vector<unsigned long> shape;            // Holds shape info; used to test array sizes for uniformity
    vector<Array*> the_arrays(num_arrays);
 
    for (int n = 0; n < num_arrays; ++n) {
        TabularFunction::build_columns(n, args->get_rvalue(n)->value(dmr), the_arrays, shape);
    }
 
    DBG(cerr << "the_arrays.size(): " << the_arrays.size() << endl);
 
    for (unsigned long n = 0; n < the_arrays.size(); ++n) {
        response->add_var(the_arrays[n]->var());
    }
 
    unsigned long num_values = TabularFunction::number_of_values(shape);
    D4SeqValues sv(num_values);
    // sv is a value-result parameter
    TabularFunction::build_sequence_values(the_arrays, sv);
 
    response->set_value(sv);
    response->set_read_p(true);
 
    return response.release();
}
#endif
 
} // namesspace functions