inet::ChunkQueue Class Reference

This class represents a first in, first out queue of chunks. More...

#include <ChunkQueue.h>

Inheritance diagram for inet::ChunkQueue:

Public Member Functions
Constructors, destructors and duplication related functions
	ChunkQueue (const char *name=nullptr, const Ptr< const Chunk > &content=EmptyChunk::singleton)
	ChunkQueue (const ChunkQueue &other)
virtual ChunkQueue *	dup () const override
Length querying related functions
b	getLength () const
	Returns the total length of data currently available in the queue. More...
b	getPushedLength () const
	Returns the total length of data pushed into the queue so far. More...
b	getPoppedLength () const
	Returns the total length of data popped from the queue so far. More...
Querying data related functions
const Ptr< const Chunk >	peek (b length=b(-1), int flags=0) const
	Returns the designated data from the head of the queue as an immutable chunk in its current representation. More...
const Ptr< const Chunk >	peekAt (b offset, b length, int flags=0) const
	Returns the designated data at the given offset as an immutable chunk in its current representation. More...
template<typename T >
bool	has (b length=b(-1)) const
	Returns true if the designated data is available at the head of the queue in the requested representation. More...
template<typename T >
const Ptr< const T >	peek (b length=b(-1), int flags=0) const
	Returns the designated data from the head of the queue as an immutable chunk in the requested representation. More...
template<typename T >
const Ptr< const T >	peekAt (b offset, b length=b(-1), int flags=0) const
	Returns the designated data at the given offset as an immutable chunk in the requested representation. More...
const Ptr< const Chunk >	peekAll (int flags=0) const
	Returns all data in the queue in the current representation. More...
const Ptr< const BitsChunk >	peekAllAsBits (int flags=0) const
	Returns all data in the queue in the as a sequence of bits. More...
const Ptr< const BytesChunk >	peekAllAsBytes (int flags=0) const
	Returns all data in the queue in the as a sequence of bytes. More...
Removing data related functions
const Ptr< const Chunk >	pop (b length=b(-1), int flags=0)
	Pops the designated data and returns it as an immutable chunk in its current representation. More...
template<typename T >
const Ptr< const T >	pop (b length=b(-1), int flags=0)
	Pops the designated data from the head of the queue and returns it as an immutable chunk in the requested representation. More...
void	clear ()
	Erases all data from the queue. More...
Filling with data related functions
void	push (const Ptr< const Chunk > &chunk)
	Inserts the provided chunk at the tail of the queue. More...
virtual std::string	str () const override
	Returns a human readable string representation. More...

Protected Member Functions
const Chunk *	getContent () const
bool	isIteratorConsistent (const Chunk::Iterator &iterator)
void	remove (b length)
void	moveIteratorOrRemove (b length)

Protected Attributes
b	pushedLength = b(0)
b	poppedLength = b(0)
Ptr< const Chunk >	content
	This chunk is always immutable to allow arbitrary peeking. More...
Chunk::Iterator	iterator

Friends
class	ChunkQueueDescriptor

Detailed Description

This class represents a first in, first out queue of chunks.

It is mainly useful for application and protocol buffers where the incoming chunks are guaranteed to be in order.

Internally, queues stores the data in different kind of chunks. See the Chunk class and its subclasses for details. All chunks are immutable in a queue. Chunks are automatically merged as they are pushed into the queue, and they are also shared among queues when duplicating.

In general, this class supports the following operations:

• push at the tail and pop at the head
• query the length
• serialize to and deserialize from a sequence of bits or bytes
• copy to a new queue
• convert to a human readable string

Constructor & Destructor Documentation

ChunkQueue() [1/2]

inet::ChunkQueue::ChunkQueue	(	const char *	name = nullptr,
		const Ptr< const Chunk > &	content = EmptyChunk::singleton
	)

                                                                        :
    cNamedObject(name),
    content(content),
    iterator(Chunk::ForwardIterator(b(0), 0))
{
    constPtrCast<Chunk>(content)->markImmutable();
}

ChunkQueue() [2/2]

inet::ChunkQueue::ChunkQueue

(

const ChunkQueue &

other

)

                                              :
    cNamedObject(other),
    content(other.content),
    iterator(other.iterator)
{
    CHUNK_CHECK_IMPLEMENTATION(content->isImmutable());
}

Member Function Documentation

clear()

void inet::ChunkQueue::clear

(

)

Erases all data from the queue.

{
    poppedLength += getLength();
    content->seekIterator(iterator, b(0));
    content = EmptyChunk::singleton;
}

Referenced by inet::tcp::TcpSendQueue::init(), inet::tcp::TcpLwipSendQueue::setConnection(), and inet::tcp::TcpLwipReceiveQueue::setConnection().

dup()

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

inlineoverridevirtual

{ return new ChunkQueue(*this); }

getContent()

const Chunk* inet::ChunkQueue::getContent ( ) const

inlineprotected

{ return content.get(); } // only for class descriptor

getLength()

b inet::ChunkQueue::getLength ( ) const

inline

Returns the total length of data currently available in the queue.

{ return content->getChunkLength() - iterator.getPosition(); }

Referenced by clear(), inet::tcp::TcpLwipReceiveQueue::extractBytesUpTo(), inet::tcp::TcpLwipReceiveQueue::getAmountOfBufferedBytes(), inet::tcp::TcpLwipSendQueue::getBytesAvailable(), inet::tcp::TcpLwipSendQueue::getBytesForTcpLayer(), inet::tcp::TcpLwipReceiveQueue::getExtractableBytesUpTo(), inet::tcp::TcpLwipReceiveQueue::getQueueLength(), peek(), peekAt(), and pop().

getPoppedLength()

b inet::ChunkQueue::getPoppedLength ( ) const

inline

Returns the total length of data popped from the queue so far.

{ return poppedLength; }

getPushedLength()

b inet::ChunkQueue::getPushedLength ( ) const

inline

Returns the total length of data pushed into the queue so far.

{ return pushedLength; }

has()

template<typename T >

bool inet::ChunkQueue::has ( b  length = b(-1) ) const

inline

Returns true if the designated data is available at the head of the queue in the requested representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

                                     {
        return content->has<T>(iterator, length == b(-1) ? Chunk::unspecifiedLength : length);
    }

isIteratorConsistent()

bool inet::ChunkQueue::isIteratorConsistent ( const Chunk::Iterator &  iterator )

inlineprotected

                                                             {
        Chunk::Iterator copy(iterator);
        content->seekIterator(copy, iterator.getPosition());
        return iterator.getPosition() == copy.getPosition() && (iterator.getIndex() == -1 || iterator.getIndex() == copy.getIndex());
    }

Referenced by moveIteratorOrRemove(), push(), and remove().

moveIteratorOrRemove()

void inet::ChunkQueue::moveIteratorOrRemove ( b  length )

protected

{
    poppedLength += length;
    content->moveIterator(iterator, length);
    if (iterator.getPosition() > content->getChunkLength() / 2)
        remove(iterator.getPosition());
    CHUNK_CHECK_IMPLEMENTATION(isIteratorConsistent(iterator));
}

Referenced by pop().

peek() [1/2]

const Ptr< const Chunk > inet::ChunkQueue::peek	(	b	length = b(-1),
		int	flags = 0
	)		const

Returns the designated data from the head of the queue as an immutable chunk in its current representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

{
    CHUNK_CHECK_USAGE(b(-1) <= length && length <= getLength(), "length is invalid");
    return content->peek(iterator, length == b(-1) ? Chunk::unspecifiedLength : length, flags);
}

Referenced by inet::tcp::TcpLwipSendQueue::getBytesForTcpLayer(), and pop().

peek() [2/2]

template<typename T >

const Ptr<const T> inet::ChunkQueue::peek ( b  length = b(-1), int  flags = 0  ) const

inline

Returns the designated data from the head of the queue as an immutable chunk in the requested representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

                                                                   {
        return content->peek<T>(iterator, length == b(-1) ? Chunk::unspecifiedLength : length, flags);
    }

peekAll()

const Ptr<const Chunk> inet::ChunkQueue::peekAll ( int  flags = 0 ) const

inline

Returns all data in the queue in the current representation.

The length of the returned chunk is the same as the value returned by getLength().

                                                        {
        return peekAt(b(0), getLength(), flags);
    }

peekAllAsBits()

const Ptr<const BitsChunk> inet::ChunkQueue::peekAllAsBits ( int  flags = 0 ) const

inline

Returns all data in the queue in the as a sequence of bits.

The length of the returned chunk is the same as the value returned by getLength().

                                                                  {
        return peekAt<BitsChunk>(b(0), getLength(), flags);
    }

peekAllAsBytes()

const Ptr<const BytesChunk> inet::ChunkQueue::peekAllAsBytes ( int  flags = 0 ) const

inline

Returns all data in the queue in the as a sequence of bytes.

The length of the returned chunk is the same as the value returned by getLength().

                                                                    {
        return peekAt<BytesChunk>(b(0), getLength(), flags);
    }

peekAt() [1/2]

const Ptr< const Chunk > inet::ChunkQueue::peekAt	(	b	offset,
		b	length,
		int	flags = 0
	)		const

Returns the designated data at the given offset as an immutable chunk in its current representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

{
    CHUNK_CHECK_USAGE(b(0) <= offset && offset <= getLength(), "offset is out of range");
    CHUNK_CHECK_USAGE(b(-1) <= length && offset + length <= getLength(), "length is invalid");
    return content->peek(Chunk::Iterator(true, iterator.getPosition() + offset, -1), length == b(-1) ? Chunk::unspecifiedLength : length, flags);
}

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

peekAt() [2/2]

template<typename T >

const Ptr<const T> inet::ChunkQueue::peekAt ( b  offset, b  length = b(-1), int  flags = 0  ) const

inline

Returns the designated data at the given offset as an immutable chunk in the requested representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

                                                                               {
        CHUNK_CHECK_USAGE(b(0) <= offset && offset <= getLength(), "offset is out of range");
        CHUNK_CHECK_USAGE(b(-1) <= length && offset + length <= getLength(), "length is invalid");
        return content->peek<T>(Chunk::Iterator(true, iterator.getPosition() + offset, -1), length == b(-1) ? Chunk::unspecifiedLength : length, flags);
    }

pop() [1/2]

const Ptr< const Chunk > inet::ChunkQueue::pop	(	b	length = b(-1),
		int	flags = 0
	)

Pops the designated data and returns it as an immutable chunk in its current representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

{
    CHUNK_CHECK_USAGE(b(-1) <= length && length <= getLength(), "length is invalid");
    const auto& chunk = peek(length == b(-1) ? Chunk::unspecifiedLength : length, flags);
    if (chunk != nullptr)
        moveIteratorOrRemove(chunk->getChunkLength());
    return chunk;
}

Referenced by inet::tcp::TcpLwipSendQueue::dequeueTcpLayerMsg(), inet::tcp::TcpSendQueue::discardUpTo(), inet::tcp::TcpLwipReceiveQueue::extractBytesUpTo(), inet::TcpGenericServerApp::handleMessage(), inet::bgp::BgpRouter::socketDataArrived(), and inet::Ldp::socketDataArrived().

pop() [2/2]

template<typename T >

const Ptr<const T> inet::ChunkQueue::pop ( b  length = b(-1), int  flags = 0  )

inline

Pops the designated data from the head of the queue and returns it as an immutable chunk in the requested representation.

If the length is unspecified, then the length of the result is chosen according to the internal representation.

                                                            {
        const auto& chunk = peek<T>(length == b(-1) ? Chunk::unspecifiedLength : length, flags);
        if (chunk != nullptr)
            moveIteratorOrRemove(chunk->getChunkLength());
        return chunk;
    }

push()

void inet::ChunkQueue::push

(

const Ptr< const Chunk > &

chunk

)

Inserts the provided chunk at the tail of the queue.

{
    CHUNK_CHECK_USAGE(chunk != nullptr, "chunk is nullptr");
    CHUNK_CHECK_USAGE(chunk->getChunkLength() > b(0), "chunk is empty");
    constPtrCast<Chunk>(chunk)->markImmutable();
    pushedLength += chunk->getChunkLength();
    if (content == EmptyChunk::singleton)
        content = chunk;
    else {
        if (content->canInsertAtBack(chunk)) {
            const auto& newContent = makeExclusivelyOwnedMutableChunk(content);
            newContent->insertAtBack(chunk);
            newContent->markImmutable();
            content = newContent->simplify();
        }
        else {
            auto sequenceChunk = makeShared<SequenceChunk>();
            sequenceChunk->insertAtBack(content);
            sequenceChunk->insertAtBack(chunk);
            sequenceChunk->markImmutable();
            content = sequenceChunk;
            content->seekIterator(iterator, iterator.getPosition());
        }
    }
    CHUNK_CHECK_IMPLEMENTATION(isIteratorConsistent(iterator));
}

Referenced by inet::tcp::TcpSendQueue::enqueueAppData(), inet::tcp::TcpLwipSendQueue::enqueueAppData(), inet::tcp::TcpLwipReceiveQueue::enqueueTcpLayerData(), inet::TcpGenericServerApp::handleMessage(), and inet::TcpSocket::ReceiveQueueBasedCallback::socketDataArrived().

remove()

void inet::ChunkQueue::remove ( b  length )

protected

{
    CHUNK_CHECK_IMPLEMENTATION(b(0) <= length && length <= iterator.getPosition());
    if (content->getChunkLength() == length)
        content = EmptyChunk::singleton;
    else if (content->canRemoveAtFront(length)) {
        const auto& newContent = makeExclusivelyOwnedMutableChunk(content);
        newContent->removeAtFront(length);
        newContent->markImmutable();
        content = newContent;
    }
    else
        content = content->peek(length, content->getChunkLength() - length);
    content->seekIterator(iterator, iterator.getPosition() - length);
    CHUNK_CHECK_IMPLEMENTATION(isIteratorConsistent(iterator));
}

Referenced by moveIteratorOrRemove().

str()

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

overridevirtual

Returns a human readable string representation.

{
    std::stringstream stream;
    if (iterator.getPosition() == b(0))
        stream << content;
    else
        stream << content->peek(iterator);
    return stream.str();
}

Referenced by inet::operator<<(), and inet::tcp::TcpSendQueue::str().

Friends And Related Function Documentation

ChunkQueueDescriptor

friend class ChunkQueueDescriptor

friend

Member Data Documentation

content

Ptr<const Chunk> inet::ChunkQueue::content

protected

This chunk is always immutable to allow arbitrary peeking.

Nevertheless it's reused if possible to allow efficient merging with newly added chunks.

Referenced by ChunkQueue(), clear(), moveIteratorOrRemove(), peek(), peekAt(), push(), remove(), and str().

iterator

Chunk::Iterator inet::ChunkQueue::iterator

protected

Referenced by clear(), moveIteratorOrRemove(), peek(), peekAt(), push(), remove(), and str().

poppedLength

b inet::ChunkQueue::poppedLength = b(0)

protected

Referenced by clear(), and moveIteratorOrRemove().

pushedLength

b inet::ChunkQueue::pushedLength = b(0)

protected

Referenced by push().

---

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

• ChunkQueue.h
• ChunkQueue.cc