localobjectstorage.hh

#ifndef __DUNE_ACFEM_LOCALOBJECTSTORAGE_HH__
#define __DUNE_ACFEM_LOCALOBJECTSTORAGE_HH__
 
#include <dune/fem/storage/objectstack.hh>
 
namespace Dune {
 
  namespace ACFem {
 
    template<class GlobalObject, class LocalObject>
    class LocalObjectFactory
    {
     public:
      typedef GlobalObject GlobalObjectType;
      typedef LocalObject ObjectType;
 
     public:
      explicit LocalObjectFactory(GlobalObjectType& global)
        : globalObject_(global)
      {}
 
      ObjectType *newObject() const
      {
        return new ObjectType(globalObject_);
      }
 
     protected:
      GlobalObjectType& globalObject_;
    };
 
    template<class Factory, template<class> class Wrapper>
    class LocalObjectStack
      : public Fem::ObjectStack<Factory>
    {
      typedef LocalObjectStack ThisType;
      typedef Fem::ObjectStack<Factory> BaseType;
     public:
      typedef Factory LocalObjectFactoryType;
      typedef typename LocalObjectFactoryType::ObjectType LocalObjectType;
      typedef typename LocalObjectFactoryType::GlobalObjectType GlobalObjectType;
      typedef Wrapper<ThisType> LocalWrapperType;
 
     public:
      explicit LocalObjectStack(const LocalObjectFactoryType& factory)
        : BaseType(factory)
      {}
 
     private:
      LocalObjectStack(const ThisType&);
      ThisType& operator=(const ThisType&);
 
     public:
      LocalWrapperType localObject()
      {
        return LocalWrapperType(*this);
      }
 
      template<class Entity>
      LocalWrapperType localObject(Entity& entity)
      {
        return LocalWrapperType(entity, *this);
      }
 
      template<class Entity>
      const LocalWrapperType localObject(Entity& entity) const
      {
        return LocalWrappertType(entity, *this);
      }
    };
 
    template<class Storage>
    struct MutableLocalObjectStorageProvider
    {
      typedef Storage StorageType;
      typedef typename StorageType::LocalObjectFactoryType FactoryType;
      typedef typename StorageType::GlobalObjectType GlobalObjectType;
 
      MutableLocalObjectStorageProvider(GlobalObjectType& global)
        : factory_(global),
          storage_(factory_)
      {}
     private:
      MutableLocalObjectStorageProvider(const MutableLocalObjectStorageProvider&) = delete;
      MutableLocalObjectStorageProvider(MutableLocalObjectStorageProvider&&) = delete;
     public:
 
      StorageType& storage() const
      {
        return storage_;
      }
 
     protected:
      FactoryType factory_;
      mutable StorageType storage_;
    };
 
    template<class Global>
    struct MutableNoStorageProvider
    {
      typedef Global StorageType;
      typedef Global GlobalObjectType;
 
      MutableNoStorageProvider(GlobalObjectType& global)
        : global_(global)
      {}
 
      GlobalObjectType& storage() const
      {
        return global_;
      }
 
     protected:
      GlobalObjectType& global_;
    };
 
 
  } // ACFem::
 
} // Dune::
 
#endif // __DUNE_ACFEM_LOCALOBJECTSTORAGE_HH__