boundarysegment.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_BOUNDARY_SEGMENT_HH
#define DUNE_GRID_COMMON_BOUNDARY_SEGMENT_HH
 
#include <map>
#include <sstream>
 
#include <dune/common/singleton.hh>
#include <dune/common/parameterizedobject.hh>
#include <dune/common/fvector.hh>
 
namespace Dune {
 
  template< int dim, int dimworld = dim, class ctype = double >
  struct BoundarySegment;
 
  template <class BndSeg>
  class BoundarySegmentBackupRestore
  {
  public:
    // type of object stream used for storing boundary segment information
    typedef std::stringstream ObjectStreamType ;
 
  protected:
    typedef BndSeg  BoundarySegment;
 
    typedef Dune::ParameterizedObjectFactory< std::unique_ptr< BoundarySegment > ( ObjectStreamType& ), int > FactoryType;
 
    static std::unique_ptr< BoundarySegment > restore( ObjectStreamType& in )
    {
      int key = -1;
      // read class key for restore
      in.read( (char *) &key, sizeof( int ) );
 
      // factory creates a unique_ptr which can be released later on
      return factory().create( key, in );
    }
 
    template <class DerivedType>
    static int registerFactory()
    {
      const int key = createKey();
      // create factory method that produces unique_ptr
      factory().template define< DerivedType >( key );
      // return key for storage in derived class
      return key;
    }
 
  private:
    static int createKey()
    {
      static int key = 0;
      return key++;
    }
 
    static FactoryType& factory()
    {
      return Dune::Singleton< FactoryType > :: instance();
    }
  };
 
  template< int dim, int dimworld, class ctype >
  struct BoundarySegment : public BoundarySegmentBackupRestore< BoundarySegment< dim, dimworld, ctype > >
  {
    typedef BoundarySegment< dim, dimworld, ctype > ThisType;
    typedef BoundarySegmentBackupRestore< BoundarySegment< dim, dimworld, ctype > > BaseType;
 
    typedef typename BaseType :: ObjectStreamType ObjectStreamType;
 
    using BaseType :: restore;
    using BaseType :: registerFactory;
 
    virtual ~BoundarySegment() {}
 
    virtual FieldVector< ctype, dimworld >
    operator() ( const FieldVector< ctype, dim-1> &local ) const = 0;
 
    virtual void backup( ObjectStreamType& buffer ) const
    {
      DUNE_THROW(NotImplemented,"BoundarySegment::backup needs to be overloaded!");
    }
  };
 
 
}  // end namespace Dune
 
#endif