GSEClause.cc

// -*- mode: c++; c-basic-offset:4 -*-

// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.

// Copyright (c) 2002,2003 OPeNDAP, Inc.
// Author: 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.

// (c) COPYRIGHT URI/MIT 1999
// Please read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
//      jhrg,jimg       James Gallagher <jgallagher@gso.uri.edu>

// The Grid Selection Expression Clause class.


#include "config.h"

#include <iostream>
#include <sstream>

#include <Array.h>
#include <Grid.h>
#include <dods-datatypes.h>
#include <Error.h>
#include <InternalErr.h>
#include <debug.h>

#include "GSEClause.h"
#include "parser.h"
#include "gse.tab.hh"

using namespace std;
using namespace libdap;

namespace functions {

// For the comparisons here, we should use an epsilon to catch issues
// with floating point values. jhrg 01/12/06
template<class T>
static bool
compare(T elem, relop op, double value)
{
    switch (op) {
    case dods_greater_op:
        return elem > value;
    case dods_greater_equal_op:
        return elem >= value;
    case dods_less_op:
        return elem < value;
    case dods_less_equal_op:
        return elem <= value;
    case dods_equal_op:
        return elem == value;
    case dods_not_equal_op:
        return elem != value;
    case dods_nop_op:
        throw Error(malformed_expr, "Attempt to use NOP in Grid selection.");
    default:
        throw Error(malformed_expr, "Unknown relational operator in Grid selection.");
    }
}

// These values are used in error messages, hence the strings.
template<class T>
void
GSEClause::set_map_min_max_value(T min, T max)
{
    DBG(cerr << "Inside set map min max value " << min << ", " << max << endl);
    std::ostringstream oss1;
    oss1 << min;
    d_map_min_value = oss1.str();

    std::ostringstream oss2;
    oss2 << max;
    d_map_max_value = oss2.str();
}

// Read the map array, scan, set start and stop.
template<class T>
void
GSEClause::set_start_stop()
{
    T *vals = new T[d_map->length()];
    d_map->value(vals);

    // Set the map's max and min values for use in error messages (it's a lot
    // easier to do here, now, than later... 9/20/2001 jhrg)
    set_map_min_max_value<T>(vals[d_start], vals[d_stop]);

    // Starting at the current start point in the map (initially index position
    // zero), scan forward until the comparison is true. Set the new value
    // of d_start to that location. Note that each clause applies to exactly
    // one map. The 'i <= end' test keeps us from setting start _past_ the
    // end ;-)
    int i = d_start;
    int end = d_stop;
    while (i <= end && !compare<T>(vals[i], d_op1, d_value1))
        i++;

    d_start = i;

    // Now scan backward from the end. We scan all the way to the actual start
    // although it would probably work to stop at 'i >= d_start'.
    i = end;
    while (i >= 0 && !compare<T>(vals[i], d_op1, d_value1))
        i--;
    d_stop = i;

    // Every clause must have one operator but the second is optional since
    // the more complex form of a clause is optional. That is, the above two
    // loops took care of constraints like 'x < 7' but we need the following
    // for ones like '3 < x < 7'.
    if (d_op2 != dods_nop_op) {
        int i = d_start;
        int end = d_stop;
        while (i <= end && !compare<T>(vals[i], d_op2, d_value2))
            i++;

        d_start = i;

        i = end;
        while (i >= 0 && !compare<T>(vals[i], d_op2, d_value2))
            i--;

        d_stop = i;
    }
    
    delete[] vals;
}

void
GSEClause::compute_indices()
{
    switch (d_map->var()->type()) {
    case dods_byte_c:
        set_start_stop<dods_byte>();
        break;
    case dods_int16_c:
        set_start_stop<dods_int16>();
        break;
    case dods_uint16_c:
        set_start_stop<dods_uint16>();
        break;
    case dods_int32_c:
        set_start_stop<dods_int32>();
        break;
    case dods_uint32_c:
        set_start_stop<dods_uint32>();
        break;
    case dods_float32_c:
        set_start_stop<dods_float32>();
        break;
    case dods_float64_c:
        set_start_stop<dods_float64>();
        break;
    default:
        throw Error(malformed_expr,
                    "Grid selection using non-numeric map vectors is not supported");
    }

}

// Public methods

GSEClause::GSEClause(Grid *grid, const string &map, const double value,
                     const relop op)
        : d_map(0),
        d_value1(value), d_value2(0), d_op1(op), d_op2(dods_nop_op),
        d_map_min_value(""), d_map_max_value("")
{
    d_map = dynamic_cast<Array *>(grid->var(map));
    if (!d_map)
        throw Error(string("The map variable '") + map
                    + string("' does not exist in the grid '")
                    + grid->name() + string("'."));

    DBG(cerr << d_map->toString());

    // Initialize the start and stop indices.
    Array::Dim_iter iter = d_map->dim_begin();
    d_start = d_map->dimension_start(iter);
    d_stop = d_map->dimension_stop(iter);

    compute_indices();
}

GSEClause::GSEClause(Grid *grid, const string &map, const double value1,
                     const relop op1, const double value2, const relop op2)
        : d_map(0),
        d_value1(value1), d_value2(value2), d_op1(op1), d_op2(op2),
        d_map_min_value(""), d_map_max_value("")
{
    d_map = dynamic_cast<Array *>(grid->var(map));
    if (!d_map)
        throw Error(string("The map variable '") + map
                    + string("' does not exist in the grid '")
                    + grid->name() + string("'."));

    DBG(cerr << d_map->toString());

    // Initialize the start and stop indices.
    Array::Dim_iter iter = d_map->dim_begin();
    d_start = d_map->dimension_start(iter);
    d_stop = d_map->dimension_stop(iter);

    compute_indices();
}

GSEClause::~GSEClause()
{
    delete d_map;
}

bool
GSEClause::OK() const
{
    if (!d_map)
        return false;

    // More ...

    return true;
}

Array *
GSEClause::get_map() const
{
    return d_map;
}

void
GSEClause::set_map(Array *map)
{
    d_map = map;
}

string
GSEClause::get_map_name() const
{
    return d_map->name();
}

int
GSEClause::get_start() const
{
    return d_start;
}

void
GSEClause::set_start(int start)
{
    d_start = start;
}

int
GSEClause::get_stop() const
{
    DBG(cerr << "Returning stop index value of: " << d_stop << endl);
    return d_stop;
}

void
GSEClause::set_stop(int stop)
{
    d_stop = stop;
}

string
GSEClause::get_map_min_value() const
{
    return d_map_min_value;
}

string
GSEClause::get_map_max_value() const
{
    return d_map_max_value;
}

} // namespace functions