// 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 "UT_STD.H"

#include "U32STD_DBMS.H"

// Class CDbTableIndexDef

EXPORT_C CDbTableIndexDef::CDbTableIndexDef()

	{}

EXPORT_C CDbTableIndexDef::~CDbTableIndexDef()

	{

	delete iName;

	}

EXPORT_C void CDbTableIndexDef::ConstructL(const TDesC& aName)

//

// Construct with an empty key

//

	{

	iName=aName.AllocL();

	}

// Class RDbIndexes

void RDbIndexes::Close()

	{

	TSglQueIter<CDbTableIndexDef> iter(iRep);

	for (CDbTableIndexDef* def;(def=iter++)!=0;)

		delete def;

	}

CDbTableIndexDef* RDbIndexes::Find(const TDesC& aName) const

//

// Locate and index on the table by name

//

	{

	TSglQueIter<CDbTableIndexDef> iter(CONST_CAST(TSglQue<CDbTableIndexDef>&,iRep));

	for (CDbTableIndexDef* def;(def=iter++)!=0;)

		if (aName.CompareF(def->Name())==0)

			return def;

	return 0;

	}

CDbTableIndexDef& RDbIndexes::FindL(const TDesC& aName) const

//

// Leave if not found

//

	{

	CDbTableIndexDef* def=Find(aName);

	if (def==NULL)

		__LEAVE(KErrNotFound);

	return *def;

	}

EXPORT_C TInt RDbIndexes::Count() const

	{

	TInt count = 0;

	TSglQueIterC<CDbTableIndexDef> iter( iRep );

	for ( ; iter++ != 0; )

		++count;

	return count;

	}

// Class TDbColumnDef

EXPORT_C void TDbColumnDef::SetL(const TDbColumnDef& aCol)

//

// Replace assignment as this can leave

//

	{

	iMaxLength=aCol.iMaxLength;

	iType=aCol.iType;

	iAttributes=aCol.iAttributes;

	iFlags=aCol.iFlags;

	iName=aCol.iName->AllocL();

	}

EXPORT_C void TDbColumnDef::SetL(const TDbCol& aCol)

	{

	iMaxLength=aCol.iMaxLength;

	iType=TUint8(aCol.iType);

	iAttributes=TUint8(aCol.iAttributes);

	iName=aCol.iName.AllocL();

	}

void TDbColumnDef::AsTDbCol(TDbCol& aColumn) const

	{

	aColumn.iType=Type();

	aColumn.iMaxLength=iMaxLength;

	aColumn.iAttributes=iAttributes;

	aColumn.iName=*iName;

	}

// Class HDbColumnSet

HDbColumnSet* HDbColumnSet::NewL(TInt aCount)

	{

	return new(User::AllocL(_FOFF(HDbColumnSet,iColumns[aCount]))) HDbColumnSet(aCount);

	}

HDbColumnSet::HDbColumnSet(TInt aCount)

	: iAttributes(0), iIndex(NULL), iEnd(&iColumns[aCount])

	{

	Mem::FillZ(&iColumns[0],aCount*sizeof(iColumns[0]));

	}

HDbColumnSet::~HDbColumnSet()

	{

	User::Free(iIndex);

	const TIteratorC end=End();

	for (TIteratorC iter=Begin();iter<end;++iter)

		delete iter->iName;

	}

EXPORT_C TInt HDbColumnSet::Count() const

	{

	return End()-Begin();

	}

void HDbColumnSet::Complete()

//

// Called on completion of the column set

//

	{

	TUint attrib=0;

	const TIteratorC end=End();

	for (TIteratorC iter=Begin();iter<end;++iter)

		{

		if (TDbCol::IsLong(iter->Type()))

			attrib|=ELongColumns;

		if (iter->iAttributes&TDbCol::EAutoIncrement)

			attrib|=EAutoIncrement;

		}

	iAttributes=attrib;

	}

EXPORT_C HDbColumnSet::TIteratorC HDbColumnSet::ColumnL(const TDesC& aColumn) const

//

// Lookup name in the name index (binary search)

//

	{

	const TIteratorC* index=IndexL();

	TInt left=0;

	TInt right=Count();

	while (left<right)

		{

		TInt mid=(left+right)>>1;

		TInt c=index[mid]->iName->CompareF(aColumn);

		if (c<0)

			left=mid+1;

		else if (c>0)

			right=mid;

		else

			return index[mid];		// matched entry

		}

	return 0;		// no match

	}

EXPORT_C TDbColNo HDbColumnSet::ColNoL(const TDesC& aColumn) const

//

// Return ordinal for given column name

//

	{

	TIteratorC col=ColumnL(aColumn);

	return col ? 1+(col-Begin()) : KDbNullColNo;

	}

const HDbColumnSet::TIteratorC* HDbColumnSet::IndexL() const

//

// Return the by-name lookup index, building it if required

//

	{

	TIteratorC* index=iIndex;

	if (!index)

		{

		CONST_CAST(TIteratorC*&,iIndex)=index=(TIteratorC*)User::AllocL(Count()*sizeof(TIteratorC));

		TInt ii=0;

		TIteratorC col=Begin();

		TIteratorC end=End();

		do

			{

			// binary search for insertion point

			TInt left=0;

			TInt right=ii;

			while (left<right)

				{

				TInt mid=(left+right)>>1;

				TInt c=index[mid]->iName->CompareF(*col->iName);

				__ASSERT(c!=0);		// names are unique

				if (c<0)

					left=mid+1;

				else

					right=mid;

				}

			// insert the entry

			Mem::Move(index+left+1,index+left,(ii-left)*sizeof(TIteratorC));

			index[left]=col;

			} while (++ii,++col<end);

		}

	return index;

	}

// Class CDbTableDef

EXPORT_C CDbTableDef::CDbTableDef()

	{}

EXPORT_C CDbTableDef::~CDbTableDef()

	{

	delete iColumns;

	delete iName;

	iIndexes.Close();

	}

EXPORT_C void CDbTableDef::ConstructL(const TDesC& aName,TInt aColumnCount)

	{

	iName=aName.AllocL();

	iColumns=HDbColumnSet::NewL(aColumnCount);

	}

void CDbTableDef::ExchangeColumnSet(HDbColumnSet* aSet)

	{

	delete iColumns;

	iColumns=aSet;

	Changed();

	}

EXPORT_C void CDbTableDef::Changed()

//

// evaluate cached info about the set

//

	{

	iColumns->Complete();

	}

const CDbTableIndexDef* CDbTableDef::FindKey(const TDesC& aColumn,TBool aFirstColumn) const

//

// Find an index which keys on the given column

//

	{

	TSglQueIterC<CDbTableIndexDef> indexes(Indexes().AsQue());

	for (const CDbTableIndexDef* def;(def=indexes++)!=0;)

		{

		const CDbKey& key=def->Key();

		TInt ii=0;

		do

			{

			if (aColumn.CompareF(key[ii].iName)==0)

				return def;

			if (aFirstColumn)

				break;

			} while (++ii<key.Count());

		}

	return 0;

	}

// Class RDbTableSchema

void RDbTableSchema::Discard()

	{

	TSglQueIter<CDbTableDef> iter(iRep);

	for (CDbTableDef* def;(def=iter++)!=0;)

		delete def;

	iRep.Reset();

	iLoaded=EFalse;

	}

CDbTableDef* RDbTableSchema::Find(const TDesC& aTable)

	{

	__ASSERT(IsLoaded());

	TSglQueIter<CDbTableDef> iter(iRep);

	for (CDbTableDef* def;(def=iter++)!=0;)

		if (aTable.CompareF(def->Name())==0)

			return def;

	return 0;

	}

CDbTableDef& RDbTableSchema::FindL(const TDesC& aTable)

//

// Leave if not found

//

	{

	CDbTableDef* def=Find(aTable);

	if (def==NULL)

		__LEAVE(KErrNotFound);

	return *def;

	}

// Class RDbTables

void RDbTables::Close()

	{

	TSglQueIter<CDbTable> iter(iRep);

	for (CDbTable* table;(table=iter++)!=0;)

		table->Discard();

	}

CDbTable* RDbTables::Find(const TDesC& aTable)

	{

	TSglQueIter<CDbTable> iter(iRep);

	for (CDbTable* table;(table=iter++)!=0;)

		if (aTable.CompareF(table->Def().Name())==0)

			return table;

	return 0;

	}