This class represents data with an ordered list of consecutive chunks. More...

#include <SequenceChunk.h>

Inheritance diagram for inet::SequenceChunk:

Public Member Functions
Constructors, destructors and duplication related functions
	SequenceChunk ()

	SequenceChunk (const SequenceChunk &other)

	SequenceChunk (const std::deque< Ptr< const Chunk >> &chunks)

virtual SequenceChunk *	dup () const override

virtual const Ptr< Chunk >	dupShared () const override
	Returns a mutable copy of this chunk in a shared pointer. More...

virtual void	parsimPack (cCommBuffer *buffer) const override

virtual void	parsimUnpack (cCommBuffer *buffer) override

virtual void	forEachChild (cVisitor *v) override

virtual bool	containsSameData (const Chunk &other) const override
	Returns true if the two chunks represent the same binary data. More...

Field accessor functions
const std::deque< Ptr< const Chunk > > &	getChunks () const

void	setChunks (const std::deque< Ptr< const Chunk >> &chunks)

Overridden flag functions
virtual bool	isComplete () const override

virtual bool	isIncomplete () const override

virtual bool	isCorrect () const override

virtual bool	isIncorrect () const override

virtual bool	isProperlyRepresented () const override

virtual bool	isImproperlyRepresented () const override

Iteration related functions
virtual void	moveIterator (Iterator &iterator, b length) const override

virtual void	seekIterator (Iterator &iterator, b offset) const override

Filling with data related functions
virtual bool	canInsertAtFront (const Ptr< const Chunk > &chunk) const override
	Returns true if this chunk is capable of representing the result. More...

virtual bool	canInsertAtBack (const Ptr< const Chunk > &chunk) const override
	Returns true if this chunk is capable of representing the result. More...

Removing data related functions
virtual bool	canRemoveAtFront (b length) const override
	Returns true if this chunk is capable of representing the result. More...

virtual bool	canRemoveAtBack (b length) const override
	Returns true if this chunk is capable of representing the result. More...

Querying data related functions
virtual ChunkType	getChunkType () const override
	Returns the type of this chunk as an enum member. More...

virtual b	getChunkLength () const override
	Returns the length of data represented by this chunk. More...

virtual bool	isEmpty () const override
	Returns true if this chunk contains no data. More...

virtual std::ostream &	printToStream (std::ostream &stream, int level, int evFlags=0) const override
	Prints an optinally formatted human readable string representation of the data present in this chunk to the given stream. More...

Public Member Functions inherited from inet::Chunk
	Chunk ()

	Chunk (const Chunk &other)

virtual bool	isMutable () const

virtual bool	isImmutable () const

virtual void	markImmutable ()

void	markMutableIfExclusivelyOwned ()

virtual void	markIncomplete ()

virtual void	markIncorrect ()

virtual void	markImproperlyRepresented ()

virtual bool	canInsertAt (const Ptr< const Chunk > &chunk, b offset) const
	Returns true if this chunk is capable of representing the result. More...

void	insertAtFront (const Ptr< const Chunk > &chunk)
	Inserts the provided chunk at the beginning of this chunk. More...

void	insertAtBack (const Ptr< const Chunk > &chunk)
	Inserts the provided chunk at the end of this chunk. More...

void	insertAt (const Ptr< const Chunk > &chunk, b offset)
	Inserts the provided chunk into this chunk. More...

virtual bool	canRemoveAt (b offset, b length) const
	Returns true if this chunk is capable of representing the result. More...

void	removeAtFront (b length)
	Removes the requested part from the beginning of this chunk. More...

void	removeAtBack (b length)
	Removes the requested part from the end of this chunk. More...

void	removeAt (b offset, b length)
	Removes the requested part from this chunk. More...

int	getChunkId () const
	Returns the sequentially assigned id. More...

const Ptr< Chunk >	simplify () const
	Returns the simplified representation of this chunk eliminating all potential redundancies. More...

const Ptr< Chunk >	peek (const Iterator &iterator, b length=unspecifiedLength, int flags=0) const
	Returns the designated part of the data represented by this chunk in its default representation. More...

template<typename T >
bool	has (const Iterator &iterator, b length=unspecifiedLength) const
	Returns whether if the designated part of the data is available in the requested representation. More...

template<typename T >
const Ptr< T >	peek (const Iterator &iterator, b length=unspecifiedLength, int flags=0) const
	Returns the designated part of the data represented by this chunk in the requested representation. More...

virtual SharingRegionTagSet &	getRegionTags () override
	Returns all region tags. More...

int	getNumTags () const
	Returns the number of chunk tags. More...

const Ptr< const TagBase >	getTag (int index) const
	Returns the chunk tag at the given index. More...

void	clearTags (b offset=b(0), b length=b(-1))
	Clears the set of chunk tags in the given region. More...

void	copyTags (const Chunk &source, b sourceOffset=b(0), b offset=b(0), b length=b(-1))
	Copies the set of chunk tags from the source region to the provided region. More...

template<typename T >
const Ptr< const T >	findTag (b offset=b(0), b length=b(-1)) const
	Returns the chunk tag for the provided type and range, or returns nullptr if no such chunk tag is found. More...

template<typename T >
const Ptr< const T >	getTag (b offset=b(0), b length=b(-1)) const
	Returns the chunk tag for the provided type and range, or throws an exception if no such chunk tag is found. More...

template<typename T >
void	mapAllTags (b offset, b length, std::function< void(b, b, const Ptr< const T > &)> f) const
	Maps all tags in the provided range to to the function. More...

template<typename T >
void	mapAllTagsForUpdate (b offset, b length, std::function< void(b, b, const Ptr< T > &)> f)
	Maps all tags in the provided range to to the function. More...

template<typename T >
std::vector< SharingRegionTagSet::RegionTag< const T > >	getAllTags (b offset=b(0), b length=b(-1)) const
	Returns all chunk tags for the provided type and range in a detached vector of region tags. More...

template<typename T >
std::vector< SharingRegionTagSet::RegionTag< T > >	getAllTagsForUpdate (b offset=b(0), b length=b(-1))
	Returns all chunk tags for the provided type and range in a detached vector of region tags. More...

template<typename T >
const Ptr< T >	addTag (b offset=b(0), b length=b(-1))
	Returns a newly added chunk tag for the provided type and range, or throws an exception if such a chunk tag is already present. More...

template<typename T >
const Ptr< T >	addTagIfAbsent (b offset=b(0), b length=b(-1))
	Returns a newly added chunk tag for the provided type and range if absent, or returns the chunk tag that is already present. More...

template<typename T >
std::vector< SharingRegionTagSet::RegionTag< T > >	addTagsWhereAbsent (b offset=b(0), b length=b(-1))
	Returns the newly added chunk tags for the provided type and range where the tag is absent. More...

template<typename T >
const Ptr< T >	removeTag (b offset, b length)
	Removes the chunk tag for the provided type and range, or throws an exception if no such chunk tag is found. More...

template<typename T >
const Ptr< T >	removeTagIfPresent (b offset, b length)
	Removes the chunk tag for the provided type and range if present, or returns nullptr if no such chunk tag is found. More...

template<typename T >
std::vector< SharingRegionTagSet::RegionTag< T > >	removeTagsWherePresent (b offset, b length)
	Removes and returns all chunk tags for the provided type and range. More...

virtual std::ostream &	printFieldsToStream (std::ostream &stream, int level, int evFlags=0) const
	Prints an optinally formatted human readable string representation of the feilds of this chunk to the given stream. More...

virtual std::string	str () const override
	Returns a human readable string representation of the data present in this chunk. More...

Public Member Functions inherited from inet::IPrintableObject
virtual	~IPrintableObject ()

virtual std::string	printToString () const

virtual std::string	printToString (int level, int evFlags=0) const

virtual std::string	getInfoStringRepresentation (int evFlags=0) const

virtual std::string	getDetailStringRepresentation (int evFlags=0) const

virtual std::string	getDebugStringRepresentation (int evFlags=0) const

virtual std::string	getTraceStringRepresentation (int evFlags=0) const

virtual std::string	getCompleteStringRepresentation (int evFlags=0) const

Protected Member Functions
int	getNumChunks () const

const Chunk *	getChunk (int i) const

int	getElementIndex (bool isForward, int index) const

const Ptr< const Chunk > &	getElementChunk (const Iterator &iterator) const

void	doInsertChunkAtFront (const Ptr< const Chunk > &chunk)

void	doInsertSliceChunkAtFront (const Ptr< const SliceChunk > &chunk)

void	doInsertSequenceChunkAtFront (const Ptr< const SequenceChunk > &chunk)

void	doInsertChunkAtBack (const Ptr< const Chunk > &chunk)

void	doInsertSliceChunkAtBack (const Ptr< const SliceChunk > &chunk)

void	doInsertSequenceChunkAtBack (const Ptr< const SequenceChunk > &chunk)

std::deque< Ptr< const Chunk > >	dupChunks () const

virtual const Ptr< Chunk >	peekUnchecked (PeekPredicate predicate, PeekConverter converter, const Iterator &iterator, b length, int flags) const override

virtual void	doInsertAtFront (const Ptr< const Chunk > &chunk) override

virtual void	doInsertAtBack (const Ptr< const Chunk > &chunk) override

virtual void	doRemoveAtFront (b length) override

virtual void	doRemoveAtBack (b length) override

Protected Member Functions inherited from inet::Chunk
int	getBinDumpNumLines () const

int	getHexDumpNumLines () const

const char *	getBinDumpLine (int index)

const char *	getHexDumpLine (int index)

const SharingRegionTagSet::RegionTag< TagBase > &	_getTag (int index) const

void	checkMutable () const

virtual void	handleChange ()

virtual void	doInsertAt (const Ptr< const Chunk > &chunk, b offset)

virtual void	doRemoveAt (b offset, b length)

template<typename T >
const Ptr< T >	peekConverted (const Iterator &iterator, b length, int flags) const

template<typename T >
const Ptr< T >	checkPeekResult (const Ptr< T > &chunk, int flags) const

Static Protected Member Functions
static const Ptr< Chunk >	convertChunk (const std::type_info &typeInfo, const Ptr< Chunk > &chunk, b offset, b length, int flags)

Static Protected Member Functions inherited from inet::Chunk
static const Ptr< Chunk >	convertChunk (const std::type_info &typeInfo, const Ptr< Chunk > &chunk, b offset, b length, int flags)
	Creates a new chunk of the given type that represents the designated part of the provided chunk. More...

Protected Attributes
std::deque< Ptr< const Chunk > >	chunks
	The list of chunks that make up this chunk. More...

Protected Attributes inherited from inet::Chunk
int	id
	The id is automatically assigned sequentially during construction. More...

int	flags
	The boolean chunk flags are merged into a single integer. More...

SharingRegionTagSet	regionTags
	The set of region tags attached to the data represented by this chunk. More...

const typedef Ptr< Chunk >(*	PeekConverter )(const Ptr< Chunk > &chunk, const Chunk::Iterator &iterator, b length, int flags)

Friends
class	Chunk

class	SequenceChunkDescriptor

Additional Inherited Members
Public Types inherited from inet::Chunk
enum	ChunkType { CT_EMPTY, CT_BITCOUNT, CT_BITS, CT_BYTECOUNT, CT_BYTES, CT_SLICE, CT_ENCRYPTED, CT_CPACKET, CT_SEQUENCE, CT_FIELDS }
	This enum is used to avoid std::dynamic_cast and dynamicPtrCast. More...

enum	PeekFlag { PF_ALLOW_NULLPTR = (1 << 0), PF_ALLOW_EMPTY = (1 << 1), PF_ALLOW_INCOMPLETE = (1 << 2), PF_ALLOW_INCORRECT = (1 << 3), PF_ALLOW_IMPROPERLY_REPRESENTED = (1 << 4), PF_ALLOW_SERIALIZATION = (1 << 5), PF_ALLOW_ALL = -1 }
	This enum specifies bitmasks for the flags argument of various peek functions. More...

Public Types inherited from inet::IPrintableObject
enum	PrintLevel { PRINT_LEVEL_TRACE, PRINT_LEVEL_DEBUG, PRINT_LEVEL_DETAIL, PRINT_LEVEL_INFO, PRINT_LEVEL_COMPLETE = INT_MIN }

enum	PrintFlag { PRINT_FLAG_FORMATTED = (1 << 0), PRINT_FLAG_MULTILINE = (1 << 1) }

Static Public Member Functions inherited from inet::Chunk
static void	serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk, b offset=b(0), b length=b(-1))
	Serializes a chunk into the given stream. More...

static const Ptr< Chunk >	deserialize (MemoryInputStream &stream, const std::type_info &typeInfo)
	Deserializes a chunk from the given stream. More...

Static Public Attributes inherited from inet::Chunk
static const b	unspecifiedLength = b(-std::numeric_limits<int64_t>::max())

static bool	enableImplicitChunkSerialization = false
	Peeking some part into a chunk that requires automatic serialization will throw an exception when implicit chunk serialization is disabled. More...

static int	nextId = 0

Protected Types inherited from inet::Chunk
enum	ChunkFlag { CF_IMMUTABLE = (1 << 0), CF_INCOMPLETE = (1 << 1), CF_INCORRECT = (1 << 2), CF_IMPROPERLY_REPRESENTED = (1 << 3) }
	This enum specifies bitmasks for the flags field of Chunk. More...

typedef bool(*	PeekPredicate) (const Ptr< Chunk > &)

Detailed Description

This class represents data with an ordered list of consecutive chunks.

It's used by the Chunk API implementation internally to manage compound data. User code should not directly instantiate this class.

Constructor & Destructor Documentation

◆ SequenceChunk() [1/3]

inet::SequenceChunk::SequenceChunk ( )

◆ SequenceChunk() [2/3]

inet::SequenceChunk::SequenceChunk ( const SequenceChunk & other )

                                                        :
     Chunk(other),
     chunks(other.isImmutable() ? other.chunks : other.dupChunks())
 {
 }

◆ SequenceChunk() [3/3]

inet::SequenceChunk::SequenceChunk ( const std::deque< Ptr< const Chunk >> & chunks )

                                                                      :
     Chunk(),
     chunks(chunks)
 {
 }

Member Function Documentation

◆ canInsertAtBack()

virtual bool inet::SequenceChunk::canInsertAtBack ( const Ptr< const Chunk > & chunk ) const

inlineoverridevirtual

Returns true if this chunk is capable of representing the result.

Reimplemented from inet::Chunk.

104 { return true; }

◆ canInsertAtFront()

virtual bool inet::SequenceChunk::canInsertAtFront ( const Ptr< const Chunk > & chunk ) const

inlineoverridevirtual

Returns true if this chunk is capable of representing the result.

Reimplemented from inet::Chunk.

103 { return true; }

◆ canRemoveAtBack()

virtual bool inet::SequenceChunk::canRemoveAtBack ( b length ) const

inlineoverridevirtual

Returns true if this chunk is capable of representing the result.

Reimplemented from inet::Chunk.

110 { return true; }

◆ canRemoveAtFront()

virtual bool inet::SequenceChunk::canRemoveAtFront ( b length ) const

inlineoverridevirtual

Returns true if this chunk is capable of representing the result.

Reimplemented from inet::Chunk.

109 { return true; }

◆ containsSameData()

bool inet::SequenceChunk::containsSameData ( const Chunk & other ) const

overridevirtual

Returns true if the two chunks represent the same binary data.

The two chunks are compared without serialization, and the method is allowed to return false if the result cannot be determined correctly. Tags and other metadata are ignored in the comparison.

Reimplemented from inet::Chunk.

 {
     if (&other == this)
         return true;
     else if (!Chunk::containsSameData(other))
         return false;
     else {
         auto otherSequence = static_cast<const SequenceChunk *>(&other);
         if (chunks.size() != otherSequence->chunks.size())
             return false;
         else {
             for (auto i = 0; i < (int)chunks.size(); i++)
                 if (!chunks[i]->containsSameData(*otherSequence->chunks[i].get()))
                     return false;
             return true;
         }
     }
 }

◆ convertChunk()

const Ptr< Chunk > inet::SequenceChunk::convertChunk	(	const std::type_info &	typeInfo,
		const Ptr< Chunk > &	chunk,
		b	offset,
		b	length,
		int	flags
	)

staticprotected

 {
     auto chunkLength = chunk->getChunkLength();
     CHUNK_CHECK_IMPLEMENTATION(b(0) <= offset && offset <= chunkLength);
     CHUNK_CHECK_IMPLEMENTATION(length <= chunkLength - offset);
     auto sequenceChunk = makeShared<SequenceChunk>();
     auto sliceChunk = makeShared<SliceChunk>(chunk, offset, length < b(0) ? std::min(-length, chunkLength - offset) : length);
     sliceChunk->markImmutable();
     sequenceChunk->insertAtBack(sliceChunk);
     return sequenceChunk;
 }

◆ doInsertAtBack()

void inet::SequenceChunk::doInsertAtBack ( const Ptr< const Chunk > & chunk )

overrideprotectedvirtual

Reimplemented from inet::Chunk.

 {
     if (chunk->getChunkType() == CT_SLICE)
         doInsertSliceChunkAtBack(staticPtrCast<const SliceChunk>(chunk));
     else if (chunk->getChunkType() == CT_SEQUENCE)
         doInsertSequenceChunkAtBack(staticPtrCast<const SequenceChunk>(chunk));
     else
         doInsertChunkAtBack(chunk);
 }

◆ doInsertAtFront()

void inet::SequenceChunk::doInsertAtFront ( const Ptr< const Chunk > & chunk )

overrideprotectedvirtual

Reimplemented from inet::Chunk.

 {
     if (chunk->getChunkType() == CT_SLICE)
         doInsertSliceChunkAtFront(staticPtrCast<const SliceChunk>(chunk));
     else if (chunk->getChunkType() == CT_SEQUENCE)
         doInsertSequenceChunkAtFront(staticPtrCast<const SequenceChunk>(chunk));
     else
         doInsertChunkAtFront(chunk);
 }

◆ doInsertChunkAtBack()

void inet::SequenceChunk::doInsertChunkAtBack ( const Ptr< const Chunk > & chunk )

protected

 {
     CHUNK_CHECK_USAGE(chunk->isImmutable(), "chunk is mutable");
     CHUNK_CHECK_USAGE(chunk->getChunkLength() > b(0), "chunk is empty");
     if (chunks.empty())
         chunks.push_back(chunk);
     else {
         const auto& lastChunk = chunks.back();
         if (!lastChunk->canInsertAtBack(chunk))
             chunks.push_back(chunk);
         else {
             const auto& mutableLastChunk = makeExclusivelyOwnedMutableChunk(lastChunk);
             mutableLastChunk->insertAtBack(chunk);
             mutableLastChunk->markImmutable();
             chunks.back() = mutableLastChunk->simplify();
         }
     }
 }

Referenced by doInsertAtBack(), doInsertSequenceChunkAtBack(), and doInsertSliceChunkAtBack().

◆ doInsertChunkAtFront()

void inet::SequenceChunk::doInsertChunkAtFront ( const Ptr< const Chunk > & chunk )

protected

 {
     CHUNK_CHECK_USAGE(chunk->isImmutable(), "chunk is mutable");
     CHUNK_CHECK_USAGE(chunk->getChunkLength() > b(0), "chunk is empty");
     if (chunks.empty())
         chunks.push_front(chunk);
     else {
         const auto& firstChunk = chunks.front();
         if (!firstChunk->canInsertAtFront(chunk))
             chunks.push_front(chunk);
         else {
             const auto& mutableFirstChunk = makeExclusivelyOwnedMutableChunk(firstChunk);
             mutableFirstChunk->insertAtFront(chunk);
             mutableFirstChunk->markImmutable();
             chunks.front() = mutableFirstChunk->simplify();
         }
     }
 }

Referenced by doInsertAtFront(), doInsertSequenceChunkAtFront(), and doInsertSliceChunkAtFront().

◆ doInsertSequenceChunkAtBack()

void inet::SequenceChunk::doInsertSequenceChunkAtBack ( const Ptr< const SequenceChunk > & chunk )

protected

 {
     for (const auto& elementChunk : chunk->chunks)
         doInsertChunkAtBack(elementChunk);
 }

Referenced by doInsertAtBack().

◆ doInsertSequenceChunkAtFront()

void inet::SequenceChunk::doInsertSequenceChunkAtFront ( const Ptr< const SequenceChunk > & chunk )

protected

 {
     for (auto it = chunk->chunks.rbegin(); it != chunk->chunks.rend(); it++)
         doInsertChunkAtFront(*it);
 }

Referenced by doInsertAtFront().

◆ doInsertSliceChunkAtBack()

void inet::SequenceChunk::doInsertSliceChunkAtBack ( const Ptr< const SliceChunk > & chunk )

protected

 {
     if (sliceChunk->getChunk()->getChunkType() == CT_SEQUENCE) {
         auto sequenceChunk = staticPtrCast<SequenceChunk>(sliceChunk->getChunk());
         b offset = b(0);
         b sliceChunkBegin = sliceChunk->getOffset();
         b sliceChunkEnd = sliceChunk->getOffset() + sliceChunk->getChunkLength();
         for (const auto& elementChunk : sequenceChunk->chunks) {
             b chunkBegin = offset;
             b chunkEnd = offset + elementChunk->getChunkLength();
             if (sliceChunkBegin <= chunkBegin && chunkEnd <= sliceChunkEnd)
                 doInsertChunkAtBack(elementChunk);
             else if (chunkBegin < sliceChunkBegin && sliceChunkEnd < chunkEnd)
                 doInsertChunkAtBack(staticPtrCast<const Chunk>(elementChunk->peek(sliceChunkBegin - chunkBegin, sliceChunkEnd - sliceChunkBegin)));
             else if (chunkBegin < sliceChunkBegin && sliceChunkBegin < chunkEnd)
                 doInsertChunkAtBack(staticPtrCast<const Chunk>(elementChunk->peek(sliceChunkBegin - chunkBegin, chunkEnd - sliceChunkBegin)));
             else if (chunkBegin < sliceChunkEnd && sliceChunkEnd < chunkEnd)
                 doInsertChunkAtBack(staticPtrCast<const Chunk>(elementChunk->peek(b(0), sliceChunkEnd - chunkBegin)));
             // otherwise the element chunk is out of the slice, therefore it's ignored
             offset += elementChunk->getChunkLength();
         }
     }
     else
         doInsertChunkAtBack(staticPtrCast<const Chunk>(sliceChunk));
 }

Referenced by doInsertAtBack().

◆ doInsertSliceChunkAtFront()

void inet::SequenceChunk::doInsertSliceChunkAtFront ( const Ptr< const SliceChunk > & chunk )

protected

 {
     if (sliceChunk->getChunk()->getChunkType() == CT_SEQUENCE) {
         auto sequenceChunk = staticPtrCast<SequenceChunk>(sliceChunk->getChunk());
         b offset = sequenceChunk->getChunkLength();
         b sliceChunkBegin = sliceChunk->getOffset();
         b sliceChunkEnd = sliceChunk->getOffset() + sliceChunk->getChunkLength();
         for (auto it = sequenceChunk->chunks.rbegin(); it != sequenceChunk->chunks.rend(); it++) {
             const auto& elementChunk = *it;
             offset -= elementChunk->getChunkLength();
             b chunkBegin = offset;
             b chunkEnd = offset + elementChunk->getChunkLength();
             if (sliceChunkBegin <= chunkBegin && chunkEnd <= sliceChunkEnd)
                 doInsertChunkAtFront(elementChunk);
             else if (chunkBegin < sliceChunkBegin && sliceChunkEnd < chunkEnd)
                 doInsertChunkAtFront(staticPtrCast<const Chunk>(elementChunk->peek(sliceChunkBegin - chunkBegin, sliceChunkEnd - sliceChunkBegin)));
             else if (chunkBegin < sliceChunkBegin && sliceChunkBegin < chunkEnd)
                 doInsertChunkAtFront(staticPtrCast<const Chunk>(elementChunk->peek(sliceChunkBegin - chunkBegin, chunkEnd - sliceChunkBegin)));
             else if (chunkBegin < sliceChunkEnd && sliceChunkEnd < chunkEnd)
                 doInsertChunkAtFront(staticPtrCast<const Chunk>(elementChunk->peek(b(0), sliceChunkEnd - chunkBegin)));
             // otherwise the element chunk is out of the slice, therefore it's ignored
         }
     }
     else
         doInsertChunkAtFront(staticPtrCast<const Chunk>(sliceChunk));
 }

Referenced by doInsertAtFront().

◆ doRemoveAtBack()

void inet::SequenceChunk::doRemoveAtBack ( b length )

overrideprotectedvirtual

Reimplemented from inet::Chunk.

 {
     auto it = chunks.rbegin();
     while (it != chunks.rend()) {
         auto chunk = *it;
         b chunkLength = chunk->getChunkLength();
         if (chunkLength <= length) {
             it++;
             length -= chunkLength;
             if (length == b(0))
                 break;
         }
         else {
             *it = chunk->peek(b(0), chunkLength - length);
             break;
         }
     }
     chunks.erase(it.base(), chunks.end());
 }

◆ doRemoveAtFront()

void inet::SequenceChunk::doRemoveAtFront ( b length )

overrideprotectedvirtual

Reimplemented from inet::Chunk.

 {
     auto it = chunks.begin();
     while (it != chunks.end()) {
         auto chunk = *it;
         b chunkLength = chunk->getChunkLength();
         if (chunkLength <= length) {
             it++;
             length -= chunkLength;
             if (length == b(0))
                 break;
         }
         else {
             *it = chunk->peek(length, chunkLength - length);
             break;
         }
     }
     chunks.erase(chunks.begin(), it);
 }

◆ dup()

virtual SequenceChunk* inet::SequenceChunk::dup ( ) const

inlineoverridevirtual

67 { return new SequenceChunk(*this); }

◆ dupChunks()

std::deque< Ptr< const Chunk > > inet::SequenceChunk::dupChunks ( ) const

protected

 {
     std::deque<Ptr<const Chunk>> copies;
     for (const auto& chunk : chunks)
         copies.push_back(chunk->isImmutable() ? chunk : staticPtrCast<const Chunk>(chunk->dupShared()));
     return copies;
 }

◆ dupShared()

virtual const Ptr<Chunk> inet::SequenceChunk::dupShared ( ) const

inlineoverridevirtual

Returns a mutable copy of this chunk in a shared pointer.

Reimplemented from inet::Chunk.

68 { return makeShared<SequenceChunk>(*this); }

◆ forEachChild()

void inet::SequenceChunk::forEachChild ( cVisitor * v )

overridevirtual

Reimplemented from inet::Chunk.

 {
     Chunk::forEachChild(v);
     for (const auto& chunk : chunks)
         v->visit(const_cast<Chunk *>(chunk.get()));
 }

◆ getChunk()

const Chunk* inet::SequenceChunk::getChunk ( int i ) const

inlineprotected

35 { return chunks[i].get(); } // only for class descriptor

◆ getChunkLength()

b inet::SequenceChunk::getChunkLength ( ) const

overridevirtual

Returns the length of data represented by this chunk.

Implements inet::Chunk.

 {
     b length = b(0);
     for (const auto& chunk : chunks) {
         auto chunkLength = chunk->getChunkLength();
         CHUNK_CHECK_IMPLEMENTATION(chunkLength > b(0));
         length += chunkLength;
     }
     return length;
 }

Referenced by moveIterator(), peekUnchecked(), and seekIterator().

◆ getChunks()

const std::deque<Ptr<const Chunk> >& inet::SequenceChunk::getChunks ( ) const

inline

79 { return chunks; }

◆ getChunkType()

virtual ChunkType inet::SequenceChunk::getChunkType ( ) const

inlineoverridevirtual

Returns the type of this chunk as an enum member.

This can be used to avoid expensive std::dynamic_cast and dynamicPtrCast operators.

Implements inet::Chunk.

115 { return CT_SEQUENCE; }

◆ getElementChunk()

const Ptr<const Chunk>& inet::SequenceChunk::getElementChunk ( const Iterator & iterator ) const

inlineprotected

38 { return chunks[getElementIndex(iterator.isForward(), iterator.getIndex())]; }

Referenced by moveIterator(), and peekUnchecked().

◆ getElementIndex()

int inet::SequenceChunk::getElementIndex	(	bool	isForward,
		int	index
	)		const

inlineprotected

37 { return isForward ? index : chunks.size() - index - 1; }

Referenced by peekUnchecked(), and seekIterator().

◆ getNumChunks()

int inet::SequenceChunk::getNumChunks ( ) const

inlineprotected

34 { return chunks.size(); } // only for class descriptor

◆ isComplete()

virtual bool inet::SequenceChunk::isComplete ( ) const

inlineoverridevirtual

Reimplemented from inet::Chunk.

85 { return !isIncomplete(); }

◆ isCorrect()

virtual bool inet::SequenceChunk::isCorrect ( ) const

inlineoverridevirtual

Reimplemented from inet::Chunk.

88 { return !isIncorrect(); }

◆ isEmpty()

virtual bool inet::SequenceChunk::isEmpty ( ) const

inlineoverridevirtual

Returns true if this chunk contains no data.

Reimplemented from inet::Chunk.

117 { return chunks.size() != 0; }

◆ isImproperlyRepresented()

bool inet::SequenceChunk::isImproperlyRepresented ( ) const

overridevirtual

Reimplemented from inet::Chunk.

 {
     if (Chunk::isImproperlyRepresented())
         return true;
     for (const auto& chunk : chunks)
         if (chunk->isImproperlyRepresented())
             return true;
     return false;
 }

◆ isIncomplete()

bool inet::SequenceChunk::isIncomplete ( ) const

overridevirtual

Reimplemented from inet::Chunk.

 {
     if (Chunk::isIncomplete())
         return true;
     for (const auto& chunk : chunks)
         if (chunk->isIncomplete())
             return true;
     return false;
 }

◆ isIncorrect()

bool inet::SequenceChunk::isIncorrect ( ) const

overridevirtual

Reimplemented from inet::Chunk.

 {
     if (Chunk::isIncorrect())
         return true;
     for (const auto& chunk : chunks)
         if (chunk->isIncorrect())
             return true;
     return false;
 }

◆ isProperlyRepresented()

virtual bool inet::SequenceChunk::isProperlyRepresented ( ) const

inlineoverridevirtual

Reimplemented from inet::Chunk.

91 { return !isImproperlyRepresented(); }

◆ moveIterator()

void inet::SequenceChunk::moveIterator	(	Iterator &	iterator,
		b	length
	)		const

overridevirtual

Reimplemented from inet::Chunk.

 {
     iterator.setPosition(iterator.getPosition() + length);
     if (iterator.getIndex() != -1 && iterator.getIndex() != (int)chunks.size() && getElementChunk(iterator)->getChunkLength() == length)
         iterator.setIndex(iterator.getIndex() + 1);
     else
         iterator.setIndex(-1);
 }

◆ parsimPack()

void inet::SequenceChunk::parsimPack ( cCommBuffer * buffer ) const

overridevirtual

Reimplemented from inet::Chunk.

 {
     Chunk::parsimPack(buffer);
     buffer->pack(chunks.size());
     for (const auto& chunk : chunks)
         buffer->packObject(const_cast<Chunk *>(chunk.get()));
 }

◆ parsimUnpack()

void inet::SequenceChunk::parsimUnpack ( cCommBuffer * buffer )

overridevirtual

Reimplemented from inet::Chunk.

 {
     Chunk::parsimUnpack(buffer);
     size_t size;
     buffer->unpack(size);
     chunks.clear();
     for (size_t i = 0; i < size; i++) {
         const auto& chunk = check_and_cast<Chunk *>(buffer->unpackObject())->shared_from_this();
         chunks.push_back(chunk);
     }
 }

◆ peekUnchecked()

const Ptr< Chunk > inet::SequenceChunk::peekUnchecked	(	PeekPredicate	predicate,
		PeekConverter	converter,
		const Iterator &	iterator,
		b	length,
		int	flags
	)		const

overrideprotectedvirtual

Implements inet::Chunk.

 {
     b chunkLength = getChunkLength();
     CHUNK_CHECK_USAGE(b(0) <= iterator.getPosition() && iterator.getPosition() <= chunkLength, "iterator is out of range");
     // 1. peeking an empty part returns nullptr
     if (length == b(0) || (iterator.getPosition() == chunkLength && length < b(0))) {
         if (predicate == nullptr || predicate(nullptr))
             return EmptyChunk::getEmptyChunk(flags);
     }
     // 2. peeking the whole part returns this chunk only if length is also specified
     if (iterator.getPosition() == b(0) && length == chunkLength) {
         auto result = const_cast<SequenceChunk *>(this)->shared_from_this();
         if (predicate == nullptr || predicate(result))
             return result;
     }
     // 3. peeking a part represented by an element chunk with its index returns that element chunk
     if (iterator.getIndex() != -1 && iterator.getIndex() != (int)chunks.size()) {
         // KLUDGE constPtrCast<Chunk>
         const auto& chunk = constPtrCast<Chunk>(getElementChunk(iterator));
         auto chunkLength = chunk->getChunkLength();
         if (-length >= chunkLength || length == chunkLength) {
             if (predicate == nullptr || predicate(chunk))
                 return chunk;
         }
     }
     // 4. peeking a part represented by an element chunk returns part of that element chunk
     b position = b(0);
     for (size_t i = 0; i < chunks.size(); i++) {
         // KLUDGE constPtrCast<Chunk>
         const auto& chunk = constPtrCast<Chunk>(chunks[getElementIndex(iterator.isForward(), i)]);
         b elementChunkLength = chunk->getChunkLength();
         // 4.1 peeking the whole part of an element chunk returns that element chunk
         if (iterator.getPosition() == position && (-length >= elementChunkLength || length == elementChunkLength)) {
             if (predicate == nullptr || predicate(chunk))
                 return chunk;
         }
         // 4.2 peeking a part of an element chunk returns the part of that element chunk
         if (position <= iterator.getPosition() && iterator.getPosition() < position + elementChunkLength &&
             (-length >= elementChunkLength || iterator.getPosition() + length <= position + elementChunkLength))
             return chunk->peekUnchecked(predicate, converter, Iterator(iterator.isForward(), iterator.getPosition() - position, -1), length, flags);
         position += elementChunkLength;
     }
     // 5. peeking without conversion returns a SequenceChunk
     if (converter == nullptr)
         return peekConverted<SequenceChunk>(iterator, length, flags);
     // 6. peeking with conversion
     return converter(const_cast<SequenceChunk *>(this)->shared_from_this(), iterator, length, flags);
 }

◆ printToStream()

std::ostream & inet::SequenceChunk::printToStream	(	std::ostream &	stream,
		int	level,
		int	evFlags = `0`
	)		const

overridevirtual

Prints an optinally formatted human readable string representation of the data present in this chunk to the given stream.

Reimplemented from inet::Chunk.

 {
     stream << "[";
     bool first = true;
     for (const auto& chunk : chunks) {
         if (!first)
             stream << " | ";
         else
             first = false;
         chunk->printToStream(stream, level + 1, evFlags);
     }
     return stream << "]";
 }

◆ seekIterator()

void inet::SequenceChunk::seekIterator	(	Iterator &	iterator,
		b	offset
	)		const

overridevirtual

Reimplemented from inet::Chunk.

 {
     CHUNK_CHECK_USAGE(b(0) <= offset && offset <= getChunkLength(), "offset is out of range");
     iterator.setPosition(offset);
     if (offset == b(0))
         iterator.setIndex(0);
     else {
         b p = b(0);
         for (size_t i = 0; i < chunks.size(); i++) {
             const auto& chunk = chunks[getElementIndex(iterator.isForward(), i)];
             p += chunk->getChunkLength();
             if (p == offset) {
                 iterator.setIndex(i + 1);
                 return;
             }
             else if (p > offset) {
                 iterator.setIndex(-1);
                 return;
             }
         }
         CHUNK_CHECK_IMPLEMENTATION(false);
     }
 }

◆ setChunks()

void inet::SequenceChunk::setChunks ( const std::deque< Ptr< const Chunk >> & chunks )

 {
     handleChange();
     this->chunks = chunks;
 }

Friends And Related Function Documentation

◆ Chunk

friend class Chunk

friend

◆ SequenceChunkDescriptor

friend class SequenceChunkDescriptor

friend

Member Data Documentation

◆ chunks

std::deque<Ptr<const Chunk> > inet::SequenceChunk::chunks

protected

The list of chunks that make up this chunk.

Referenced by containsSameData(), doInsertChunkAtBack(), doInsertChunkAtFront(), doRemoveAtBack(), doRemoveAtFront(), dupChunks(), forEachChild(), getChunkLength(), isImproperlyRepresented(), isIncomplete(), isIncorrect(), moveIterator(), parsimPack(), parsimUnpack(), peekUnchecked(), printToStream(), seekIterator(), and setChunks().

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

Public Member Functions

Protected Member Functions

Static Protected Member Functions

Protected Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ SequenceChunk() [1/3]

◆ SequenceChunk() [2/3]

◆ SequenceChunk() [3/3]

Member Function Documentation

◆ canInsertAtBack()

◆ canInsertAtFront()

◆ canRemoveAtBack()

◆ canRemoveAtFront()

◆ containsSameData()

◆ convertChunk()

◆ doInsertAtBack()

◆ doInsertAtFront()

◆ doInsertChunkAtBack()

◆ doInsertChunkAtFront()

◆ doInsertSequenceChunkAtBack()

◆ doInsertSequenceChunkAtFront()

◆ doInsertSliceChunkAtBack()

◆ doInsertSliceChunkAtFront()

◆ doRemoveAtBack()

◆ doRemoveAtFront()

◆ dup()

◆ dupChunks()

◆ dupShared()

◆ forEachChild()

◆ getChunk()

◆ getChunkLength()

◆ getChunks()

◆ getChunkType()

◆ getElementChunk()

◆ getElementIndex()

◆ getNumChunks()

◆ isComplete()

◆ isCorrect()

◆ isEmpty()

◆ isImproperlyRepresented()

◆ isIncomplete()

◆ isIncorrect()

◆ isProperlyRepresented()

◆ moveIterator()

◆ parsimPack()

◆ parsimUnpack()

◆ peekUnchecked()

◆ printToStream()

◆ seekIterator()

◆ setChunks()

Friends And Related Function Documentation

◆ Chunk

◆ SequenceChunkDescriptor

Member Data Documentation

◆ chunks