dune::MilliSliceWriter Class Reference

#include <MilliSliceWriter.hh>

Inheritance diagram for dune::MilliSliceWriter:

Public Member Functions
	MilliSliceWriter (uint8_t *address, uint32_t max_size_bytes)
std::shared_ptr< MicroSliceWriter >	reserveMicroSlice (uint32_t ms_max_bytes)
int32_t	finalize ()
Public Member Functions inherited from dune::MilliSlice
	MilliSlice (uint8_t *address)
Header::millislice_size_t	size () const
Header::microslice_count_t	microSliceCount () const
std::unique_ptr< MicroSlice >	microSlice (uint32_t index) const

Protected Member Functions
void	finalizeLatestMicroSlice_ ()
Header *	header_ ()
uint8_t *	data_ (int index)
Protected Member Functions inherited from dune::MilliSlice
Header const *	header_ () const
uint8_t *	data_ (int index) const

Protected Attributes
uint32_t	max_size_bytes_
std::shared_ptr< MicroSliceWriter >	latest_microslice_ptr_
Protected Attributes inherited from dune::MilliSlice
uint8_t *	buffer_

Detailed Description

Definition at line 11 of file MilliSliceWriter.hh.

Constructor & Destructor Documentation

dune::MilliSliceWriter::MilliSliceWriter	(	uint8_t *	address,
		uint32_t	max_size_bytes
	)

Definition at line 5 of file MilliSliceWriter.cc.

                                                            :
    MilliSlice(address), max_size_bytes_(max_size_bytes)
{
  header_()->version = 1;
  header_()->millislice_size = sizeof(Header);
  header_()->microslice_count = 0;
}

Member Function Documentation

uint8_t * dune::MilliSliceWriter::data_ ( int  index )

protected

Definition at line 61 of file MilliSliceWriter.cc.

{
  uint8_t* ms_ptr = buffer_ + sizeof(Header);
  for (int idx = 0; idx < index; ++idx) {
    MicroSlice tmp_ms(ms_ptr);
    ms_ptr += tmp_ms.size();
  }
  return ms_ptr;
}

int32_t dune::MilliSliceWriter::finalize

(

)

Definition at line 34 of file MilliSliceWriter.cc.

{
  // first, we need to finalize the last MicroSlice, in case that
  // hasn't already been done
  finalizeLatestMicroSlice_();

  // next, we update our maximum size so that no more MicroSlices
  // can be added
  int32_t size_diff = max_size_bytes_ - header_()->millislice_size;
  max_size_bytes_ = header_()->millislice_size;
  return size_diff;
}

void dune::MilliSliceWriter::finalizeLatestMicroSlice_ ( )

protected

Definition at line 47 of file MilliSliceWriter.cc.

{
  if (header_()->microslice_count > 0 &&
      latest_microslice_ptr_.get() != 0) {
    int size_change = latest_microslice_ptr_->finalize();
    header_()->millislice_size -= size_change;
  }
}

dune::MilliSliceWriter::Header * dune::MilliSliceWriter::header_ ( )

protected

Definition at line 56 of file MilliSliceWriter.cc.

{
  return reinterpret_cast<Header *>(buffer_);
}

std::shared_ptr< dune::MicroSliceWriter > dune::MilliSliceWriter::reserveMicroSlice

(

uint32_t

ms_max_bytes

)

Definition at line 14 of file MilliSliceWriter.cc.

{
  // finalize the most recent MicroSlice, in case that hasn't
  // already been done
  finalizeLatestMicroSlice_();

  // test if this new MicroSlice could overflow our maximum size
  if ((size() + ms_max_bytes) > max_size_bytes_) {
    throw cet::exception("MilliSliceWriter") << "Slice overflow error";
  }

  // create the next MicroSlice in our buffer, and update our
  // counters to include the new MicroSlice
  uint8_t* ms_ptr = data_(header_()->microslice_count);
  latest_microslice_ptr_.reset(new MicroSliceWriter(ms_ptr, ms_max_bytes));
  ++(header_()->microslice_count);
  header_()->millislice_size += ms_max_bytes;
  return latest_microslice_ptr_;
}

Member Data Documentation

std::shared_ptr<MicroSliceWriter> dune::MilliSliceWriter::latest_microslice_ptr_

protected

Definition at line 50 of file MilliSliceWriter.hh.

uint32_t dune::MilliSliceWriter::max_size_bytes_

protected

Definition at line 49 of file MilliSliceWriter.hh.

---

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

• dune-raw-data/dune-raw-data/Overlays/MilliSliceWriter.hh
• dune-raw-data/dune-raw-data/Overlays/MilliSliceWriter.cc