#include <MilliSliceFragmentWriter.hh>

Inheritance diagram for dune::MilliSliceFragmentWriter:

Public Member Functions
	MilliSliceFragmentWriter (artdaq::Fragment &frag, uint32_t max_size_bytes)

std::shared_ptr< MicroSliceWriter >	reserveMicroSlice (uint32_t ms_max_bytes)

int32_t	finalize ()

Public Member Functions inherited from dune::MilliSliceFragment
	MilliSliceFragment (artdaq::Fragment const &frag)

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::MilliSliceFragment
Header const *	header_ () const

uint8_t *	data_ (int index) const

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_

Private Attributes
artdaq::Fragment &	artdaq_fragment_

Detailed Description

Definition at line 11 of file MilliSliceFragmentWriter.hh.

Constructor & Destructor Documentation

dune::MilliSliceFragmentWriter::MilliSliceFragmentWriter	(	artdaq::Fragment &	frag,
		uint32_t	max_size_bytes
	)

Definition at line 5 of file MilliSliceFragmentWriter.cc.

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

Member Function Documentation

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

protected

Definition at line 61 of file MilliSliceFragmentWriter.cc.

 {
   uint8_t* ms_ptr = reinterpret_cast<uint8_t *>(artdaq_fragment_.dataBeginBytes())
     + 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::MilliSliceFragmentWriter::finalize ( )

Definition at line 34 of file MilliSliceFragmentWriter.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::MilliSliceFragmentWriter::finalizeLatestMicroSlice_ ( )

protected

Definition at line 47 of file MilliSliceFragmentWriter.cc.

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

dune::MilliSliceFragmentWriter::Header * dune::MilliSliceFragmentWriter::header_ ( )

protected

Definition at line 56 of file MilliSliceFragmentWriter.cc.

 {
   return reinterpret_cast<Header *>(artdaq_fragment_.dataBeginBytes());
 }

std::shared_ptr< dune::MicroSliceWriter > dune::MilliSliceFragmentWriter::reserveMicroSlice ( uint32_t ms_max_bytes )

Definition at line 14 of file MilliSliceFragmentWriter.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("MicroSliceWriter") << "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_;
 }