// Copyright (c) 1998-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:

//

#include "UD_STD.H"

#define UNUSED_VAR(a) a = a

// Class TDbColumn

EXPORT_C void TDbColumn::SetL(const TAny* aPtr,TInt aSize)

	{

	Mem::Copy(Row().SetColumnWidthL(iColumn,aSize),aPtr,aSize);

	}

EXPORT_C void TDbColumn::SetL(TUint32 aValue)

	{

	*(TUint32*)Row().SetColumnWidthL(iColumn,sizeof(aValue))=aValue;

	}

EXPORT_C void TDbColumn::SetL(TInt64 aValue)

	{

	*(TInt64*)Row().SetColumnWidthL(iColumn,sizeof(aValue))=aValue;

	}

EXPORT_C void TDbColumn::SetL(TReal32 aValue) __SOFTFP

	{

	*(TReal32*)Row().SetColumnWidthL(iColumn,sizeof(aValue))=aValue;

	}

EXPORT_C void TDbColumn::SetL(TReal64 aValue) __SOFTFP

	{

	*(TReal64*)Row().SetColumnWidthL(iColumn,sizeof(aValue))=aValue;

	}

EXPORT_C void TDbColumn::SetL(const TDesC8& aValue)

	{

	SetL(aValue.Ptr(),aValue.Length());

	}

EXPORT_C void TDbColumn::SetL(const TDesC16& aValue)

	{

	SetL(aValue.Ptr(),aValue.Length()<<1);

	}

EXPORT_C void TDbColumn::SetBlobL(TDbBlobId aBlobId,TInt aSize)

	{

	new(Row().SetColumnWidthL(iColumn,TDbBlob::RefSize())) TDbBlob(aBlobId,aSize);

	}

EXPORT_C void TDbColumn::SetBlobL(const TUint8* aData,TInt aSize)

	{

	new(Row().SetColumnWidthL(iColumn,TDbBlob::InlineSize(aSize))) TDbBlob(aData,aSize);

	}

EXPORT_C TDbBlob& TDbColumn::InitBlobL()

	{

	return *new(Row().SetColumnWidthL(iColumn,sizeof(TDbBlob))) TDbBlob;

	}

EXPORT_C void TDbColumn::CommitBlob(const TDbBlob& aBlob)

	{

#if defined(_DEBUG)

	TDbColumnC colC(*this);

	__ASSERT(&colC.Blob()==&aBlob);

	__ASSERT(colC.Size()>=aBlob.CellSize());

#endif

	TRAPD(errCode, Row().SetColumnWidthL(iColumn,aBlob.Size() ? aBlob.CellSize() : 0));

    UNUSED_VAR(errCode);

	}

// The row buffer

// Minimum data width is 4 bytes for strict alignment

// No integral set members for small integers and extractors do the cast down from 4-byte integers

EXPORT_C RDbRow::RDbRow()

//

// default to dynamic-owned empty row buffer

//

	:iFirst(0),iLast(0),iEnd(0),iCell(0),iColumn(TUint(EOwned))

	{}

EXPORT_C void RDbRow::Open(TAny* aBuf,TInt aSize,TInt aMaxSize)

//

// Use the provided row buffer

//

	{

	iFirst=(TDbCell*)aBuf;

	iEnd=PtrAdd(iFirst,aMaxSize);

	iColumn=0;			// non-owned buffer

	SetSize(aSize);

	}

EXPORT_C void RDbRow::CreateL(TInt aMaxSize)

	{

	__ASSERT(!iFirst && Owned());

	GrowL(aMaxSize);

	}

void RDbRow::PushL()

//

// Dynamic reallocation requires that the buffer is pushed

//

	{

	CleanupClosePushL(*this);

	}

EXPORT_C void RDbRow::Close()

//

// release the buffer if owned, and return to default constructed state

//

	{

	if (Owned())

		User::Free(iFirst);

	iFirst=iLast=iEnd=iCell=0;

	iColumn=TUint(EOwned);

	}

EXPORT_C void RDbRow::SetSize(TInt aSize)

//

// Set the current buffer size: assert that it is valid

//

	{

	__ASSERT(PtrAdd(iFirst,aSize)<=iEnd);

	iLast=PtrAdd(iFirst,aSize);

	SetCache(iFirst,0);

	}

EXPORT_C void RDbRow::GrowL(TInt aMaxSize)

//

// Grow the buffer to at least aMaxSize, the buffer empty on return

//

	{

	if (aMaxSize>MaxSize())

		{

		ReallocL(aMaxSize);

		Reset();

	//

		__ASSERT(iFirst<=iEnd);

		__ASSERT(iFirst<=iLast && iLast<=iEnd);

		__ASSERT(iFirst<=iCell && iCell<=iLast);

		}

	}

void RDbRow::ExtendL(TInt aAdjust)

//

// Adjust the buffer length by aAdjust, leave if no room, preserve contents and cache

//

	{

	TDbCell* newLast=PtrAdd(iLast,aAdjust);

	if (newLast>iEnd)

		{

		TInt move=ReallocL(Diff(iFirst,newLast));

		iCell=PtrAdd(iCell,move);

		newLast=PtrAdd(newLast,move);

		}

	iLast=newLast;

// check invariant

	__ASSERT(iFirst<=iEnd);

	__ASSERT(iFirst<=iLast && iLast<=iEnd);

	__ASSERT(iFirst<=iCell && iCell<=iLast);

	}

TInt RDbRow::ReallocL(TInt aMaxSize)

//

// Grow the buffer to aMaxSize, return the offset of buffer movement

// leave iLast and cache untouched

//

	{

	__ASSERT(aMaxSize>MaxSize());

	if (!Owned())

		__LEAVE(KErrTooBig);	// cannot reallocate if not owned

//

	aMaxSize+=EGranularity-1;

	aMaxSize&=~(EGranularity-1);

	TDbCell* buf=(TDbCell*)User::ReAllocL(iFirst,aMaxSize);

	TInt move=Diff(iFirst,buf);

	iFirst=buf;

	iEnd=PtrAdd(buf,aMaxSize);

	return move;

	}

TDbCell* RDbRow::Column(TInt aColIx) const

//

// aCol is now zero-based

// Return a pointer to column aCol in the buffer

// Return 0 if the column is past the end

//

	{

	TInt ix=Column();

	TDbCell* pC;

	if (aColIx<ix)

		{

		ix=0;

		pC=iFirst;

		}

	else

		pC=iCell;

	TDbCell* last=iLast;

	for (;;)

		{

		if (pC>=last)

			break;

		if (ix>=aColIx)

			break;

		pC=pC->Next();

		++ix;

		}

	CONST_CAST(RDbRow*,this)->SetCache(pC,ix);

	return pC<last?pC:0;

	}

LOCAL_C const TDbCell* NullCell()

	{

	static TUint32 const NullCell[3]={0,0,0};	// 3 zero words represent any "Null" value

//

	return REINTERPRET_CAST(const TDbCell*,&NullCell[0]);

	}

EXPORT_C const TDbCell* RDbRow::ColCell(TDbColNo aColNo) const

	{

	__ASSERT(aColNo>0);

	const TDbCell* cell=Column(aColNo-1);

	return cell && cell->Length() ? cell : NullCell();

	}

EXPORT_C TAny* RDbRow::SetColumnWidthL(TDbColNo aColNo,TInt aWidth)

// set the width for column aCol to Width

// add extra NULL columns to buffer as required

// return pointer to data for that column

	{

	__ASSERT(aColNo>0);

	TDbCell* pC=Column(--aColNo);

	if (pC==0)

		{		// add extra NULL columns to buffer

		if (aWidth==0)

			return 0;	// setting to NULL, don't bother padding

		TInt cFill=(aColNo-iColumn)*sizeof(TInt);

		ExtendL(cFill+TDbCell::Size(aWidth));

		pC=iCell;

		Mem::FillZ(pC,cFill);

		pC=PtrAdd(pC,cFill);		// set cache

		SetCache(pC,aColNo);

		}

	else

		{

		TInt adjust=TDbCell::Size(aWidth)-pC->Size();	// how much to add

		if (adjust!=0)

			{

			ExtendL(adjust);

			pC=iCell;		// may have moved in extension

			TDbCell* pNext=pC->Next();

			TDbCell* pAdjust=PtrAdd(pNext,adjust);

			Mem::Move(pAdjust,pNext,Diff(pAdjust,iLast));

			}

		}

	pC->SetLength(aWidth);

	return pC->Data();

	}