#include <TPEFUDataSectionWriter.hh>

Inheritance diagram for TPEF::TPEFUDataSectionWriter:

Collaboration diagram for TPEF::TPEFUDataSectionWriter:

Protected Member Functions
	TPEFUDataSectionWriter ()

virtual	~TPEFUDataSectionWriter ()

virtual Section::SectionType	type () const

virtual void	createKeys (const Section *sect) const

virtual Word	elementSize (const Section *section) const

virtual void	writeSize (BinaryStream &stream, const Section *sect) const

Protected Member Functions inherited from TPEF::TPEFSectionWriter
	TPEFSectionWriter ()

virtual	~TPEFSectionWriter ()

virtual const BinaryWriter &	parent () const

virtual void	actualWriteHeader (BinaryStream &stream, const Section *sect) const

virtual void	actualWriteData (BinaryStream &stream, const Section *sect) const

virtual void	writeInfo (BinaryStream &stream, const Section *sect) const

virtual SectionId	getSectionId () const

Protected Member Functions inherited from TPEF::SectionWriter
	SectionWriter ()

virtual	~SectionWriter ()

virtual void	finalize (BinaryStream &stream, Section *section) const

Private Member Functions
	TPEFUDataSectionWriter (const TPEFUDataSectionWriter &)
	Copying not allowed. More...

TPEFUDataSectionWriter	operator= (const TPEFUDataSectionWriter &)
	Assignment not allowed. More...

Static Private Attributes
static const TPEFUDataSectionWriter	instance_
	Unique instance of a class. More...

Additional Inherited Members
Static Public Member Functions inherited from TPEF::SectionWriter
static void	writeHeader (BinaryStream &stream, const Section sect, const BinaryWriter writer)

static void	writeData (BinaryStream &stream, const Section sect, const BinaryWriter writer)

static void	finalizeBinary (BinaryStream &stream, const Binary binaryToFinalize, const BinaryWriter writer)

Static Protected Member Functions inherited from TPEF::SectionWriter
static void	registerSectionWriter (const SectionWriter *sWriter)

static SectionId	getUniqueSectionId ()

Detailed Description

Writes unitialized data section in to stream.

Actually implements only needed fall through methods for setting element size and section size to section header and for creating section offset keys for referred data chunks.

Definition at line 50 of file TPEFUDataSectionWriter.hh.

Constructor & Destructor Documentation

◆ TPEFUDataSectionWriter() [1/2]

TPEF::TPEFUDataSectionWriter::TPEFUDataSectionWriter ( )

protected

Constructor.

Registers itself to SectionWriter.

Definition at line 60 of file TPEFUDataSectionWriter.cc.

                                                : TPEFSectionWriter() {
     registerSectionWriter(this);
 }

References TPEF::SectionWriter::registerSectionWriter().

Here is the call graph for this function:

◆ ~TPEFUDataSectionWriter()

TPEF::TPEFUDataSectionWriter::~TPEFUDataSectionWriter ( )

protectedvirtual

Destructor.

Definition at line 67 of file TPEFUDataSectionWriter.cc.

67 {

68 }

◆ TPEFUDataSectionWriter() [2/2]

TPEF::TPEFUDataSectionWriter::TPEFUDataSectionWriter ( const TPEFUDataSectionWriter & )

private

Copying not allowed.

Member Function Documentation

◆ createKeys()

void TPEF::TPEFUDataSectionWriter::createKeys ( const Section * sect ) const

protectedvirtual

Creates keys to make able to reference UData chunks with section offsets.

Parameters

sect	Section which for keys will be created.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 115 of file TPEFUDataSectionWriter.cc.

                                                             {
     const UDataSection* uDSection = dynamic_cast<const UDataSection*>(sect);
  
     assert(uDSection != NULL);
  
     SectionOffset sectOffset = 0;
     SectionKey sKey = SafePointer::sectionKeyFor(uDSection);
     SectionId id = sKey.sectionId();
  
     // key for first element is always set
     Chunk* chunk = uDSection->chunk(0);
  
     SafePointer::addObjectReference(
         SectionOffsetKey(id, sectOffset), chunk);
  
     // go through requested chunks..
     for (unsigned int i = 0; i < uDSection->referredChunkCount(); i++) {
         try {
             chunk = uDSection->referredChunk(i);
         } catch (const NotChunkable& n) {
             bool sectionToWriteIsNotChunkable = false;
             assert(sectionToWriteIsNotChunkable);
         }
  
         sectOffset = chunk->offset();
  
         // add section offset to element if really referenced element
         if (SafePointer::isReferenced(chunk) && sectOffset != 0) {
             SafePointer::addObjectReference(
                 SectionOffsetKey(id, sectOffset), chunk);
         }
     }
 }

References TPEF::ReferenceManager::SafePointer::addObjectReference(), assert, TPEF::RawSection::chunk(), TPEF::ReferenceManager::SafePointer::isReferenced(), TPEF::Chunk::offset(), TPEF::RawSection::referredChunk(), TPEF::RawSection::referredChunkCount(), TPEF::ReferenceManager::SectionKey::sectionId(), and TPEF::ReferenceManager::SafePointer::sectionKeyFor().

Here is the call graph for this function:

◆ elementSize()

Word TPEF::TPEFUDataSectionWriter::elementSize ( const Section * section ) const

protectedvirtual

Returns the fixed size of section elements in bytes.

Size of element depends on address space of section.

Parameters

section Section which is written.

Returns: Size of uninitialized data element in bytes.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 89 of file TPEFUDataSectionWriter.cc.

                                                                 {
     return static_cast<Word>(
         ceil(static_cast<double>(section->aSpace()->MAU()) /
              BYTE_BITWIDTH));
 }

References TPEF::Section::aSpace(), BYTE_BITWIDTH, and TPEF::ASpaceElement::MAU().

Here is the call graph for this function:

◆ operator=()

TPEFUDataSectionWriter TPEF::TPEFUDataSectionWriter::operator= ( const TPEFUDataSectionWriter & )

private

Assignment not allowed.

◆ type()

Section::SectionType TPEF::TPEFUDataSectionWriter::type ( ) const

protectedvirtual

Returns the type of section, that writer can write.

Returns: The type of the section, that writer can write.

Implements TPEF::TPEFSectionWriter.

Definition at line 76 of file TPEFUDataSectionWriter.cc.

                                    {
     return Section::ST_UDATA;
 }

References TPEF::Section::ST_UDATA.

◆ writeSize()

void TPEF::TPEFUDataSectionWriter::writeSize	(	BinaryStream &	stream,
		const Section *	sect
	)		const

protectedvirtual

Writes section's size into stream.

Parameters

stream	Stream to write.
sect	Section which size to write.

Reimplemented from TPEF::TPEFSectionWriter.

Definition at line 102 of file TPEFUDataSectionWriter.cc.

                                                              {
  
     const UDataSection* uSect = dynamic_cast<const UDataSection*>(sect);
     stream.writeWord(uSect->length());
 }

References TPEF::RawSection::length(), and TPEF::BinaryStream::writeWord().

Here is the call graph for this function:

Member Data Documentation

◆ instance_

const TPEFUDataSectionWriter TPEF::TPEFUDataSectionWriter::instance_

staticprivate

Unique instance of a class.

Definition at line 70 of file TPEFUDataSectionWriter.hh.

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

Protected Member Functions

Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ TPEFUDataSectionWriter() [1/2]

◆ ~TPEFUDataSectionWriter()

◆ TPEFUDataSectionWriter() [2/2]

Member Function Documentation

◆ createKeys()

◆ elementSize()

◆ operator=()

◆ type()

◆ writeSize()

Member Data Documentation

◆ instance_