Expression.hpp

Go to the documentation of this file.

//  This file is part of ff3d - http://www.freefem.org/ff3d
//  Copyright (C) 2001, 2002, 2003 Stéphane Del Pino

//  This program is free software; you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation; either version 2, or (at your option)
//  any later version.

//  This program 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 General Public License for more details.

//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software Foundation,
//  Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  

//  $Id: Expression.hpp,v 1.7 2008/10/06 21:38:53 delpinux Exp $

#ifndef EXPRESSION_HPP
#define EXPRESSION_HPP

#include <Types.hpp>
#include <ReferenceCounting.hpp>
#include <StreamCenter.hpp>

#include <ErrorHandler.hpp>

class Expression
{
public:
  enum  Type {
    boolean,
    boundary,
    boundaryCondition,
    boundaryConditionList,

    domain,

    field,
    fieldlist,
    function,

    ifstreamexpression,
    integrated,
    integratedOperator,
    insideExpression,
    insideListExpression,
    istreamexpression,
    istreamExpressionList,

    linearExp,

    mesh,
    multiLinearExp,
    multiLinearExpSum,
    multiLinearForm,
    multiLinearFormSum,

    ofstreamexpression,
    option,
    ostreamexpression,
    ostreamExpressionList,

    pdeEquation,
    pdeOperator,
    pdeOperatorSum,
    pdeProblem,
    problem,

    real,

    scene,
    solver,
    solverOptions,
    string,
    subOption,
    subOptionList,

    testFunctionList,

    unknown,
    unknownList,

    variationalFormula,
    variationalBilinearOperator,
    variationalLinearOperator,
    variationalDirichlet,
    vector3
  };

private:
  Expression::Type __type;

protected:
  static Expression::Type
  getType(ReferenceCounting<Expression> e1,
          ReferenceCounting<Expression> e2)
  {
    return Expression::real;
  }

  virtual std::ostream& put(std::ostream& os) const = 0;

  virtual std::istream& _get(std::istream& is)
  {
    throw ErrorHandler(__FILE__,__LINE__,
                       "operator >> is not supported for this expression",
                       ErrorHandler::normal);
    return is;
  }

public:
  const Expression::Type& type() const
  {
    return __type;
  }

  virtual void execute() = 0;

  friend std::ostream& operator << (std::ostream& os, const Expression& e)
  {
    return e.put(os);
  }

  friend std::istream& operator >> (std::istream& is, Expression& e)
  {
    return e._get(is);
  }

  Expression(const Expression::Type& t)
    : __type(t)
  {
    ;
  }

  Expression(const Expression& e)
    : __type(e.__type)
  {
    ;
  }

  virtual ~Expression()
  {
    ;
  }
};

#endif // EXPRESSION_HPP

---