datahandleif.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_DATAHANDLEIF_HH
#define DUNE_GRID_COMMON_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
  {
    template <class M>
    class CheckFixedSizeMethod
    {
      // check for old signature of deprecated fixedsize method.
      template <class T>
      static std::true_type testSignature(bool (T::*)(int, int) const);
 
      template <class T>
      static decltype(testSignature(&T::fixedsize)) test(std::nullptr_t);
 
      template <class T>
      static std::false_type test(...);
 
      using type = decltype(test<M>(nullptr));
    public:
      static const bool value = type::value;
    };
 
 
    template <class DH, bool>
    struct CallFixedSize
    {
      static bool fixedSize( const DH& dh, int dim, int codim )
      {
        return dh.fixedSize( dim, codim );
      }
    };
 
    // old, deprecated implementation
    template <class DH>
    struct CallFixedSize< DH, true >
    {
      static bool fixedSize( const DH& dh, int dim, int codim )
      {
        return dh.overloaded_deprecated_fixedsize( dim, codim );
      }
    };
 
  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);
    }
 
    [[deprecated("fixedsize (lower case s) will be removed after release 2.8. Implement and call fixedSize (camelCase) instead!")]]
    int fixedsize (int dim, int codim) const
    {
      return int(fixedSize( dim, codim ));
    }
 
    // if this deprecation appears then the DataHandle implementation
    // is overloaded in the old 'fixedsize' method but not the new 'fixedSize'
    // method.
    [[deprecated("fixedsize (lower case s) will be removed after release 2.8. Implement and call fixedSize (camelCase) instead!")]]
    bool overloaded_deprecated_fixedsize( int dim, int codim ) const
    {
      return asImp().fixedsize( dim, codim );
    }
 
    bool fixedSize (int dim, int codim) const
    {
      // this should be enabled once the old fixedsize is removed
      //CHECK_INTERFACE_IMPLEMENTATION((asImp().fixedSize(dim,codim)));
      return CallFixedSize< DataHandleImp,
                            CheckFixedSizeMethod< DataHandleImp >::value >::fixedSize( asImp(), 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