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 "D4RValue.h"
#include "D4FilterClause.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;
    }
}

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;
}

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
}

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");
    }
}

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