ConstraintEvaluator.cc

Go to the documentation of this file.

// -*- 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.
 
#include "config.h"
 
// #define DODS_DEBUG
 
#include "Clause.h"
#include "ConstraintEvaluator.h"
#include "DataDDS.h"
#include "ServerFunctionsList.h"
 
#include "ce_parser.h"
#include "debug.h"
#include "expr.h"
#include "parser.h"
 
struct yy_buffer_state;
 
int ce_exprparse(libdap::ce_parser_arg *arg);
 
// Glue routines declared in expr.lex
void ce_expr_switch_to_buffer(void *new_buffer);
void ce_expr_delete_buffer(void *buffer);
void *ce_expr_string(const char *yy_str);
 
namespace libdap {
 
ConstraintEvaluator::ConstraintEvaluator() {
    // Functions are now held in BES modules. jhrg 1/30/13
 
    // modules load functions to this list; this class searches the list
    // instead of having it's own copy. This is very similar to the BES'
    // various List classes, but this one is part of libdap and not the
    // BES. The List class is a singleton, so each function module can
    // register it's functions to the list object.
    d_functions_list = ServerFunctionsList::TheList();
}
 
ConstraintEvaluator::~ConstraintEvaluator() {
    // delete all the constants created by the parser for CE evaluation
    for (Constants_iter j = constants.begin(); j != constants.end(); j++) {
        BaseType *btp = *j;
        delete btp;
        btp = 0;
    }
 
    for (Clause_iter k = expr.begin(); k != expr.end(); k++) {
        Clause *cp = *k;
        delete cp;
        cp = 0;
    }
}

ConstraintEvaluator::Clause_iter ConstraintEvaluator::clause_begin() { return expr.begin(); }

ConstraintEvaluator::Clause_iter ConstraintEvaluator::clause_end() { return expr.end(); }

bool ConstraintEvaluator::clause_value(Clause_iter &iter, DDS &dds /*, const string &***/) {
    if (expr.empty())
        throw InternalErr(__FILE__, __LINE__, "There are no CE clauses for *this* DDS object.");
 
    return (*iter)->value(dds);
}

void ConstraintEvaluator::append_clause(int op, rvalue *arg1, rvalue_list *arg2) {
    Clause *clause = new Clause(op, arg1, arg2);
 
    expr.push_back(clause);
}

void ConstraintEvaluator::append_clause(bool_func func, rvalue_list *args) {
    Clause *clause = new Clause(func, args);
 
    expr.push_back(clause);
}

void ConstraintEvaluator::append_clause(btp_func func, rvalue_list *args) {
    Clause *clause = new Clause(func, args);
 
    expr.push_back(clause);
}

void ConstraintEvaluator::append_constant(BaseType *btp) { constants.push_back(btp); }

bool ConstraintEvaluator::find_function(const string &name, bool_func *f) const {
    return d_functions_list->find_function(name, f);
}

bool ConstraintEvaluator::find_function(const string &name, btp_func *f) const {
    return d_functions_list->find_function(name, f);
}

bool ConstraintEvaluator::find_function(const string &name, proj_func *f) const {
    return d_functions_list->find_function(name, f);
}


bool ConstraintEvaluator::functional_expression() {
    if (expr.empty())
        return false;
 
    Clause *cp = expr[0];
    return cp->value_clause();
}

BaseType *ConstraintEvaluator::eval_function(DDS &dds, const string &) {
    if (expr.size() != 1)
        throw InternalErr(__FILE__, __LINE__, "The length of the list of CE clauses is not 1.");
 
    Clause *cp = expr[0];
    BaseType *result;
    if (cp->value(dds, &result))
        return result;
    else
        return NULL;
}

bool ConstraintEvaluator::function_clauses() {
    if (expr.empty())
        return false;
 
    for (unsigned int i = 0; i < expr.size(); ++i) {
        Clause *cp = expr[i];
        if (!cp->value_clause())
            return false;
    }
 
    return true;
}

DDS *ConstraintEvaluator::eval_function_clauses(DDS &dds) {
    if (expr.empty())
        throw InternalErr(__FILE__, __LINE__, "The constraint expression is empty.");
 
    DDS *fdds = new DDS(dds.get_factory(), "function_result_" + dds.get_dataset_name());
    for (unsigned int i = 0; i < expr.size(); ++i) {
        Clause *cp = expr[i];
        BaseType *result;
        if (cp->value(dds, &result)) {
            // This is correct: The function must allocate the memory for the result
            // variable. 11/30/12 jhrg
            fdds->add_var_nocopy(result);
        } else {
            delete fdds;
            throw Error(internal_error, "A function was called but failed to return a value.");
        }
    }
 
    return fdds;
}

DataDDS *ConstraintEvaluator::eval_function_clauses(DataDDS &dds) {
    if (expr.empty())
        throw InternalErr(__FILE__, __LINE__, "The constraint expression is empty.");
 
    DataDDS *fdds = new DataDDS(dds.get_factory(), "function_result_" + dds.get_dataset_name(), dds.get_version(),
                                dds.get_protocol());
 
    for (unsigned int i = 0; i < expr.size(); ++i) {
        Clause *cp = expr[i];
        BaseType *result;
        if (cp->value(dds, &result)) {
            fdds->add_var_nocopy(result);
        } else {
            delete fdds;
            throw Error(internal_error, "A function was called but failed to return a value.");
        }
    }
 
    return fdds;
}

bool ConstraintEvaluator::boolean_expression() {
    if (expr.empty())
        return false;
 
    bool boolean = true;
    for (Clause_iter i = expr.begin(); i != expr.end(); i++) {
        boolean = boolean && (*i)->boolean_clause();
    }
 
    return boolean;
}

bool ConstraintEvaluator::eval_selection(DDS &dds, const string &) {
    if (expr.empty()) {
        DBG(cerr << "No selection recorded" << endl);
        return true;
    }
 
    DBG(cerr << "Eval selection" << endl);
 
    // A CE is made up of zero or more clauses, each of which has a boolean
    // value. The value of the CE is the logical AND of the clause
    // values. See ConstraintEvaluator::clause::value(...) for information on logical ORs in
    // CEs.
    bool result = true;
    for (Clause_iter i = expr.begin(); i != expr.end() && result; i++) {
        // A selection expression *must* contain only boolean clauses!
        if (!((*i)->boolean_clause()))
            throw InternalErr(__FILE__, __LINE__, "A selection expression must contain only boolean clauses.");
        result = result && (*i)->value(dds);
    }
 
    return result;
}

void ConstraintEvaluator::parse_constraint(const string &constraint, DDS &dds) {
    void *buffer = ce_expr_string(constraint.c_str());
 
    ce_expr_switch_to_buffer(buffer);
 
    ce_parser_arg arg(this, &dds);
 
    // For all errors, exprparse will throw Error.
    try {
        ce_exprparse(&arg);
        ce_expr_delete_buffer(buffer);
    } catch (...) {
        // Make sure to remove the buffer when there's an error
        ce_expr_delete_buffer(buffer);
        throw;
    }
}
 
} // namespace libdap