packing_decl.h

Go to the documentation of this file.

// The TIMPI Message-Passing Parallelism Library.
// Copyright (C) 2002-2025 Benjamin S. Kirk, John W. Peterson, Roy H. Stogner
 
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
 
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
 
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 
#ifndef TIMPI_PACKING_DECL_H
#define TIMPI_PACKING_DECL_H
 
// TIMPI Includes
#include "timpi/packing_forward.h"
#include "timpi/standard_type.h"
 
// C++ includes
#include <array>
#include <list>
#include <map>
#include <set>
#include <tuple>
#include <type_traits> // enable_if
#include <unordered_map>
#include <unordered_set>
#include <utility>     // pair
#include <vector>
 
 
// FIXME: This *should* be in TIMPI namespace but we have libMesh
// users which already partially specialized it
namespace libMesh
{
 
namespace Parallel
{
 
template <typename T, typename Enable>
class Packing;
 
// Idiom taken from https://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Member_Detector
//
// We need this in _decl because we're using it for SFINAE in
// template declarations
template <typename T>
class Has_buffer_type
{
  using Yes = char[2];
  using No = char[1];
 
  struct Fallback {
    struct buffer_type {};
  };
  struct Derived : T, Fallback {};
 
  template <typename U> static Yes &test(U *);
 
  // this template must be more specialized in general than the Yes version because it involves a
  // type-dependent expression...?
  template <typename U> static No &test(typename U::buffer_type *);
 
public:
  static constexpr bool value = sizeof(test<Derived>(nullptr)) == sizeof(Yes);
};
 
 
// specialization for std::pair
template <typename T1, typename T2>
struct PairHasPacking
{
  typedef typename std::remove_const<T1>::type cT1;
 
  static const bool value =
    !TIMPI::StandardType<std::pair<cT1, T2>>::is_fixed_type &&
    (Has_buffer_type<Packing<cT1>>::value ||
     TIMPI::StandardType<cT1>::is_fixed_type) &&
    (Has_buffer_type<Packing<T2>>::value ||
     TIMPI::StandardType<T2>::is_fixed_type);
};
 
 
template <typename T1, typename T2>
class Packing<std::pair<T1, T2>,
              typename std::enable_if<PairHasPacking<T1,T2>::value>::type>;
 
 
// specializations for std::tuple
 
template <typename... Types>
struct TupleHasPacking;
 
template <>
struct TupleHasPacking<>
{
  static const bool value = true;
};
 
template <typename T, typename... Types>
struct TupleHasPacking<T, Types...>
{
  static const bool value =
    !TIMPI::StandardType<std::tuple<T, Types...>>::is_fixed_type &&
    (Has_buffer_type<Packing<T>>::value ||
     TIMPI::StandardType<T>::is_fixed_type) &&
    (TupleHasPacking<Types...>::value ||
     TIMPI::StandardType<std::tuple<Types...>>::is_fixed_type);
};
 
 
template <typename Enable>
class Packing<std::tuple<>, Enable>;
 
template <typename T, typename... Types>
class Packing<std::tuple<T, Types...>,
              typename std::enable_if<TupleHasPacking<T, Types...>::value>::type>;
 
 
// specialization for std::array
template <typename T, std::size_t N>
class Packing<std::array<T, N>,
              typename std::enable_if<Has_buffer_type<Packing<T>>::value>::type>;
 
 
// helper class for any homogeneous-type variable-size containers
// which define the usual iterator ranges, value_type, etc.
template <typename Container>
class PackingRange;
 
 
#define TIMPI_DECL_PACKING_RANGE_SUBCLASS(Container) \
class Packing<Container,                             \
              typename std::enable_if<Has_buffer_type<Packing<typename Container::value_type>>::value || \
                                      TIMPI::StandardType<typename Container::value_type>::is_fixed_type>::type>
 
#define TIMPI_P_COMMA ,
 
template <typename T, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::vector<T TIMPI_P_COMMA A>);
 
template <typename T, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::list<T TIMPI_P_COMMA A>);
 
template <typename K, typename T, typename C, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::map<K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A>);
 
template <typename K, typename T, typename C, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::multimap<K TIMPI_P_COMMA T TIMPI_P_COMMA C TIMPI_P_COMMA A>);
 
template <typename K, typename C, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::multiset<K TIMPI_P_COMMA C TIMPI_P_COMMA A>);
 
template <typename K, typename C, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::set<K TIMPI_P_COMMA C TIMPI_P_COMMA A>);
 
template <typename K, typename T, typename H, typename KE, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::unordered_map<K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A>);
 
template <typename K, typename T, typename H, typename KE, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::unordered_multimap<K TIMPI_P_COMMA T TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A>);
 
template <typename K, typename H, typename KE, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::unordered_multiset<K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A>);
 
template <typename K, typename H, typename KE, typename A>
TIMPI_DECL_PACKING_RANGE_SUBCLASS(std::unordered_set<K TIMPI_P_COMMA H TIMPI_P_COMMA KE TIMPI_P_COMMA A>);
 
 
 
#define TIMPI_HAVE_STRING_PACKING
 
template <typename T>
class Packing<std::basic_string<T>,
              typename std::enable_if<TIMPI::StandardType<T>::is_fixed_type>::type>;
 
} // namespace Parallel
 
} // namespace libMesh
 
 
namespace TIMPI {
 
using libMesh::Parallel::Packing;
 
template <typename Context, typename buffertype,
          typename OutputIter, typename T>
inline OutputIter unpack_range (const typename std::vector<buffertype> & buffer,
                                Context * context,
                                OutputIter out_iter,
                                const T * output_type /* used only to infer T */);
 
template <typename Context, typename buffertype, typename Iter>
inline Iter pack_range (const Context * context,
                        Iter range_begin,
                        const Iter range_end,
                        typename std::vector<buffertype> & buffer,
                        std::size_t approx_buffer_size = 1000000);
 
template <typename Context, typename Iter>
inline std::size_t packed_range_size (const Context * context,
                                      Iter range_begin,
                                      const Iter range_end);
 
} // namespace TIMPI
 
#endif // TIMPI_PACKING_H