FunctionExpressionMeshReferences.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: FunctionExpressionMeshReferences.hpp,v 1.2 2007/11/20 22:24:41 delpinux Exp $

#ifndef FUNCTION_EXPRESSION_MESH_REFERENCES_HPP
#define FUNCTION_EXPRESSION_MESH_REFERENCES_HPP

#include <FunctionExpression.hpp>
#include <RealExpression.hpp>

#include <vector>
class FunctionExpressionMeshReferences
  : public FunctionExpression
{
public:
  class ReferencesSet
  {
    friend class FunctionExpressionMeshReferences;

  public:
    typedef std::vector<std::pair<ReferenceCounting<RealExpression>,
                                  ReferenceCounting<FunctionExpression> > >
    FunctionReferences;         
  private:
    FunctionReferences __functionReferences; 
  public:
    FunctionReferences& functionReferences()
    {
      return __functionReferences;
    }

    bool hasBoundaryExpression() const
    {
      bool found = false;
      for (FunctionReferences::const_iterator i = __functionReferences.begin();
           i != __functionReferences.end(); ++i) {
        found = (*(*i).second).hasBoundaryExpression();
      }
      return found;
    }

    friend std::ostream& operator << (std::ostream& os, const ReferencesSet& r)
    {
      FunctionReferences::const_iterator i = r.__functionReferences.begin();
      if (i != r.__functionReferences.end())
        os << *i->first << ':' << *i->second;
      i++;
      for (; i != r.__functionReferences.end(); ++i) {
        os << ',' << *i->first << ':' << *i->second;
      }
      return os;
    }

    void execute()
    {
      for (FunctionReferences::iterator i = __functionReferences.begin();
           i != __functionReferences.end(); ++i) {
        RealExpression* r = i->first;
        r->execute();
        i->second->execute();
      }
    }

    void add(ReferenceCounting<RealExpression> ref,
             ReferenceCounting<FunctionExpression> function)
    {
      __functionReferences.push_back(std::make_pair(ref, function));
    }

    ReferencesSet(ReferenceCounting<RealExpression> ref,
                  ReferenceCounting<FunctionExpression> function)
    {
      __functionReferences.push_back(std::make_pair(ref, function));
    }

    ReferencesSet(const ReferencesSet& r)
      : __functionReferences(r.__functionReferences)
    {
      ;
    }

    ~ReferencesSet()
    {
      ;
    }
  };

  enum ItemType {
    element,
    vertex,
    undefined
  };

private:
  std::string __itemName;       
  ReferenceCounting<MeshExpression> __mesh; 
  ReferenceCounting<ReferencesSet> __referenceSet; 
  ItemType __getItemType();

  std::ostream& put(std::ostream& os) const;
public:
  void execute();

  FunctionExpressionMeshReferences(const std::string itemName,
                                   ReferenceCounting<MeshExpression> mesh,
                                   ReferenceCounting<ReferencesSet> ref);

  FunctionExpressionMeshReferences(const FunctionExpressionMeshReferences& f);

  ~FunctionExpressionMeshReferences();
};


#endif // FUNCTION_EXPRESSION_MESH_REFERENCES_HPP

---