// Copyright (c) 2008-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:
// @file
// @internalComponent
// 
//

#include <e32base.h>
#include "rmemcell.h"
#include "rmemchunk.h"

EXPORT_C TInt RMemChunk::Alloc ( TInt aSize, RMemoryAllocator& aAllocator )
	{
	if ( aSize == 0 )
		{
		return KErrNone;
		}
		
	__ASSERT_ALWAYS ( iNextCell == NULL, User::Invariant () ); //TODO
	iNextCell = aAllocator.ChunkManager ()->Alloc ( aSize );
	return iNextCell == NULL ? KErrNoMemory : KErrNone;
	}
	
EXPORT_C void RMemChunk::CreateL ( const TDesC8& aDes, RMemoryAllocator& aAllocator )
	{
	User::LeaveIfError ( Create ( aDes, aAllocator ) );
	}
	
EXPORT_C TInt RMemChunk::Create ( const TDesC8& aDes, RMemoryAllocator& aAllocator )
	{
	TInt err = Alloc ( aDes.Length (), aAllocator );
	if ( err == KErrNone )
		{
		// copy descriptor to the memchunk allocated.
		CopyIn(aDes);
		}
	return  err;
	}
	
EXPORT_C void RMemChunk::Free ()
	{
	if ( iNextCell )
		iNextCell->Free ();
	iNextCell = NULL;
	}

EXPORT_C void RMemChunk::CopyIn(const TDesC8& aDes, TInt aOffset)
	{
	__ASSERT_ALWAYS(iNextCell!=NULL, User::Invariant ());
	__ASSERT_ALWAYS(aOffset>=0, User::Invariant ());

	TUint8* ptr = (TUint8*)aDes.Ptr();
	TInt len = aDes.Length();

	TInt n;
	RMemCell* m=iNextCell;

	while (len>0 && m!=NULL)
		{
		n = len > m->Length() ? m->Length() : len;
		Mem::Copy(m->Ptr(), ptr, n);
		ptr += n;
		len -= n;
		m = m->Next();
		}
	}

EXPORT_C void RMemChunk::CopyOut(TDes8& aDes, TInt aOffset) const
	{
	__ASSERT_ALWAYS(aOffset>=0, User::Invariant ());

	TUint8* ptr = (TUint8*)aDes.Ptr();
	TInt len = aDes.Length();

	TInt n;
	RMemCell* m = iNextCell;
	
	while (len>0 && m!=NULL)
		{
		n = len > m->Length() ? m->Length() : len;
		Mem::Copy(ptr, m->Ptr(), n);
		ptr += n;
		len -= n;
		m = m->Next();
		}
	aDes.SetLength(ptr-aDes.Ptr());
	}



EXPORT_C TBool RMemChunk::Goto(TInt anOffset, RMemCell* &resBuf, TInt& resOffset, TInt& resLength, RMemCell* &resPrevBuf) const
	{
	__ASSERT_ALWAYS(iNextCell!=NULL, User::Invariant ());
	__ASSERT_ALWAYS(anOffset>=0, User::Invariant ());

	TInt o = 0;
	RMemCell* p = NULL, *m = iNextCell;

	while (m!=NULL)
		{
		if (o + m->Length() > anOffset)
			{
			resBuf = m;
			resOffset = (anOffset - o) + m->Offset();
			resLength = m->Length() - (anOffset - o);
			resPrevBuf = p;
			return ETrue;
			}
		o += m->Length();
		p = m;
		m = m->Next();
		}

	__ASSERT_ALWAYS(o==anOffset, User::Invariant ());
	return EFalse;
	}

EXPORT_C TInt RMemChunk::Length() const
	{
	TInt len = 0;
	RMemCell* m;
	for (m = iNextCell; m!=NULL; m = m->Next())
		len += m->Length();

	return len;
	}

EXPORT_C void RMemChunk::TrimStart(TInt anOffset)
	{
	__ASSERT_ALWAYS(iNextCell!=NULL, User::Invariant ());
	__ASSERT_ALWAYS(anOffset>=0, User::Invariant ());

	if (anOffset==0)
		return;

	RMemCell* m, *p;
	TInt o, n;
	if (!Goto(anOffset, m, o, n, p))
		{
		Free();
		return;
		}

	if (p!=NULL) 
		{
		p->Unlink();
		iNextCell->Free();

		iNextCell = m;
		}

	if (o!=m->Offset()) 
		m->SetData(o, n);
	}

EXPORT_C void RMemChunk::Assign(RMemChunk& aChain)
	{
	__ASSERT_ALWAYS(iNextCell==NULL, User::Invariant ());
	iNextCell = aChain.iNextCell;
	aChain.Init();
	}

EXPORT_C RMemCell* TMemCellIterator::operator ++(TInt)
	{ 
	RMemCell* m=iMemCell; 
	if ( m!=NULL) 
		iMemCell=iMemCell->Next(); 
	return m; 
	}

EXPORT_C RMemCell* RMemChunk::Last() const
	{
	__ASSERT_ALWAYS(iNextCell!=NULL, User::Invariant ());

	return iNextCell->Last();
	}


EXPORT_C void RMemChunk::Append(RMemChunk& aChain)
	{
	__ASSERT_ALWAYS(iNextCell!=aChain.iNextCell, User::Invariant ());

	if (iNextCell!=NULL)
		{
		RMemCell* last	= Last();
		last->Link(aChain.iNextCell);
		}
	else
		iNextCell = aChain.iNextCell;

	aChain.Init();
	}

EXPORT_C RMemCell* RMemChunk::Remove()
	{
	if (IsEmpty())
		return NULL;
	else
		{
		RMemCell* m = iNextCell;
		iNextCell = iNextCell->Next();
		m->Unlink();
		return m;
		}
	}

EXPORT_C TInt RMemChunk::NumBufs() const
	{
	__ASSERT_ALWAYS(iNextCell!=NULL, User::Invariant ());

	TInt len = 0;
	RMemCell* m;
	for (m = iNextCell; m!=NULL; m = m->Next())
		len++;

	return len;
	}