InsideListExpression.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: InsideListExpression.hpp,v 1.6 2004/12/31 14:00:47 delpinux Exp $

#ifndef INSIDE_LIST_EXPRESSION_HPP
#define INSIDE_LIST_EXPRESSION_HPP

#include <Expression.hpp>
#include <InsideExpression.hpp>

#include <Stringify.hpp>
#include <ErrorHandler.hpp>

class Object;
class Scene;

class InsideListExpression
  : public Expression
{
protected:

  typedef std::map<TinyVector<3, real_t>, size_t> ReferenceList;

public:
  enum NodeType {
    NodeAnd,
    NodeOr,
    NodeNot,
    NodeLeaf
  };

private:
  const NodeType __type;        
public:

  void execute()
  {
    this->subExecute();
    this->checkReferencesUniqueness();
  }

  virtual void subExecute() = 0;

  void checkReferencesUniqueness()
  {
    InsideListExpression::ReferenceList references;
    this->addReferences(references);
    for (ReferenceList::const_iterator i = references.begin();
         i != references.end(); ++i) {
      if ((*i).second > 1) {
        std::string errorMsg
          = "POV-Ray reference "+stringify((*i).first)+" is used "
                 +stringify((*i).second)+" times in the domain definition\n"
            "only once is allowed";
        throw ErrorHandler(__FILE__,__LINE__,
                           errorMsg,
                           ErrorHandler::normal);
      }
    }
  }

  virtual void
  addReferences(InsideListExpression::ReferenceList& references) = 0;

  virtual ReferenceCounting<Object> objects(const Scene& S) = 0;

  InsideListExpression(const InsideListExpression::NodeType type)
    : Expression(Expression::insideListExpression),
      __type(type)
  {
    ;
  }

  InsideListExpression(const InsideListExpression& ie)
    : Expression(ie),
      __type(ie.__type)
  {
    ;
  }

  virtual ~InsideListExpression()
  {
    ;
  }
};


class InsideListExpressionAnd
  : public InsideListExpression
{
private:

  ReferenceCounting<InsideListExpression> __node1;

  ReferenceCounting<InsideListExpression> __node2;

  std::ostream& put(std::ostream& os) const
  {
    os << '(' << *__node1 << " and " << *__node2 << ')';
    return os;
  }

public:

  ReferenceCounting<Object> objects(const Scene& S);

  void subExecute()
  {
    (*__node1).subExecute();
    (*__node2).subExecute();
  }

  void
  addReferences(InsideListExpression::ReferenceList& references)
  {
    (*__node1).addReferences(references);
    (*__node2).addReferences(references);
  }

  InsideListExpressionAnd(ReferenceCounting<InsideListExpression> node1,
                          ReferenceCounting<InsideListExpression> node2)
    : InsideListExpression(InsideListExpression::NodeAnd),
      __node1(node1),
      __node2(node2)
  {
    ;
  }

  InsideListExpressionAnd(const InsideListExpressionAnd& I)
    : InsideListExpression(I),
      __node1(I.__node1),
      __node2(I.__node2)
  {
    ;
  }

  ~InsideListExpressionAnd()
  {
    ;
  }
};


class InsideListExpressionOr
  : public InsideListExpression
{
private:

  ReferenceCounting<InsideListExpression> __node1;

  ReferenceCounting<InsideListExpression> __node2;

  std::ostream& put(std::ostream& os) const
  {
    os << '(' << *__node1 << " or " << *__node2 << ')';
    return os;
  }

public:
  ReferenceCounting<Object> objects(const Scene& S);

  void subExecute()
  {
    (*__node1).subExecute();
    (*__node2).subExecute();
  }

  void
  addReferences(InsideListExpression::ReferenceList& references)
  {
    (*__node1).addReferences(references);
    (*__node2).addReferences(references);
  }

  InsideListExpressionOr(ReferenceCounting<InsideListExpression> node1,
                          ReferenceCounting<InsideListExpression> node2)
    : InsideListExpression(InsideListExpression::NodeOr),
      __node1(node1),
      __node2(node2)
  {
    ;
  }

  InsideListExpressionOr(const InsideListExpressionOr& I)
    : InsideListExpression(I),
      __node1(I.__node1),
      __node2(I.__node2)
  {
    ;
  }

  ~InsideListExpressionOr()
  {
    ;
  }
};



class InsideListExpressionNot
  : public InsideListExpression
{
private:

  ReferenceCounting<InsideListExpression> __node;

  std::ostream& put(std::ostream& os) const
  {
    os << '!' << *__node;
    return os;
  }

public:

  ReferenceCounting<Object> objects(const Scene& S);

  void subExecute()
  {
    (*__node).subExecute();
  }

  void
  addReferences(InsideListExpression::ReferenceList& references)
  {
    (*__node).addReferences(references);
  }

  InsideListExpressionNot(ReferenceCounting<InsideListExpression> node)
    : InsideListExpression(InsideListExpression::NodeNot),
      __node(node)
  {
    ;
  }

  InsideListExpressionNot(const InsideListExpressionNot& I)
    : InsideListExpression(I),
      __node(I.__node)
  {
    ;
  }

  ~InsideListExpressionNot()
  {
    ;
  }
};


class InsideListExpressionLeaf
  : public InsideListExpression
{
private:

  ReferenceCounting<InsideExpression> __leaf;

  std::ostream& put(std::ostream& os) const
  {
    os << *__leaf;
    return os;
  }

public:
  ReferenceCounting<Object> objects(const Scene& S);

  void subExecute()
  {
    (*__leaf).execute();
  }

  void
  addReferences(InsideListExpression::ReferenceList& references)
  {
    references[(*__leaf).reference()]++;
  }

  InsideListExpressionLeaf(ReferenceCounting<InsideExpression> leaf)
    : InsideListExpression(InsideListExpression::NodeLeaf),
      __leaf(leaf)
  {
    ;
  }

  InsideListExpressionLeaf(const InsideListExpressionLeaf& I)
    : InsideListExpression(I),
      __leaf(I.__leaf)
  {
    ;
  }

  ~InsideListExpressionLeaf()
  {
    ;
  }
};

#endif // INSIDE_LIST_EXPRESSION_HPP

---