H5Utils::WriterXd Class Reference

WriterXd. More...

#include <HdfTuple.h>

Collaboration diagram for H5Utils::WriterXd:

Public Member Functions
	WriterXd (H5::Group &group, const std::string &name, VariableFillers fillers, std::vector< hsize_t > dataset_dimensions, hsize_t chunk_size=2048)
	WriterXd (const WriterXd &)=delete
WriterXd &	operator= (WriterXd &)=delete
	~WriterXd ()
void	fillWhileIncrementing (std::vector< size_t > &indices)
void	flush ()
size_t	index () const

Private Member Functions
hsize_t	buffer_size () const

Private Attributes
H5::CompType	m_type
std::vector< hsize_t >	m_max_length
std::vector< hsize_t >	m_dim_stride
hsize_t	m_batch_size
hsize_t	m_offset
std::vector< internal::data_buffer_t >	m_buffer
VariableFillers	m_fillers
H5::DataSet	m_ds

Detailed Description

WriterXd.

Writer class

This is the other thing you interact with.

You'll have to specify the H5::Group to write the dataset to, the name of the new dataset, and the extent of the dataset.

To fill, use the fill_while_incrementing function, which will iterate over all possible values of indices within the dataset dimensions. The variable filler is called once for each index combination.

Definition at line 154 of file HdfTuple.h.

Constructor & Destructor Documentation

WriterXd() [1/2]

H5Utils::WriterXd::WriterXd	(	H5::Group &	group,
		const std::string &	name,
		VariableFillers	fillers,
		std::vector< hsize_t >	dataset_dimensions,
		hsize_t	chunk_size = 2048
	)

Definition at line 51 of file HdfTuple.cxx.

                                        :
    m_type(build_type(fillers)),
    m_max_length(max_length),
    m_dim_stride(max_length),
    m_batch_size(batch_size),
    m_offset(0),
    m_fillers(fillers)
  {
    if (batch_size < 1) {
      throw std::logic_error("batch size must be > 0");
    }
    // create space
    H5::DataSpace space = internal::getUnlimitedSpace(max_length);
 
    // create params
    H5::DSetCreatPropList params = getChunckedDatasetParams(
      max_length, batch_size);
 
    // calculate striding
    m_dim_stride = internal::getStriding(max_length);
 
    // create ds
    internal::throwIfExists(name, group);
    m_ds = group.createDataSet(name, internal::packed(m_type), space, params);
  }

WriterXd() [2/2]

H5Utils::WriterXd::WriterXd ( const WriterXd &  )

delete

~WriterXd()

H5Utils::WriterXd::~WriterXd

(

)

Definition at line 80 of file HdfTuple.cxx.

                      {
    try {
      flush();
    } catch (H5::Exception& err) {
      internal::printDestructorError(err.getDetailMsg());
    } catch (std::exception& err) {
      internal::printDestructorError(err.what());
    }
  }

Member Function Documentation

buffer_size()

hsize_t H5Utils::WriterXd::buffer_size ( ) const

private

Definition at line 144 of file HdfTuple.cxx.

                                      {
    size_t n_entries = m_buffer.size() / m_fillers.size();
    assert(n_entries % m_dim_stride.front() == 0);
    return n_entries / m_dim_stride.front();
  }

fillWhileIncrementing()

void H5Utils::WriterXd::fillWhileIncrementing

(

std::vector< size_t > &

indices

)

Definition at line 90 of file HdfTuple.cxx.

                                                                 {
    if (buffer_size() == m_batch_size) {
      flush();
    }
    indices.resize(m_max_length.size());
 
    // build buffer and _then_ insert it so that exceptions don't leave
    // the buffer in a weird state
    std::vector<internal::data_buffer_t> temp;
 
    std::fill(indices.begin(), indices.end(), 0);
    for (size_t gidx = 0; gidx < m_dim_stride.front(); gidx++) {
 
      // we might be able to make this more efficient and less cryptic
      for (size_t iii = 0; iii < indices.size(); iii++) {
        indices.at(iii) = (gidx % m_dim_stride.at(iii)) /
          m_dim_stride.at(iii+1);
      }
 
      for (const auto& filler: m_fillers) {
        temp.push_back(filler->get_buffer());
      }
    }
    m_buffer.insert(m_buffer.end(), temp.begin(), temp.end());
  }

flush()

void H5Utils::WriterXd::flush

(

)

Definition at line 115 of file HdfTuple.cxx.

                       {
    if (buffer_size() == 0) return;
    // extend the ds
    std::vector<hsize_t> slab_dims{buffer_size()};
    slab_dims.insert(slab_dims.end(), m_max_length.begin(), m_max_length.end());
    std::vector<hsize_t> total_dims{buffer_size() + m_offset};
    total_dims.insert(total_dims.end(), m_max_length.begin(), m_max_length.end());
    m_ds.extend(total_dims.data());
 
    // setup dataspaces
    H5::DataSpace file_space = m_ds.getSpace();
    H5::DataSpace mem_space(slab_dims.size(), slab_dims.data());
    std::vector<hsize_t> offset_dims{m_offset};
    offset_dims.resize(slab_dims.size(), 0);
    file_space.selectHyperslab(H5S_SELECT_SET,
                               slab_dims.data(), offset_dims.data());
 
    // write out
    assert(static_cast<size_t>(file_space.getSelectNpoints())
           == m_buffer.size() / m_fillers.size());
    m_ds.write(m_buffer.data(), m_type, mem_space, file_space);
    m_offset += buffer_size();
    m_buffer.clear();
  }

index()

size_t H5Utils::WriterXd::index

(

)

const

Definition at line 140 of file HdfTuple.cxx.

                               {
    return m_offset + buffer_size();
  }

operator=()

WriterXd& H5Utils::WriterXd::operator= ( WriterXd &  )

delete

Member Data Documentation

m_batch_size

hsize_t H5Utils::WriterXd::m_batch_size

private

Definition at line 172 of file HdfTuple.h.

m_buffer

std::vector<internal::data_buffer_t> H5Utils::WriterXd::m_buffer

private

Definition at line 174 of file HdfTuple.h.

m_dim_stride

std::vector<hsize_t> H5Utils::WriterXd::m_dim_stride

private

Definition at line 171 of file HdfTuple.h.

m_ds

H5::DataSet H5Utils::WriterXd::m_ds

private

Definition at line 176 of file HdfTuple.h.

m_fillers

VariableFillers H5Utils::WriterXd::m_fillers

private

Definition at line 175 of file HdfTuple.h.

m_max_length

std::vector<hsize_t> H5Utils::WriterXd::m_max_length

private

Definition at line 170 of file HdfTuple.h.

m_offset

hsize_t H5Utils::WriterXd::m_offset

private

Definition at line 173 of file HdfTuple.h.

m_type

H5::CompType H5Utils::WriterXd::m_type

private

Definition at line 169 of file HdfTuple.h.

---

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

• HdfTuple.h
• HdfTuple.cxx