ConstraintEvaluator.h

// -*- mode: c++; c-basic-offset:4 -*-
 
// This file is part of libdap, A C++ implementation of the OPeNDAP Data
// Access Protocol.
 
// Copyright (c) 2006 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.
 
#ifndef constraint_evaluator_h
#define constraint_evaluator_h
 
#include <vector>
 
#include "RValue.h"
#include "expr.h"
 
namespace libdap {
 
class DDS;
class DataDDS;
struct Clause;
class ServerFunctionsList;

class ConstraintEvaluator {
private:
    std::vector<Clause *> expr; // List of CE Clauses
 
    std::vector<BaseType *> constants; // List of temporary objects
 
    ServerFunctionsList *d_functions_list; // Known external functions from
                                           // modules
 
    // The default versions of these methods will break this class. Because
    // Clause does not support deep copies, that class will need to be modified
    // before these can be properly implemented. jhrg 4/3/06
    ConstraintEvaluator(const ConstraintEvaluator &);
    ConstraintEvaluator &operator=(const ConstraintEvaluator &);
 
    friend class func_name_is;
 
public:
    typedef std::vector<Clause *>::const_iterator Clause_citer;
    typedef std::vector<Clause *>::iterator Clause_iter;
 
    typedef std::vector<BaseType *>::const_iterator Constants_citer;
    typedef std::vector<BaseType *>::iterator Constants_iter;
 
    ConstraintEvaluator();
 
    virtual ~ConstraintEvaluator();
    bool find_function(const std::string &name, bool_func *f) const;
    bool find_function(const std::string &name, btp_func *f) const;
    bool find_function(const std::string &name, proj_func *f) const;
 
    void append_clause(int op, rvalue *arg1, rvalue_list *arg2);
    void append_clause(bool_func func, rvalue_list *args);
    void append_clause(btp_func func, rvalue_list *args);
 
    bool functional_expression();
    bool boolean_expression();
    bool eval_selection(DDS &dds, const std::string &dataset);
    BaseType *eval_function(DDS &dds, const std::string &dataset);
 
    // New for libdap 3.11. These methods provide a way to evaluate multiple
    // functions in one CE
    bool function_clauses();
    DDS *eval_function_clauses(DDS &dds);
    DataDDS *eval_function_clauses(DataDDS &dds);
 
    Clause_iter clause_begin();
    Clause_iter clause_end();
    bool clause_value(Clause_iter &i, DDS &dds);
 
    void parse_constraint(const std::string &constraint, DDS &dds);
    void append_constant(BaseType *btp);
};
 
} // namespace libdap
 
#endif // constraint_evaluator_h