inet::Chunk Class Reference

This class represents a piece of data that is usually part of a packet or some other data such as a protocol buffer. More...

#include <Chunk.h>

Inheritance diagram for inet::Chunk:

Classes
class	BackwardIterator
	Position and index are measured from the end. More...
class	ForwardIterator
	Position and index are measured from the beginning. More...
class	Iterator

Public Types
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) }

Public Member Functions
Constructors, destructors and duplication related functions
	Chunk ()
	Chunk (const Chunk &other)
virtual const Ptr< Chunk >	dupShared () const
	Returns a mutable copy of this chunk in a shared pointer. More...
virtual void	forEachChild (cVisitor *v) override
virtual void	parsimPack (cCommBuffer *buffer) const override
virtual void	parsimUnpack (cCommBuffer *buffer) override
Mutability related functions
virtual bool	isMutable () const
virtual bool	isImmutable () const
virtual void	markImmutable ()
void	markMutableIfExclusivelyOwned ()
Completeness related functions
virtual bool	isComplete () const
virtual bool	isIncomplete () const
virtual void	markIncomplete ()
Correctness related functions
virtual bool	isCorrect () const
virtual bool	isIncorrect () const
virtual void	markIncorrect ()
Proper representation related functions
virtual bool	isProperlyRepresented () const
virtual bool	isImproperlyRepresented () const
virtual void	markImproperlyRepresented ()
Iteration related functions
virtual void	moveIterator (Iterator &iterator, b length) const
virtual void	seekIterator (Iterator &iterator, b position) const
Inserting data related functions
virtual bool	canInsertAtFront (const Ptr< const Chunk > &chunk) const
	Returns true if this chunk is capable of representing the result. More...
virtual bool	canInsertAtBack (const Ptr< const Chunk > &chunk) const
	Returns true if this chunk is capable of representing the result. More...
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...
Removing data related functions
virtual bool	canRemoveAtFront (b length) const
	Returns true if this chunk is capable of representing the result. More...
virtual bool	canRemoveAtBack (b length) const
	Returns true if this chunk is capable of representing the result. 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...
Chunk querying related functions
int	getChunkId () const
	Returns the sequentially assigned id. More...
virtual ChunkType	getChunkType () const =0
	Returns the type of this chunk as an enum member. More...
virtual b	getChunkLength () const =0
	Returns the length of data represented by this chunk. More...
virtual bool	containsSameData (const Chunk &other) const
	Returns true if the two chunks represent the same binary data. More...
virtual bool	isEmpty () const
	Returns true if this chunk contains no data. 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...
Region tagging functions
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...
Utility functions
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...
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

Static Public Member Functions
Chunk serialization related functions
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
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
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...

Protected Member Functions
Class descriptor functions
int	getBinDumpNumLines () const
int	getHexDumpNumLines () const
const char *	getBinDumpLine (int index)
const char *	getHexDumpLine (int index)
const SharingRegionTagSet::RegionTag< TagBase > &	_getTag (int index) const
Self checking functions
void	checkMutable () const

Protected Attributes
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...

Friends
class	SliceChunk
class	EncryptedChunk
class	SequenceChunk
class	ChunkDescriptor

Customizable functions
typedef bool(*	PeekPredicate) (const Ptr< Chunk > &)
const typedef Ptr< Chunk >(*	PeekConverter )(const Ptr< Chunk > &chunk, const Chunk::Iterator &iterator, b length, int flags)
virtual void	handleChange ()
virtual void	doInsertAtFront (const Ptr< const Chunk > &chunk)
virtual void	doInsertAtBack (const Ptr< const Chunk > &chunk)
virtual void	doInsertAt (const Ptr< const Chunk > &chunk, b offset)
virtual void	doRemoveAtFront (b length)
virtual void	doRemoveAtBack (b length)
virtual void	doRemoveAt (b offset, b length)
virtual const Ptr< Chunk >	peekUnchecked (PeekPredicate predicate, PeekConverter converter, const Iterator &iterator, b length, int flags) const =0
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 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...

Detailed Description

This class represents a piece of data that is usually part of a packet or some other data such as a protocol buffer.

The chunk interface is designed to be very flexible in terms of alternative representations. For example, when the actual bytes in the data is irrelevant, a chunk can be as simple as an integer specifying its length. Contrary, sometimes it might be necessary to represent the data bytes as is. For example, when one is using an external program to send or receive the data. But most often it's better to have a representation that is easy to inspect and understand during debugging. Fortunately, this representation can be easily generated using the omnetpp message compiler. In any case, chunks can always be converted to and from a sequence of bytes using the corresponding serializer.

Chunks can represent data in different ways:

• BitsChunk contains a sequence of bits
• BitCountChunk contains a bit length field only
• BytesChunk contains a sequence of bytes
• ByteCountChunk contains a byte length field only
• SliceChunk contains a slice of another chunk
• SequenceChunk contains a sequence of other chunks
• cPacketChunk contains a cPacket for backward compatibility
• message compiler generated chunks extending FieldsChunk contain various user defined fields

Chunks are initially:

• mutable, then may become immutable, but never the other way around. There is one exception to this rule, when the chunk is exclusively owned. That is when it has exactly one reference. Immutable chunks cannot be changed anymore because they might be used to efficiently share data.
• complete, then may become incomplete, but never the other way around. Incomplete chunks are not totally filled in. For example, when a chunk is created by deserializing it from insufficient amount of data.
• correct, then may become incorrect, but never the other way around. Incorrect chunks contain bit errors. For example, when a packet is sent through a lossy channel causing bit errors in it.
• properly represented, then may become improperly represented, but never the other way around. Improperly represented chunks misrepresent their data. For example, when a chunk is created by deserializing data but the field based representation does not fully support all possible data.

Chunks can be safely shared using Ptr. In fact, the reason for having immutable chunks is to allow for efficient sharing using shared pointers. For example, when a Packet data structure is duplicated the copy can share immutable chunks with the original.

In general, chunks support the following operations:

• insert to the beginning or end
• remove from the beginning or end
• query length and peek an arbitrary part
• serialize to and deserialize from a sequence of bytes
• copy to a new mutable chunk
• convert to a human readable string

The chunk API supports polymorphism, so it's possible to create chunk class hierarchies with proper automatic deserialization. Chunks can be nested into each other similarly how SliceChunk and SequenceChunk does it. You can find examples for these in the tests folder of INET.

Communication protocol headers often contain optional parts. There are many ways to represent optional fields with chunks. For example, the IP header contains an optional part that is a list of IP specific options. Assuming the packet already contains a SequenceChunk, the IP header can be represented in various ways. Here are a few examples:

• IpHeader is a FieldsChunk subclass
  • mandatory fields are directly represented in the IpHeader chunk
  • each Ipv4Option is added as an optional structure inside an array
• IpHeader is a FieldsChunk subclass
• IpOptions is a SequenceChunk subclass
  • each Ipv4Option is a FieldsChunk subclass inside the SequenceChunk
• IpHeader is a FieldsChunk subclass
• each Ipv4Option is added as a separate FieldsChunk subclass

Communication protocol headers also often contain CRC or checksum fields. In network simulations, most of the time it's unnecessary to compute the correct CRC. One can safely assume the correct CRC is present, unless the packet has to be serialized. As for the representation, a FieldsChunk subclass should contain a CRC field and possibly a CRC mode field. Please note that computing, inserting and verifying the actual CRC is not the task of the chunk serializer but rather the task of the communication protocol. You can find a few examples how to implement CRC insertion and verification in the TCP/IP protocol stack.

Implementing lossy communication channels is somewhat more complicated but also more flexible with new chunk API. Whenever a packet passes through a lossy channel there are a number of options to represent errors.

• the simplest way is marking the whole packet erroneous via setBitError()
• a more detailed way would be iterating through the chunks in the packet and marking the erroneous chunks via markIncorrect(). Note that the chunks marked this way has to be duplicated before, and they have to be replaced in the packet to avoid accidentally propagating the same error to multiple receivers.
• the most detailed way is asking for the BytesChunk (or BitsChunk) of the packet and actually changing the erroneous bytes (bits) before the packet arrives at the receiver. Fortunately, the receiver doesn't have to worry about receiving a packet containing bytes instead of the original chunks, because the chunk API provides the requested chunk types either way.

Representation duality is a very important aspect of the chunk API. It means that a protocol doesn't have to worry about the actual representation of the packet's data while it's processing. For example, when the IP protocol peeks the packet for the IpHeader, there are a few possiblities. The requested class is either already there to be returned, or if the packet contains the raw bytes, then it's going to be deserialized automatically and transparently.

In fact, the chunk API supports turning any kind of chunk into any other kind of chunk using serialization/deserialization. This represents the fact that the protocol data is really a sequence of bits and any other representation is just a view on top of that. Of course, this could lead to all sorts of surprising things such as accidentally processing a Foo protocol header as a Bar protocol header. This can happen due bit errors (e.g. incorrect length field) or programming errors. To avoid hard to debug errors this conversion is disabled by default.

General rules for peeking into a chunk: 1) Peeking never returns a) a SliceChunk containing

• a BitsChunk
• a BitCountChunk
• a BytesChunk
• a ByteCountChunk
• another SliceChunk
• the whole of another chunk
• a SequenceChunk with superfluous elements b) a SequenceChunk containing
• connecting BitsChunks
• connecting BitCountChunks
• connecting BytesChunks
• connecting ByteCountChunks
• connecting SliceChunks of the same chunk
• another SequenceChunk
• only one chunk 2) Peeking (various special cases) a) an empty part of the chunk returns nullptr if allowed b) the whole of the chunk returns the chunk c) any part that is directly represented by another chunk returns that chunk 3) Peeking without providing a return type for a a) BitsChunk always returns a BitsChunk containing the bits of the requested part b) BitCountChunk always returns a BitCountChunk containing the requested length c) BytesChunk always returns a BytesChunk containing the bytes of the requested part d) ByteCountChunk always returns a ByteCountChunk containing the requested length e) SliceChunk always returns a SliceChunk containing the requested slice of the chunk that is used by the original SliceChunk f) SequenceChunk may return
• an element chunk
• a SliceChunk of an element chunk
• a SliceChunk using the original SequenceChunk
• a new SequenceChunk using the elements of the original SequenceChunk g) any other chunk returns a SliceChunk 4) Peeking with providing a return type always returns a chunk of the requested type (or a subtype thereof) a) Peeking with a BitCountChunk return type for any chunk returns a BitCountChunk containing the requested bit length b) Peeking with a BitsChunk return type for any chunk returns a BitsChunk containing a part of the serialized bits of the original chunk c) Peeking with a ByteCountChunk return type for any chunk returns a ByteCountChunk containing the requested byte length d) Peeking with a BytesChunk return type for any chunk returns a BytesChunk containing a part of the serialized bytes of the original chunk e) Peeking with a SliceChunk return type for any chunk returns a SliceChunk containing the requested slice of the original chunk f) Peeking with a SequenceChunk return type is an error g) Peeking with a any other return type for any chunk returns a chunk of the requested type containing data deserialized from the bytes that were serialized from the original chunk 5) Peeking never returns a chunk that is one of the following unless it's explicitly allowed by passing the corresponding peek flag a) a nullptr b) an incomplete chunk c) an incorrect chunk d) an improperly represented chunk e) a chunk converted from Foo to Bar

General rules for inserting a chunk into another: a) Inserting a BitsChunk into a BitsChunk merges them b) Inserting a BitCountChunk into a BitCountChunk merges them c) Inserting a BytesChunk into a BytesChunk merges them d) Inserting a ByteCountChunk into a ByteCountChunk merges them e) Inserting a connecting SliceChunk into a SliceChunk merges them

Member Typedef Documentation

PeekPredicate

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

protected

Member Enumeration Documentation

ChunkFlag

enum inet::Chunk::ChunkFlag

protected

This enum specifies bitmasks for the flags field of Chunk.

Enumerator
CF_IMMUTABLE
CF_INCOMPLETE
CF_INCORRECT
CF_IMPROPERLY_REPRESENTED

                   {
        CF_IMMUTABLE              = (1 << 0),
        CF_INCOMPLETE             = (1 << 1),
        CF_INCORRECT              = (1 << 2),
        CF_IMPROPERLY_REPRESENTED = (1 << 3),
    };

ChunkType

enum inet::Chunk::ChunkType

This enum is used to avoid std::dynamic_cast and dynamicPtrCast.

Enumerator
CT_EMPTY
CT_BITCOUNT
CT_BITS
CT_BYTECOUNT
CT_BYTES
CT_SLICE
CT_ENCRYPTED
CT_CPACKET
CT_SEQUENCE
CT_FIELDS

                   {
        CT_EMPTY,
        CT_BITCOUNT,
        CT_BITS,
        CT_BYTECOUNT,
        CT_BYTES,
        CT_SLICE,
        CT_ENCRYPTED,
        CT_CPACKET,
        CT_SEQUENCE,
        CT_FIELDS
    };

PeekFlag

enum inet::Chunk::PeekFlag

This enum specifies bitmasks for the flags argument of various peek functions.

Enumerator
PF_ALLOW_NULLPTR
PF_ALLOW_EMPTY
PF_ALLOW_INCOMPLETE
PF_ALLOW_INCORRECT
PF_ALLOW_IMPROPERLY_REPRESENTED
PF_ALLOW_SERIALIZATION
PF_ALLOW_ALL

                  {
        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
    };

Constructor & Destructor Documentation

Chunk() [1/2]

inet::Chunk::Chunk

(

)

             :
    id(nextId++),
    flags(0)
{
}

Chunk() [2/2]

inet::Chunk::Chunk

(

const Chunk &

other

)

                               :
    cObject(other),
    SharedBase<Chunk>(other),
    id(nextId++),
    flags(other.flags & ~CF_IMMUTABLE),
    regionTags(other.regionTags)
{
}

Member Function Documentation

_getTag()

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

inlineprotected

{ return regionTags.getRegionTag(index); }

addTag()

template<typename T >

const Ptr<T> inet::Chunk::addTag ( b  offset = b(0), b  length = b(-1)  )

inline

Returns a newly added chunk tag for the provided type and range, or throws an exception if such a chunk tag is already present.

                                                                                {
        checkMutable();
        return regionTags.addTag<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

Referenced by inet::EthernetCsmaMac::frameReceptionComplete().

addTagIfAbsent()

template<typename T >

const Ptr<T> inet::Chunk::addTagIfAbsent ( b  offset = b(0), b  length = b(-1)  )

inline

Returns a newly added chunk tag for the provided type and range if absent, or returns the chunk tag that is already present.

                                                                                        {
        checkMutable();
        return regionTags.addTagIfAbsent<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

Referenced by inet::physicallayer::EthernetPhy::handleMessage(), inet::Ipv6::handleMessage(), and inet::Gptp::receiveSignal().

addTagsWhereAbsent()

template<typename T >

std::vector<SharingRegionTagSet::RegionTag<T> > inet::Chunk::addTagsWhereAbsent ( b  offset = b(0), b  length = b(-1)  )

inline

Returns the newly added chunk tags for the provided type and range where the tag is absent.

                                                                                                                          {
        checkMutable();
        return regionTags.addTagsWhereAbsent<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

canInsertAt()

virtual bool inet::Chunk::canInsertAt ( const Ptr< const Chunk > &  chunk, b  offset  ) const

inlinevirtual

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

Reimplemented in inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

canInsertAtBack()

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

inlinevirtual

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

Reimplemented in inet::SliceChunk, inet::SequenceChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

canInsertAtFront()

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

inlinevirtual

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

Reimplemented in inet::SliceChunk, inet::SequenceChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

canRemoveAt()

virtual bool inet::Chunk::canRemoveAt ( b  offset, b  length  ) const

inlinevirtual

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

Reimplemented in inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

canRemoveAtBack()

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

inlinevirtual

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

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

canRemoveAtFront()

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

inlinevirtual

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

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, and inet::ByteCountChunk.

{ return false; }

checkMutable()

void inet::Chunk::checkMutable ( ) const

inlineprotected

{ CHUNK_CHECK_USAGE(isMutable(), "chunk is immutable"); }

Referenced by handleChange().

checkPeekResult()

template<typename T >

const Ptr<T> inet::Chunk::checkPeekResult ( const Ptr< T > &  chunk, int  flags  ) const

inlineprotected

                                                                       {
        if (chunk == nullptr) {
            if (!(flags & PF_ALLOW_NULLPTR))
                throw cRuntimeError("Returning an empty chunk (nullptr) is not allowed according to the flags: %x", flags);
        }
        else if (chunk->getChunkType() == CT_EMPTY) {
            if (!(flags & PF_ALLOW_EMPTY))
                throw cRuntimeError("Returning an empty chunk (EmptyChunk) is not allowed according to the flags: %x", flags);
        }
        else {
            if (chunk->isIncomplete() && !(flags & PF_ALLOW_INCOMPLETE))
                throw cRuntimeError("Returning an incomplete chunk is not allowed according to the flags: %x", flags);
            if (chunk->isIncorrect() && !(flags & PF_ALLOW_INCORRECT))
                throw cRuntimeError("Returning an incorrect chunk is not allowed according to the flags: %x", flags);
            if (chunk->isImproperlyRepresented() && !(flags & PF_ALLOW_IMPROPERLY_REPRESENTED))
                throw cRuntimeError("Returning an improperly represented chunk is not allowed according to the flags: %x", flags);
        }
        return chunk;
    }

clearTags()

void inet::Chunk::clearTags ( b  offset = b(0), b  length = b(-1)  )

inline

Clears the set of chunk tags in the given region.

                                                      {
        checkMutable();
        regionTags.clearTags(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

containsSameData()

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

inlinevirtual

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 in inet::SliceChunk, inet::EncryptedChunk, inet::BytesChunk, inet::SequenceChunk, inet::BitsChunk, inet::BitCountChunk, inet::ByteCountChunk, inet::FieldsChunk, and inet::cPacketChunk.

                                                            {
        return getChunkType() == other.getChunkType() && getChunkLength() == other.getChunkLength();
    }

Referenced by inet::cPacketChunk::containsSameData(), inet::FieldsChunk::containsSameData(), inet::BitCountChunk::containsSameData(), inet::ByteCountChunk::containsSameData(), inet::BitsChunk::containsSameData(), inet::SequenceChunk::containsSameData(), inet::BytesChunk::containsSameData(), inet::EncryptedChunk::containsSameData(), and inet::SliceChunk::containsSameData().

convertChunk()

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

staticprotected

Creates a new chunk of the given type that represents the designated part of the provided chunk.

The designated part starts at the provided offset and has the provided length. This function isn't a constructor to allow creating instances of message compiler generated field based chunk classes.

{
    auto chunkType = chunk->getChunkType();
    if (!enableImplicitChunkSerialization && !(flags & PF_ALLOW_SERIALIZATION) && chunkType != CT_BITS && chunkType != CT_BYTES) {
        auto chunkObject = chunk.get();
        throw cRuntimeError("Implicit data reinterpretation via chunk serialization/deserialization (%s -> %s) is disabled to prevent unexpected behavior due to reinterpretation and unpredictable performance degradation due to overhead (you may consider changing the Chunk::enableImplicitChunkSerialization flag or passing the PF_ALLOW_SERIALIZATION flag)", opp_typename(typeid(*chunkObject)), opp_typename(typeInfo));
    }
    MemoryOutputStream outputStream;
    serialize(outputStream, chunk, offset, length < b(0) ? std::min(-length, chunk->getChunkLength() - offset) : length);
    MemoryInputStream inputStream(outputStream.getData());
    const auto& result = deserialize(inputStream, typeInfo);
    result->regionTags.copyTags(chunk->regionTags, offset, b(0), result->getChunkLength());
    return result;
}

Referenced by inet::FieldsChunk::convertChunk().

copyTags()

void inet::Chunk::copyTags ( const Chunk &  source, b  sourceOffset = b(0), b  offset = b(0), b  length = b(-1)  )

inline

Copies the set of chunk tags from the source region to the provided region.

                                                                                                 {
        checkMutable();
        regionTags.copyTags(source.regionTags, sourceOffset, offset, length == b(-1) ? getChunkLength() - offset : length);
    }

deserialize()

const Ptr< Chunk > inet::Chunk::deserialize ( MemoryInputStream &  stream, const std::type_info &  typeInfo  )

static

Deserializes a chunk from the given stream.

The returned chunk will be an instance of the provided type. The chunk represents the bytes in the stream starting from the current stream position up to the length required by the deserializer of the chunk.

{
    auto serializer = ChunkSerializerRegistry::globalRegistry.getSerializer(typeInfo);
#if CHUNK_CHECK_IMPLEMENTATION_ENABLED
    auto startPosition = B(stream.getPosition());
#endif
    auto chunk = serializer->deserialize(stream, typeInfo);
#if CHUNK_CHECK_IMPLEMENTATION_ENABLED
    auto endPosition = B(stream.getPosition());
    CHUNK_CHECK_IMPLEMENTATION(chunk->getChunkLength() == endPosition - startPosition);
#endif
    if (stream.isReadBeyondEnd())
        chunk->markIncomplete();
    return chunk;
}

Referenced by convertChunk().

doInsertAt()

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

inlineprotectedvirtual

Reimplemented in inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

doInsertAtBack()

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

inlineprotectedvirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

doInsertAtFront()

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

inlineprotectedvirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

doRemoveAt()

virtual void inet::Chunk::doRemoveAt ( b  offset, b  length  )

inlineprotectedvirtual

Reimplemented in inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

doRemoveAtBack()

virtual void inet::Chunk::doRemoveAtBack ( b  length )

inlineprotectedvirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

doRemoveAtFront()

virtual void inet::Chunk::doRemoveAtFront ( b  length )

inlineprotectedvirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, and inet::BytesChunk.

{ throw cRuntimeError("Invalid operation"); }

dupShared()

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

inlinevirtual

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

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::BytesChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, inet::EncryptedChunk, inet::cPacketChunk, and inet::EmptyChunk.

{ return Ptr<Chunk>(static_cast<Chunk *>(dup())); }

Referenced by inet::ieee80211::Defragmentation::defragmentFrames(), inet::ProbabilisticBroadcast::handleLowerPacket(), inet::Dsdv::handleMessageWhenUp(), inet::FieldsChunk::peekUnchecked(), inet::RsvpTe::processPathMsg(), and inet::Rip::processRequest().

findTag()

template<typename T >

const Ptr<const T> inet::Chunk::findTag ( b  offset = b(0), b  length = b(-1)  ) const

inline

Returns the chunk tag for the provided type and range, or returns nullptr if no such chunk tag is found.

                                                                                             {
        return regionTags.findTag<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

forEachChild()

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

overridevirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, and inet::EncryptedChunk.

{
    for (int i = 0; i < regionTags.getNumTags(); i++)
        v->visit(const_cast<TagBase *>(regionTags.getTag(i).get()));
}

Referenced by inet::EncryptedChunk::forEachChild(), inet::SliceChunk::forEachChild(), and inet::SequenceChunk::forEachChild().

getAllTags()

template<typename T >

std::vector<SharingRegionTagSet::RegionTag<const T> > inet::Chunk::getAllTags ( b  offset = b(0), b  length = b(-1)  ) const

inline

Returns all chunk tags for the provided type and range in a detached vector of region tags.

                                                                                                                              {
        return regionTags.getAllTags<const T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

getAllTagsForUpdate()

template<typename T >

std::vector<SharingRegionTagSet::RegionTag<T> > inet::Chunk::getAllTagsForUpdate ( b  offset = b(0), b  length = b(-1)  )

inline

Returns all chunk tags for the provided type and range in a detached vector of region tags.

                                                                                                                           {
        checkMutable();
        return regionTags.getAllTagsForUpdate<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

getBinDumpLine()

const char * inet::Chunk::getBinDumpLine ( int  index )

protected

{
    asStringValue = "";
    try {
        int offset = index * 32;
        int length = std::min(32, (int)b(getChunkLength()).get() - offset);
        MemoryOutputStream outputStream;
        serialize(outputStream, shared_from_this(), b(offset), b(length));
        std::vector<bool> bits;
        outputStream.copyData(bits);
        for (int i = 0; i < length; i++) {
            if (i != 0 && i % 4 == 0)
                asStringValue += " ";
            asStringValue += (bits[i] ? "1" : "0");
        }
    }
    catch (cRuntimeError& e) {
        asStringValue = e.what();
    }
    return asStringValue.c_str();
}

getBinDumpNumLines()

int inet::Chunk::getBinDumpNumLines ( ) const

protected

{
    return (b(getChunkLength()).get() + 31) / 32;
}

getChunkId()

int inet::Chunk::getChunkId ( ) const

inline

Returns the sequentially assigned id.

{ return id; }

getChunkLength()

virtual b inet::Chunk::getChunkLength ( ) const

pure virtual

Returns the length of data represented by this chunk.

Implemented in inet::SequenceChunk, inet::SliceChunk, inet::EncryptedChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, inet::ByteCountChunk, inet::FieldsChunk, inet::cPacketChunk, inet::EmptyChunk, and inet::PacketDissector::ProtocolDataUnit.

Referenced by containsSameData(), getBinDumpLine(), getBinDumpNumLines(), getHexDumpLine(), getHexDumpNumLines(), printFieldsToStream(), and serialize().

getChunkType()

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

pure virtual

Returns the type of this chunk as an enum member.

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

Implemented in inet::SequenceChunk, inet::SliceChunk, inet::EncryptedChunk, inet::BytesChunk, inet::BitsChunk, inet::BitCountChunk, inet::ByteCountChunk, inet::FieldsChunk, inet::cPacketChunk, inet::EmptyChunk, and inet::PacketDissector::ProtocolDataUnit.

Referenced by containsSameData().

getHexDumpLine()

const char * inet::Chunk::getHexDumpLine ( int  index )

protected

{
    asStringValue = "";
    try {
        int offset = index * 8 * 16;
        int length = std::min(8 * 16, (int)b(getChunkLength()).get() - offset);
        MemoryOutputStream outputStream;
        serialize(outputStream, shared_from_this(), b(offset), b(length));
        ASSERT(outputStream.getLength() == b(length));
        std::vector<uint8_t> bytes;
        outputStream.copyData(bytes);
        char tmp[3] = "  ";
        for (size_t i = 0; i < bytes.size(); i++) {
            if (i != 0)
                asStringValue += " ";
            sprintf(tmp, "%02X", bytes[i]);
            asStringValue += tmp;
        }
    }
    catch (cRuntimeError& e) {
        asStringValue = e.what();
    }
    return asStringValue.c_str();
}

getHexDumpNumLines()

int inet::Chunk::getHexDumpNumLines ( ) const

protected

{
    return ((b(getChunkLength()).get() + 7) / 8 + 15) / 16;
}

getNumTags()

int inet::Chunk::getNumTags ( ) const

inline

Returns the number of chunk tags.

                           {
        return regionTags.getNumTags();
    }

getRegionTags()

virtual SharingRegionTagSet& inet::Chunk::getRegionTags ( )

inlineoverridevirtual

Returns all region tags.

Implements inet::IRegionTaggedObject.

{ return regionTags; }

getTag() [1/2]

template<typename T >

const Ptr<const T> inet::Chunk::getTag ( b  offset = b(0), b  length = b(-1)  ) const

inline

Returns the chunk tag for the provided type and range, or throws an exception if no such chunk tag is found.

                                                                                            {
        return regionTags.getTag<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

getTag() [2/2]

const Ptr<const TagBase> inet::Chunk::getTag ( int  index ) const

inline

Returns the chunk tag at the given index.

                                                     {
        return regionTags.getTag(index);
    }

handleChange()

void inet::Chunk::handleChange ( )

protectedvirtual

Reimplemented in inet::FieldsChunk.

{
    checkMutable();
}

Referenced by inet::BytesChunk::copyFromBuffer(), inet::FieldsChunk::handleChange(), inet::BitsChunk::setBit(), inet::BitsChunk::setBits(), inet::BytesChunk::setByte(), inet::BytesChunk::setBytes(), inet::SequenceChunk::setChunks(), inet::ByteCountChunk::setData(), inet::BitCountChunk::setData(), inet::BitCountChunk::setLength(), inet::ByteCountChunk::setLength(), inet::EncryptedChunk::setLength(), inet::SliceChunk::setLength(), and inet::SliceChunk::setOffset().

has()

template<typename T >

bool inet::Chunk::has ( const Iterator &  iterator, b  length = unspecifiedLength  ) const

inline

Returns whether if the designated part of the data is available in the requested representation.

                                                                           {
        if (length >= b(0) && getChunkLength() < iterator.getPosition() + length)
            return false;
        else {
            const auto& chunk = peek<T>(iterator, length, PF_ALLOW_NULLPTR | PF_ALLOW_INCOMPLETE);
            return chunk != nullptr && chunk->isComplete();
        }
    }

insertAt()

void inet::Chunk::insertAt ( const Ptr< const Chunk > &  chunk, b  offset  )

inline

Inserts the provided chunk into this chunk.

                                                           {
        auto chunkLength = getChunkLength();
        CHUNK_CHECK_USAGE(b(0) <= offset && offset <= chunkLength, "offset is invalid");
        CHUNK_CHECK_IMPLEMENTATION(canInsertAtBack(chunk));
        handleChange();
        regionTags.moveTags(offset, chunkLength - offset, chunk->getChunkLength());
        regionTags.copyTags(chunk->regionTags, b(0), offset, chunk->getChunkLength());
        doInsertAt(chunk, offset);
    }

insertAtBack()

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

inline

Inserts the provided chunk at the end of this chunk.

                                                     {
        CHUNK_CHECK_IMPLEMENTATION(canInsertAtBack(chunk));
        handleChange();
        regionTags.copyTags(chunk->regionTags, b(0), getChunkLength(), chunk->getChunkLength());
        doInsertAtBack(chunk);
    }

Referenced by inet::ieee80211::Defragmentation::defragmentFrames().

insertAtFront()

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

inline

Inserts the provided chunk at the beginning of this chunk.

                                                      {
        CHUNK_CHECK_IMPLEMENTATION(canInsertAtFront(chunk));
        handleChange();
        auto length = chunk->getChunkLength();
        regionTags.moveTags(length);
        regionTags.copyTags(chunk->regionTags, b(0), b(0), length);
        doInsertAtFront(chunk);
    }

Referenced by inet::tcp::TcpLwipSendQueue::createSegmentWithBytes().

isComplete()

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

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, and inet::EncryptedChunk.

{ return !(flags & CF_INCOMPLETE); }

Referenced by inet::EncryptedChunk::isComplete(), and inet::SliceChunk::isComplete().

isCorrect()

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

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, inet::EncryptedChunk, and inet::PacketDissector::ProtocolDataUnit.

{ return !(flags & CF_INCORRECT); }

Referenced by inet::EncryptedChunk::isCorrect(), inet::SliceChunk::isCorrect(), inet::physicallayer::EthernetPhyHeaderChecker::matchesPacket(), and inet::Udp::verifyCrc().

isEmpty()

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

inlinevirtual

Returns true if this chunk contains no data.

Reimplemented in inet::SequenceChunk.

{ return getChunkLength() == b(0); }

isImmutable()

virtual bool inet::Chunk::isImmutable ( ) const

inlinevirtual

Reimplemented in inet::SliceChunk, and inet::EncryptedChunk.

{ return flags & CF_IMMUTABLE; }

Referenced by inet::EncryptedChunk::isImmutable(), and inet::SliceChunk::isImmutable().

isImproperlyRepresented()

virtual bool inet::Chunk::isImproperlyRepresented ( ) const

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, and inet::EncryptedChunk.

{ return flags & CF_IMPROPERLY_REPRESENTED; }

Referenced by inet::EncryptedChunk::isImproperlyRepresented(), inet::SequenceChunk::isImproperlyRepresented(), and inet::SliceChunk::isImproperlyRepresented().

isIncomplete()

virtual bool inet::Chunk::isIncomplete ( ) const

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, and inet::EncryptedChunk.

{ return flags & CF_INCOMPLETE; }

Referenced by inet::EncryptedChunk::isIncomplete(), inet::SequenceChunk::isIncomplete(), and inet::SliceChunk::isIncomplete().

isIncorrect()

virtual bool inet::Chunk::isIncorrect ( ) const

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, and inet::EncryptedChunk.

{ return flags & CF_INCORRECT; }

Referenced by inet::EncryptedChunk::isIncorrect(), inet::SequenceChunk::isIncorrect(), and inet::SliceChunk::isIncorrect().

isMutable()

virtual bool inet::Chunk::isMutable ( ) const

inlinevirtual

Reimplemented in inet::SliceChunk, and inet::EncryptedChunk.

{ return !(flags & CF_IMMUTABLE); }

Referenced by inet::EncryptedChunk::isMutable(), and inet::SliceChunk::isMutable().

isProperlyRepresented()

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

inlinevirtual

Reimplemented in inet::SliceChunk, inet::SequenceChunk, and inet::EncryptedChunk.

{ return !(flags & CF_IMPROPERLY_REPRESENTED); }

Referenced by inet::EncryptedChunk::isProperlyRepresented(), and inet::SliceChunk::isProperlyRepresented().

mapAllTags()

template<typename T >

void inet::Chunk::mapAllTags ( b  offset, b  length, std::function< void(b, b, const Ptr< const T > &)>  f  ) const

inline

Maps all tags in the provided range to to the function.

                                                                                                                   {
        return regionTags.mapAllTags<const T>(offset, length == b(-1) ? getChunkLength() - offset : length, f);
    }

mapAllTagsForUpdate()

template<typename T >

void inet::Chunk::mapAllTagsForUpdate ( b  offset, b  length, std::function< void(b, b, const Ptr< T > &)>  f  )

inline

Maps all tags in the provided range to to the function.

                                                                                                                {
        checkMutable();
        return regionTags.mapAllTagsForUpdate<T>(offset, length == b(-1) ? getChunkLength() - offset : length, f);
    }

markImmutable()

virtual void inet::Chunk::markImmutable ( )

inlinevirtual

{ flags |= CF_IMMUTABLE; }

Referenced by inet::EmptyChunk::EmptyChunk().

markImproperlyRepresented()

virtual void inet::Chunk::markImproperlyRepresented ( )

inlinevirtual

{ checkMutable(); flags |= CF_IMPROPERLY_REPRESENTED; }

markIncomplete()

virtual void inet::Chunk::markIncomplete ( )

inlinevirtual

{ checkMutable(); flags |= CF_INCOMPLETE; }

markIncorrect()

virtual void inet::Chunk::markIncorrect ( )

inlinevirtual

Reimplemented in inet::PacketDissector::ProtocolDataUnit.

{ checkMutable(); flags |= CF_INCORRECT; }

Referenced by inet::deserializeIpv6NdOptions().

markMutableIfExclusivelyOwned()

void inet::Chunk::markMutableIfExclusivelyOwned ( )

inline

                                         {
        // NOTE: one for the external reference and one for the temporary return value of shared_from_this()
        CHUNK_CHECK_USAGE(shared_from_this().use_count() == 2, "chunk is not exclusively owned");
        flags &= ~CF_IMMUTABLE;
    }

moveIterator()

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

virtual

Reimplemented in inet::SequenceChunk.

{
    auto position = iterator.getPosition() + length;
    iterator.setPosition(position);
    iterator.setIndex(position == b(0) ? 0 : -1);
}

parsimPack()

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

overridevirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::FieldsChunk, inet::BytesChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, inet::EncryptedChunk, and inet::cPacketChunk.

{
    buffer->pack(id);
    buffer->pack(flags);
    regionTags.parsimPack(buffer);
}

Referenced by inet::cPacketChunk::parsimPack(), inet::EncryptedChunk::parsimPack(), inet::BitCountChunk::parsimPack(), inet::BitsChunk::parsimPack(), inet::ByteCountChunk::parsimPack(), inet::BytesChunk::parsimPack(), inet::FieldsChunk::parsimPack(), inet::SliceChunk::parsimPack(), and inet::SequenceChunk::parsimPack().

parsimUnpack()

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

overridevirtual

Reimplemented in inet::SequenceChunk, inet::SliceChunk, inet::FieldsChunk, inet::BytesChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, inet::EncryptedChunk, and inet::cPacketChunk.

{
    buffer->unpack(id);
    buffer->unpack(flags);
    regionTags.parsimUnpack(buffer);
}

Referenced by inet::cPacketChunk::parsimUnpack(), inet::EncryptedChunk::parsimUnpack(), inet::BitCountChunk::parsimUnpack(), inet::BitsChunk::parsimUnpack(), inet::ByteCountChunk::parsimUnpack(), inet::BytesChunk::parsimUnpack(), inet::FieldsChunk::parsimUnpack(), inet::SliceChunk::parsimUnpack(), and inet::SequenceChunk::parsimUnpack().

peek() [1/2]

const Ptr< Chunk > inet::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.

If the length is unspecified, then the length of the result is chosen according to the internal representation. If the length is negative, then the result won't be longer than the absolute length. The result is mutable iff the designated part is directly represented in this chunk by a mutable chunk, otherwise the result is immutable.

{
    const auto& chunk = peekUnchecked(nullptr, nullptr, iterator, length, flags);
    return checkPeekResult<Chunk>(chunk, flags);
}

peek() [2/2]

template<typename T >

const Ptr<T> inet::Chunk::peek ( const Iterator &  iterator, b  length = unspecifiedLength, int  flags = 0  ) const

inline

Returns the designated part of the data represented by this chunk in the requested representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation. If the length is negative, then the result won't be longer than the absolute length. The result is mutable iff the designated part is directly represented in this chunk by a mutable chunk, otherwise the result is immutable.

                                                                                                   {
        if (std::is_same<T, Chunk>::value)
            // NOTE: this code used to be a simple peek template specialization for the Chunk type but
            // explicit specialization in non-namespace scope does not compile in GCC:
            // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=85282
            // specialization for the case where any returned type is acceptable.
            return staticPtrCast<T>(peek(iterator, length, flags));
        else {
            CHUNK_CHECK_USAGE((flags & PF_ALLOW_EMPTY) == 0, "peeking with a specific chunk type with PF_ALLOW_EMPTY is an invalid operation");
            const auto& predicate = [] (const Ptr<Chunk>& chunk) -> bool { return chunk == nullptr || dynamicPtrCast<T>(chunk); };
            const auto& converter = [] (const Ptr<Chunk>& chunk, const Iterator& iterator, b length, int flags) -> const Ptr<Chunk> { return chunk->peekConverted<T>(iterator, length, flags); };
            const auto& chunk = peekUnchecked(predicate, converter, iterator, length, flags);
            return checkPeekResult<T>(staticPtrCast<T>(chunk), flags);
        }
    }

peekConverted()

template<typename T >

const Ptr<T> inet::Chunk::peekConverted ( const Iterator &  iterator, b  length, int  flags  ) const

inlineprotected

                                                                                    {
        CHUNK_CHECK_USAGE(iterator.isForward() || length >= b(0), "chunk conversion using backward iterator with undefined length is invalid");
        auto offset = iterator.isForward() ? iterator.getPosition() : getChunkLength() - iterator.getPosition() - length;
        const auto& chunk = T::convertChunk(typeid(T), const_cast<Chunk *>(this)->shared_from_this(), offset, length, flags);
        chunk->markImmutable();
        return staticPtrCast<T>(chunk);
    }

peekUnchecked()

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

protectedpure virtual

Implemented in inet::SequenceChunk, inet::SliceChunk, inet::FieldsChunk, inet::EncryptedChunk, inet::BitCountChunk, inet::BitsChunk, inet::ByteCountChunk, inet::BytesChunk, inet::cPacketChunk, inet::EmptyChunk, and inet::PacketDissector::ProtocolDataUnit.

Referenced by peek().

printFieldsToStream()

std::ostream & inet::Chunk::printFieldsToStream ( std::ostream &  stream, int  level, int  evFlags = 0  ) const

virtual

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

Reimplemented in inet::SliceChunk, inet::BytesChunk, inet::EncryptedChunk, inet::BitsChunk, inet::BitCountChunk, inet::ByteCountChunk, inet::FieldsChunk, inet::cPacketChunk, and inet::EmptyChunk.

{
    if (level <= PRINT_LEVEL_DETAIL)
        stream << EV_FIELD(length, getChunkLength());
    return stream;
}

Referenced by inet::ByteCountChunk::printFieldsToStream(), printToStream(), and str().

printToStream()

std::ostream & inet::Chunk::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::IPrintableObject.

Reimplemented in inet::SequenceChunk.

{
    std::string className = getClassName();
    auto index = className.rfind("::");
    if (index != std::string::npos)
        className = className.substr(index + 2);
    stream << EV_FAINT << className << EV_NORMAL;
    return printFieldsToStream(stream, level, evFlags);
}

removeAt()

void inet::Chunk::removeAt ( b  offset, b  length  )

inline

Removes the requested part from this chunk.

                                      {
        auto chunkLength = getChunkLength();
        CHUNK_CHECK_USAGE(b(0) <= length && length <= chunkLength, "length is invalid");
        CHUNK_CHECK_USAGE(b(0) <= offset && offset + length <= chunkLength, "offset is invalid");
        CHUNK_CHECK_IMPLEMENTATION(canRemoveAt(offset, length));
        handleChange();
        doRemoveAt(offset, length);
        regionTags.moveTags(offset + length, chunkLength - offset - length, -length);
    }

removeAtBack()

void inet::Chunk::removeAtBack ( b  length )

inline

Removes the requested part from the end of this chunk.

                                {
        auto chunkLength = getChunkLength();
        CHUNK_CHECK_USAGE(b(0) <= length && length <= getChunkLength(), "length is invalid");
        CHUNK_CHECK_IMPLEMENTATION(canRemoveAtBack(length));
        handleChange();
        doRemoveAtBack(length);
        regionTags.clearTags(chunkLength - length, length);
    }

removeAtFront()

void inet::Chunk::removeAtFront ( b  length )

inline

Removes the requested part from the beginning of this chunk.

                                 {
        CHUNK_CHECK_USAGE(b(0) <= length && length <= getChunkLength(), "length is invalid");
        CHUNK_CHECK_IMPLEMENTATION(canRemoveAtFront(length));
        handleChange();
        doRemoveAtFront(length);
        regionTags.clearTags(b(0), length);
        regionTags.moveTags(-length);
    }

removeTag()

template<typename T >

const Ptr<T> inet::Chunk::removeTag ( b  offset, b  length  )

inline

Removes the chunk tag for the provided type and range, or throws an exception if no such chunk tag is found.

                                                                    {
        checkMutable();
        return regionTags.removeTag<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

removeTagIfPresent()

template<typename T >

const Ptr<T> inet::Chunk::removeTagIfPresent ( b  offset, b  length  )

inline

Removes the chunk tag for the provided type and range if present, or returns nullptr if no such chunk tag is found.

                                                                             {
        checkMutable();
        return regionTags.removeTagIfPresent<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

removeTagsWherePresent()

template<typename T >

std::vector<SharingRegionTagSet::RegionTag<T> > inet::Chunk::removeTagsWherePresent ( b  offset, b  length  )

inline

Removes and returns all chunk tags for the provided type and range.

                                                                                                               {
        checkMutable();
        return regionTags.removeTagsWherePresent<T>(offset, length == b(-1) ? getChunkLength() - offset : length);
    }

seekIterator()

void inet::Chunk::seekIterator ( Iterator &  iterator, b  position  ) const

virtual

Reimplemented in inet::SequenceChunk.

{
    iterator.setPosition(position);
    iterator.setIndex(position == b(0) ? 0 : -1);
}

serialize()

void inet::Chunk::serialize ( MemoryOutputStream &  stream, const Ptr< const Chunk > &  chunk, b  offset = b(0), b  length = b(-1)  )

static

Serializes a chunk into the given stream.

The bytes representing the chunk is written at the current position of the stream up to its length. The offset parameter and the offset + length value must be in the range [0, chunkLength]. If the length parameter is -1, then the chunk will be serialized up to its end.

{
    CHUNK_CHECK_USAGE(length >= b(-1), "length is invalid");
    CHUNK_CHECK_USAGE(b(0) <= offset && offset <= chunk->getChunkLength(), "offset is out of range");
    const Chunk *chunkPointer = chunk.get();
    auto serializer = ChunkSerializerRegistry::globalRegistry.getSerializer(typeid(*chunkPointer));
#if CHUNK_CHECK_IMPLEMENTATION_ENABLED
    auto startPosition = stream.getLength();
#endif
    serializer->serialize(stream, chunk, offset, length);
#if CHUNK_CHECK_IMPLEMENTATION_ENABLED
    auto endPosition = stream.getLength();
    auto expectedChunkLength = length == b(-1) ? chunk->getChunkLength() - offset : length;
    CHUNK_CHECK_IMPLEMENTATION(expectedChunkLength == endPosition - startPosition);
#endif
}

Referenced by inet::tcp::Tcp::checkCrc(), inet::tcp::TcpCrcInsertionHook::computeCrc(), inet::Pim::computeCrc(), inet::Udp::computeCrc(), inet::BytesChunk::convertChunk(), inet::BitsChunk::convertChunk(), convertChunk(), inet::Ipv4Encap::encapsulate(), getBinDumpLine(), getHexDumpLine(), inet::sctp::SctpCrcInsertion::insertCrc(), inet::Icmp::insertCrc(), inet::Icmpv6::insertCrc(), inet::Ipv4::insertCrc(), inet::Igmpv2::insertCrc(), inet::Igmpv3::insertCrc(), inet::SequenceChunkSerializer::serialize(), inet::SliceChunkSerializer::serialize(), inet::Ipv4::setComputedCrc(), inet::ospfv2::setOspfCrc(), and inet::Ipv4::verifyCrc().

simplify()

const Ptr<Chunk> inet::Chunk::simplify ( ) const

inline

Returns the simplified representation of this chunk eliminating all potential redundancies.

This function may return a nullptr for emptry chunks.

                                      {
        return peek(b(0), getChunkLength(), PF_ALLOW_INCOMPLETE | PF_ALLOW_INCORRECT | PF_ALLOW_IMPROPERLY_REPRESENTED);
    }

str()

std::string inet::Chunk::str ( ) const

overridevirtual

Returns a human readable string representation of the data present in this chunk.

Reimplemented in inet::tcp::TcpHeader, inet::rtp::RtpHeader, inet::ArpPacket, and inet::MplsHeader.

{
    std::stringstream stream;
    printFieldsToStream(stream, PRINT_LEVEL_COMPLETE, 0);
    return stream.tellp() == 0 ? "" : stream.str().substr(2);
}

Friends And Related Function Documentation

ChunkDescriptor

friend class ChunkDescriptor

friend

EncryptedChunk

friend class EncryptedChunk

friend

SequenceChunk

friend class SequenceChunk

friend

SliceChunk

friend class SliceChunk

friend

Member Data Documentation

enableImplicitChunkSerialization

bool inet::Chunk::enableImplicitChunkSerialization = false

static

Peeking some part into a chunk that requires automatic serialization will throw an exception when implicit chunk serialization is disabled.

Referenced by convertChunk().

flags

int inet::Chunk::flags

protected

The boolean chunk flags are merged into a single integer.

Referenced by inet::FieldsChunk::containsSameData(), convertChunk(), parsimPack(), parsimUnpack(), peek(), inet::EmptyChunk::peekUnchecked(), inet::cPacketChunk::peekUnchecked(), inet::BytesChunk::peekUnchecked(), inet::BitCountChunk::peekUnchecked(), inet::BitsChunk::peekUnchecked(), inet::ByteCountChunk::peekUnchecked(), inet::EncryptedChunk::peekUnchecked(), inet::FieldsChunk::peekUnchecked(), inet::SliceChunk::peekUnchecked(), and inet::SequenceChunk::peekUnchecked().

id

int inet::Chunk::id

protected

The id is automatically assigned sequentially during construction.

nextId

int inet::Chunk::nextId = 0

static

PeekConverter

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

protected

regionTags

SharingRegionTagSet inet::Chunk::regionTags

protected

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

Referenced by copyTags(), forEachChild(), parsimPack(), parsimUnpack(), inet::BitCountChunk::peekUnchecked(), inet::BytesChunk::peekUnchecked(), inet::BitsChunk::peekUnchecked(), inet::ByteCountChunk::peekUnchecked(), inet::FieldsChunk::peekUnchecked(), and inet::SliceChunk::SliceChunk().

unspecifiedLength

const b inet::Chunk::unspecifiedLength = b(-std::numeric_limits<int64_t>::max())

static

Referenced by inet::ChunkQueue::has(), inet::ChunkQueue::peek(), inet::ChunkQueue::peekAt(), and inet::ChunkQueue::pop().

---

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

• Chunk.h
• Chunk.cc