TPEF::TPEFUDataSectionWriter Class Reference

#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.
TPEFUDataSectionWriter	operator= (const TPEFUDataSectionWriter &)
	Assignment not allowed.

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

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.

                                                {
}

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:

• TPEFUDataSectionWriter.hh
• TPEFUDataSectionWriter.cc