topologyfactory.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GEOMETRY_TOPOLOGYFACTORY_HH
#define DUNE_GEOMETRY_TOPOLOGYFACTORY_HH
 
#include <vector>
#include <map>
 
#include <dune/common/array.hh>
 
#include <dune/geometry/type.hh>
 
namespace Dune
{
 
  template <class Traits>
  struct TopologyFactory
  {
    // extract types from Traits class
    static const unsigned int dimension = Traits::dimension;
    typedef typename Traits::Key Key;
    typedef typename Traits::Object Object;
    typedef typename Traits::Factory Factory;
 
    static Object *create ( const Dune::GeometryType &gt, const Key &key )
    {
      return Impl::IfTopology< Maker, dimension >::apply( gt.id(), key );
    }
 
    template< class Topology >
    static Object *create ( const Key &key )
    {
      return Factory::template createObject< Topology >( key );
    }
 
    static void release( Object *object ) { delete object; }
 
  private:
    // Internal maker class used in ifTopology helper
    template< class Topology >
    struct Maker
    {
      static Object *apply ( const Key &key )
      {
        return create< Topology >( key );
      };
    };
  };
 
 
 
  template <class Factory>
  struct TopologySingletonFactory
  {
    static const unsigned int dimension = Factory::dimension;
    typedef typename Factory::Key Key;
    typedef const typename Factory::Object Object;
 
    static Object *create ( const Dune::GeometryType &gt, const Key &key )
    {
      assert( gt.id() < numTopologies );
      return instance().getObject( gt, key );
    }
    template< class Topology >
    static Object *create ( const Key &key )
    {
      static_assert((Topology::dimension == dimension),
                    "Topology with incompatible dimension used");
      return instance().template getObject< Topology >( key );
    }
    static void release ( Object *object )
    {}
  private:
    static TopologySingletonFactory &instance ()
    {
      static TopologySingletonFactory instance;
      return instance;
    }
 
    static const unsigned int numTopologies = (1 << dimension);
    typedef std::array< Object *, numTopologies > Array;
    typedef std::map< Key, Array > Storage;
 
    TopologySingletonFactory ()
    {}
    ~TopologySingletonFactory ()
    {
      const typename Storage::iterator end = storage_.end();
      for( typename Storage::iterator it = storage_.begin(); it != end; ++it )
      {
        for( unsigned int topologyId = 0; topologyId < numTopologies; ++topologyId )
        {
          Object *&object = it->second[ topologyId ];
          if( object != 0 )
            Factory::release( object );
          object = 0;
        }
      }
    }
 
    Object *&find( const unsigned int topologyId, const Key &key )
    {
      typename Storage::iterator it = storage_.find( key );
      if( it == storage_.end() )
        it = storage_.insert( std::make_pair( key, fill_array<Object*, numTopologies>( nullptr ) ) ).first;
      return it->second[ topologyId ];
    }
 
    Object *getObject ( const Dune::GeometryType &gt, const Key &key )
    {
      Object *&object = find( gt.id(), key );
      if( object == 0 )
        object = Factory::create( gt, key );
      return object;
    }
 
    template< class Topology >
    Object *getObject ( const Key &key )
    {
      Object *&object = find(Topology::id,key);
      if( object == 0 )
        object = Factory::template create< Topology >( key );
      return object;
    }
    Storage storage_;
  };
 
}
 
#endif // #ifndef DUNE_GEOMETRY_TOPOLOGYFACTORY_HH