// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// sbque.cpp - TCP sequence block queue
//

#include "sbque.h"

EXPORT_C SequenceBlock *SequenceBlockQueue::AddOrdered(TTcpSeqNum aLeft, TTcpSeqNum aRight)
	{
	SequenceBlock *current, *block = NULL;
	SequenceBlockQueueIter iter(*this);

	iter.SetToLast();
	while (current = iter--, current != NULL)
		{
		// Find correct position.
		if (aRight < current->iLeft)
			continue;

		// No overlap? Insert new block here.
		if (aLeft > current->iRight)
			{
			if (block = new SequenceBlock(aLeft, aRight), block == NULL)
				return NULL;
			block->iLink.Enque(&current->iLink);
			iCount++;
			iBytes += (aRight - aLeft);
			break;
			}

		// Already know about this block?
		if (aLeft >= current->iLeft && aRight <= current->iRight)
			{
			block = current;
			break;
			}

		// Our block partially overlaps one or more blocks.
		if (aLeft > current->iLeft)
			aLeft = current->iLeft;
		if (aRight < current->iRight)
			aRight = current->iRight;

		// Delete the previously known overlapping block.
		iBytes -= (current->iRight - current->iLeft);
		current->iLink.Deque();
		delete current;
		iCount--;
		}

	// We haven't found or created a sequence block? It goes first then.
	if (!block)
		{
		block = new SequenceBlock(aLeft, aRight);
		if (block != NULL)
			{
			AddFirst(*block);
			iCount++;
			iBytes += (aRight - aLeft);
			}
		}

	// Return the contiguous block, which the new block is belonged to.
	return block;
	}

EXPORT_C SequenceBlock *SequenceBlockQueue::AddUnordered(TTcpSeqNum aLeft, TTcpSeqNum aRight)
	{
	SequenceBlock *current, *block = NULL;
	SequenceBlockQueueIter iter(*this);

	while (current = iter++, current != NULL)
		{
		// Find overlapping blocks.
		if (aLeft > current->iRight || aRight < current->iLeft)
			continue;

		// Overlapping block exists. Extend our block accordingly.
		if (aLeft > current->iLeft)
			aLeft = current->iLeft;
		if (aRight < current->iRight)
			aRight = current->iRight;

		// Delete the previously known overlapping block.
		iBytes -= (current->iRight - current->iLeft);
		current->iLink.Deque();
		delete current;
		iCount--;
		}

	// Insert new block first in the queue.
	if (block = new SequenceBlock(aLeft, aRight), block != NULL)
		{
		AddFirst(*block);
		iOrdered = !iCount;
		iCount++;
		iBytes += (aRight - aLeft);
		}

	// Return the contiguous block, to which the new block belongs.
	return block;
	}


//
// Find a block that contains the given sequence number
//
EXPORT_C SequenceBlock *SequenceBlockQueue::Find(TTcpSeqNum aSeq)
	{
	SequenceBlock *current;
	SequenceBlockQueueIter iter(*this);

	while (current = iter++, current != NULL)
		{
		// Find correct position.
		if (aSeq >= current->iRight)
			continue;

		// Found?
		if (aSeq >= current->iLeft)
			return current;

		// We can stop here if we know the queue is ordered.
		if (iOrdered)
			break;
		}

	return NULL;
	}

//
// This only makes sense with ordered queues.
//
EXPORT_C TInt SequenceBlockQueue::FindGap(TTcpSeqNum& aLeft, TTcpSeqNum& aRight)
	{
	ASSERT(iOrdered);

	SequenceBlock *current;
	SequenceBlockQueueIter iter(*this);
	TInt skipped = 0;

    while (current = iter++, current != NULL)
        {
        TTcpSeqNum right = current->iRight;
        TTcpSeqNum left = current->iLeft;
        if (aLeft >= right)
            {
            skipped += (right - left);
            continue;
            }

        if (aLeft >= left)
            {
            skipped += (right - aLeft);
            aLeft = right;
            continue;
            }

        aRight = left;
        return skipped;
        }
    
	return -1;
	}


//
// Remove all contiguous blocks with sequence numbers
// less than aLeft.
//
EXPORT_C void SequenceBlockQueue::Prune(TTcpSeqNum aLeft)
	{
	SequenceBlock *current;
	SequenceBlockQueueIter iter(*this);

    while (current = iter++, current != NULL)
        {
        TTcpSeqNum right = current->iRight;
        TTcpSeqNum left = current->iLeft;
        
        // The whole block can go?
        if (aLeft >= right)
            {
            iBytes -= (right - left);
            current->iLink.Deque();
            delete current;
            --iCount;
            continue;
            }

        // Trim left edge of block.
        if (aLeft > left)
            {
            iBytes -= (aLeft - left);
            current->iLeft = aLeft;
            }

        // We can stop here if we know the queue is ordered.
        if (iOrdered)
            return;
        }

	if (iCount <= 1)
		iOrdered = ETrue;
	}


//
// Remove contiguous blocks from the end of the queue
// until at most aCount blocks remain.
//
EXPORT_C void SequenceBlockQueue::Limit(TInt aCount)
	{
	SequenceBlock *current;
	SequenceBlockQueueIter iter(*this);

	iter.SetToLast();
	while (iCount > aCount)
		{
		current = iter--;
		iBytes -= (current->iRight - current->iLeft);
		current->iLink.Deque();
		delete current;
		--iCount;
		}

	if (iCount <= 1)
		iOrdered = ETrue;
	}


//
// Clear the queue.
//
EXPORT_C void SequenceBlockQueue::Clear()
	{
	SequenceBlock *current;
	SequenceBlockQueueIter iter(*this);

	while (current = iter++, current != NULL)
		{
		current->iLink.Deque();
		delete current;
		}
	iCount = 0;
	iBytes = 0;
	iOrdered = ETrue;
	}