libMesh::Parallel::PackingRange< Container > Class Template Reference

#include <packing.h>

Public Types
typedef DefaultBufferType< typenameContainer::value_type >::type	buffer_type
typedef PackingMixedType< buffer_type >	Mixed

Static Public Member Functions
template<typename OutputIter , typename Context >
static void	pack (const Container &a, OutputIter data_out, const Context *context)
template<typename Context >
static unsigned int	packable_size (const Container &a, const Context *context)
template<typename BufferIter >
static unsigned int	packed_size (BufferIter iter)
template<typename BufferIter , typename Context >
static Container	unpack (BufferIter in, Context *ctx)

Detailed Description

template<typename Container>
class libMesh::Parallel::PackingRange< Container >

Definition at line 800 of file packing.h.

Member Typedef Documentation

buffer_type

template<typename Container >

typedef DefaultBufferType<typenameContainer::value_type>::type libMesh::Parallel::PackingRange< Container >::buffer_type

Definition at line 805 of file packing.h.

Mixed

template<typename Container >

typedef PackingMixedType<buffer_type> libMesh::Parallel::PackingRange< Container >::Mixed

Definition at line 807 of file packing.h.

Member Function Documentation

pack()

template<typename Container >

template<typename OutputIter , typename Context >

void libMesh::Parallel::PackingRange< Container >::pack ( const Container &  a, OutputIter  data_out, const Context *  context  )

static

Definition at line 848 of file packing.h.

{
  unsigned int size = packable_size(c, ctx);
 
  // First write out info about the buffer size
  put_packed_len<buffer_type>(size, data_out);
 
  // Now pack the data
  for (const auto & entry : c)
    Mixed::pack_comp(entry, data_out, ctx);
}

packable_size()

template<typename Container >

template<typename Context >

unsigned int libMesh::Parallel::PackingRange< Container >::packable_size ( const Container &  a, const Context *  context  )

static

Definition at line 828 of file packing.h.

{
  unsigned int returnval = get_packed_len_entries<buffer_type>(); // size
  for (const auto & entry : c)
    returnval += Mixed::packable_size_comp(entry, ctx);
  return returnval;
}

packed_size()

template<typename Container >

template<typename BufferIter >

unsigned int libMesh::Parallel::PackingRange< Container >::packed_size ( BufferIter  iter )

static

Definition at line 839 of file packing.h.

{
  // We recorded the size in the first buffer entries
  return get_packed_len<buffer_type>(iter);
}

unpack()

template<typename Container >

template<typename BufferIter , typename Context >

Container libMesh::Parallel::PackingRange< Container >::unpack ( BufferIter  in, Context *  ctx  )

static

Definition at line 863 of file packing.h.

{
  Container c;
 
  unsigned int size = packed_size(in);
 
  timpi_assert_greater(size, 0);
 
  // Get the total size
  constexpr int size_bytes = get_packed_len_entries<buffer_type>();
  in += size_bytes;
  size -= size_bytes;
 
  // Unpack the data
  std::size_t unpacked_size = 0;
  while (unpacked_size < size)
    {
      typename DefaultValueType<typename Container::value_type>::type entry;
      Mixed::unpack_comp(entry, in, ctx);
 
      c.insert(c.end(), entry);
 
      // Make sure we increment the iterator
      const std::size_t unpacked_size_comp =
        Mixed::packable_size_comp(entry, ctx);
      in += unpacked_size_comp;
      unpacked_size += unpacked_size_comp;
    }
 
  // We should always finish at exactly the size we expected, not
  // proceed past it
  timpi_assert_equal_to(unpacked_size, size);
 
  return c;
}

---

The documentation for this class was generated from the following file:

• src/parallel/include/timpi/packing.h