D4FilterClause.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 1996,1998,1999
// Please first read the full copyright statement in the file COPYRIGHT_URI.
//
// Authors:
// jhrg,jimg James Gallagher <jgallagher@gso.uri.edu>

// Implementation for the CE Clause class.

#include "config.h"

#include "D4FilterClause.h"
#include "D4RValue.h"

using namespace std;

namespace libdap {

void D4FilterClauseList::m_duplicate(const D4FilterClauseList &src) {
    // D4FilterClauseList &non_c_src = const_cast<D4FilterClauseList &>(src);

    for (D4FilterClauseList::citer i = src.cbegin(), e = src.cend(); i != e; ++i) {
        D4FilterClause *fc = *i;
        d_clauses.push_back(new D4FilterClause(*fc));
    }
}

D4FilterClauseList::~D4FilterClauseList() {
    for (D4FilterClauseList::iter i = d_clauses.begin(), e = d_clauses.end(); i != e; ++i) {
        delete *i;
    }
}

/**
 * @brief Evaluate the list of clauses
 *
 * Evaluate the list of clauses and return false when/if one is found to be false.
 * This evaluates the clauses in the order they are stored and stops evaluation a
 * the first false clause.
 *
 * @param dmr Use this DMR when evaluating clauses - for clauses that contain functions,
 * not currently in the DAP4 specification.
 * @return True if each of the clauses' value is true, otherwise false
 */
bool D4FilterClauseList::value(DMR &dmr) {
    for (D4FilterClauseList::iter i = d_clauses.begin(), e = d_clauses.end(); i != e; ++i) {
        if ((*i)->value(dmr) == false)
            return false;
    }

    return true;
}

/**
 * @brief Evaluate the list of clauses
 *
 * This version of value() does not need a DMR parameter (but will not work
 * if the clauses contain a function call (which is not currently supported
 * by the spec).
 *
 * @return True if each clauses' value is true, false otherwise
 * @see D4FilterClauseList::value(DMR &dmr)
 */
bool D4FilterClauseList::value() {
    for (D4FilterClauseList::iter i = d_clauses.begin(), e = d_clauses.end(); i != e; ++i) {
        if ((*i)->value() == false)
            return false;
    }

    return true;
}

void D4FilterClause::m_duplicate(const D4FilterClause &rhs) {
    d_op = rhs.d_op;

    d_arg1 = new D4RValue(*rhs.d_arg1);
    d_arg2 = new D4RValue(*rhs.d_arg2);

#if 0
    // Copy the D4RValue pointer if the 'value_kind' is a basetype,
    // but build a new D4RValue if it is a constant (because the
    // basetype is a weak pointer.
    switch (rhs.d_arg1->get_kind()) {
    case D4RValue::basetype:
        d_arg1 = rhs.d_arg1;
        break;
    case D4RValue::constant:
        d_arg1 = new D4RValue(*(rhs.d_arg1));
        break;
    default:
        throw Error(malformed_expr, "found a filter clause with a function call.");
    }

    switch (rhs.d_arg2->get_kind()) {
    case D4RValue::basetype:
        d_arg2 = rhs.d_arg2;
        break;
    case D4RValue::constant:
        d_arg2 = new D4RValue(*(rhs.d_arg2));
        break;
    default:
        throw Error(malformed_expr, "found a filter clause with a function call.");
    }
#endif
}

/**
 * @brief Get the value of this relational expression.
 * This version of value() works for function clauses, although that's
 * not supported by the syntax at this time.
 * @param dmr The DMR to use when evaluating a function
 * @return True if the clause is true, false otherwise.
 */
bool D4FilterClause::value(DMR &dmr) {
    switch (d_op) {
    case null:
        throw InternalErr(__FILE__, __LINE__, "While evaluating a constraint filter clause: Found a null operator");

    case less:
    case greater:
    case less_equal:
    case greater_equal:
    case equal:
    case not_equal:
    case match:
        return cmp(d_op, d_arg1->value(dmr), d_arg2->value(dmr));

    case ND:
    case map:
        throw InternalErr(__FILE__, __LINE__,
                          "While evaluating a constraint filter clause: Filter operator not implemented");

    default:
        throw InternalErr(__FILE__, __LINE__, "While evaluating a constraint filter clause: Unrecognized operator");
    }
}

/**
 * @brief Get the value of this relational expression.
 * This version of value() will not work for clauses where one of the
 * rvalues is a function call. This is not currently supported by the
 * DAP4 specification, so it's probably no great loss.
 * @return True if the clause is true, false otherwise.
 */
bool D4FilterClause::value() {
    switch (d_op) {
    case null:
        throw InternalErr(__FILE__, __LINE__, "While evaluating a constraint filter clause: Found a null operator");

    case less:
    case greater:
    case less_equal:
    case greater_equal:
    case equal:
    case not_equal:
    case match:
        return cmp(d_op, d_arg1->value(), d_arg2->value());

    case ND:
    case map:
        throw InternalErr(__FILE__, __LINE__,
                          "While evaluating a constraint filter clause: Filter operator not implemented");

    default:
        throw InternalErr(__FILE__, __LINE__, "While evaluating a constraint filter clause: Unrecognized operator");
    }
}

// It may be better to use the code in the Byte, ..., classes that was
// impl'd for DAP2 (with extensions). For now, test this and build the
// rest of the filter implementation. But there is certainly a more _compact_
// way to code this!
//
// Optimize the extraction of constant values.
bool D4FilterClause::cmp(ops op, BaseType *arg1, BaseType *arg2) { return arg1->d4_ops(arg2, op); }

} // namespace libdap