// -*- 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 "expr.h"
#include "RValue.h"

namespace libdap
{

class DDS;
class DataDDS;
struct Clause;
class ServerFunctionsList;

/** @brief Evaluate a constraint expression */
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