datahandleif.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_DATAHANDLEIF_HH
#define DUNE_DATAHANDLEIF_HH
 
#include <dune/common/bartonnackmanifcheck.hh>
 
namespace Dune
{
 
  template <class MessageBufferImp>
  class MessageBufferIF
  {
    MessageBufferImp & buff_;
  public:
    MessageBufferIF(MessageBufferImp & buff) : buff_(buff) {}
 
    template <class T>
    void write(const T & val)
    {
      buff_.write(val);
    }
 
    template <class T>
    void read(T & val)
    {
      buff_.read(val);
    }
  }; // end class MessageBufferIF
 
 
  template <class DataHandleImp, class DataTypeImp>
  class CommDataHandleIF
  {
  public:
    typedef DataTypeImp DataType;
 
  protected:
    // one should not create an explicit instance of this interface object
    CommDataHandleIF() {}
 
  public:
    bool contains (int dim, int codim) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().contains(dim,codim)));
      return asImp().contains(dim,codim);
    }
 
    bool fixedsize (int dim, int codim) const
    {
      auto basePtr = &CommDataHandleIF<DataHandleImp,DataTypeImp>::fixedSize;
      auto derPtr = &DataHandleImp::fixedSize;
      bool hasOverwrittenFixedSize = basePtr != derPtr;
      if (hasOverwrittenFixedSize)
        return asImp().fixedSize(dim,codim);
      else
        return asImp().fixedsize(dim,codim);
    }
 
    bool fixedSize (int dim, int codim) const
    {
      auto basePtr = &CommDataHandleIF<DataHandleImp,DataTypeImp>::fixedSize;
      auto derPtr = &DataHandleImp::fixedSize;
      bool hasOverwrittenFixedSize = basePtr != derPtr;
      if (hasOverwrittenFixedSize)
        return asImp().fixedSize(dim,codim);
      else
        return asImp().fixedsize(dim,codim);
    }
 
    template<class EntityType>
    size_t size (const EntityType& e) const
    {
      CHECK_INTERFACE_IMPLEMENTATION((asImp().size(e)));
      return asImp().size(e);
    }
 
    template<class MessageBufferImp, class EntityType>
    void gather (MessageBufferImp& buff, const EntityType& e) const
    {
      MessageBufferIF<MessageBufferImp> buffIF(buff);
      CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().gather(buffIF,e)));
    }
 
    template<class MessageBufferImp, class EntityType>
    void scatter (MessageBufferImp& buff, const EntityType& e, size_t n)
    {
      MessageBufferIF<MessageBufferImp> buffIF(buff);
      CHECK_AND_CALL_INTERFACE_IMPLEMENTATION((asImp().scatter(buffIF,e,n)));
    }
 
  private:
    DataHandleImp& asImp () {return static_cast<DataHandleImp &> (*this);}
    const DataHandleImp& asImp () const
    {
      return static_cast<const DataHandleImp &>(*this);
    }
  }; // end class CommDataHandleIF
 
#undef CHECK_INTERFACE_IMPLEMENTATION
#undef CHECK_AND_CALL_INTERFACE_IMPLEMENTATION
 
} // end namespace Dune
#endif