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

//#define __READBIT_CLASS

//#define __WRITEBIT_CLASS

#ifdef __READBIT_CLASS

class TReadBitSequence

	{

public:

	inline TReadBitSequence();

	inline TBool HasBits() const;

	TUint Read(const TUint8*& aPtr);

private:

	TUint iBits;

	};

inline TReadBitSequence::TReadBitSequence()

	:iBits(0) {}

inline TBool TReadBitSequence::HasBits() const

	{return (iBits&0x2000000);}

TUint TReadBitSequence::Read(const TUint8*& aPtr)

	{

	iBits>>=1;

	if ((iBits&0x1000000)==0)

		iBits=*aPtr++ | 0xff000000u;

	return iBits&1;

	}

#define READBITINIT(This) TReadBitSequence This

#define READHASBITS(This) This.HasBits()

#define READBIT(This,ptr) This.Read(ptr)

#define SKIPBIT(This,ptr) READBIT(This,ptr)

#else

#define READBITINIT(This) TUint This##_bits=0

#define READHASBITS(This) (This##_bits&0x2000000)

#define SKIPBIT(This,ptr) (This##_bits>>=1,(This##_bits&0x1000000 ? void(0) : void(This##_bits=*ptr++|0xff000000u)))

#define READBIT(This,ptr) (SKIPBIT(This,ptr),This##_bits&1)

#endif

#ifdef __WRITEBIT_CLASS

class TWriteBitSequence

	{

public:

	inline TWriteBitSequence();

	TUint8* Write(TUint8* aPtr,TUint aBit);

	void Flush();

private:

	TUint iBits;

	TUint8* iPtr;

	};

inline TWriteBitSequence::TWriteBitSequence()

	:iBits(0),iPtr(0) {}

TUint8* TWriteBitSequence::Write(TUint8* aPtr,TUint aBit)

	{

	TUint bits=iBits>>1;

	if ((bits&0x1000000)==0)

		{

		if (iPtr)

			*iPtr=TUint8(bits);

		iPtr=aPtr++;

		bits=0xff000000;

		}

	if (aBit)

		bits|=0x100;

	iBits=bits;

	return aPtr;

	}

void TWriteBitSequence::Flush()

	{

	TUint8* ptr=iPtr;

	if (ptr)

		{

		TUint bits=iBits;

		do bits>>=1; while (bits&0x1000000);

		*ptr=TUint8(bits);

		}

	}

#define WRITEBITINIT(This) TWriteBitSequence This

#define WRITEBIT(This,ptr,bit) ptr=This.Write(ptr,bit)

#define WRITEZEROBIT(This,ptr) ptr=This.Write(ptr,0)

#define FLUSHBITS(This) This.Flush()

#else

#define WRITEBITINIT(This) TUint32 This##_bits=0; TUint8* This##_ptr=0

#define NEXTBIT(This,ptr) This##_bits>>=1;if ((This##_bits&0x1000000)==0){if (This##_ptr) *This##_ptr=TUint8(This##_bits);This##_ptr=ptr++;This##_bits=0xff000000;}

#define WRITEZEROBIT(This,ptr) {NEXTBIT(This,ptr)}

#define WRITEBIT(This,ptr,bit) {NEXTBIT(This,ptr) if (bit) This##_bits|=0x100;}

#define FLUSHBITS(This) {if (This##_ptr){do This##_bits>>=1; while (This##_bits&0x1000000);*This##_ptr=TUint8(This##_bits);}}

#endif

LOCAL_C const TUint8* Read32(const TUint8* aPtr,TUint32* aDest)

// fast read for non-aligned little-endian 32-bit data

	{

	TUint32 x=*aPtr++;

	x|=*aPtr++<<8;

	x|=*aPtr++<<16;

	x|=*aPtr++<<24;

	*aDest=x;

	return aPtr;

	}

LOCAL_C TUint8* Write32(TUint8* aPtr,TUint32 aVal)

// fast transfer for non-aligned little-endian 32-bit data

	{

	*aPtr++=TUint8(aVal);

	*aPtr++=TUint8(aVal>>8);

	*aPtr++=TUint8(aVal>>16);

	*aPtr++=TUint8(aVal>>24);

	return aPtr;

	}

inline const TUint8* Read16(const TUint8* aPtr,TUint32* aDest)

// Read unsigned 16-bit value into aDest storage

	{

	TUint x=*aPtr++;

	x|=*aPtr++<<8;

	*aDest=TUint16(x);

	return aPtr;

	}

inline const TUint8* Read16s(const TUint8* aPtr,TUint32* aDest)

// Read signed 16-bit value into aDest storage

	{

	TInt x=*aPtr++<<16;

	x|=*aPtr++<<24;

	*aDest=x>>16;

	return aPtr;

	}

inline TUint8* Write16(TUint8* aPtr,TUint aVal)

// Write little-endian rep of the low 16 bits of aVal

	{

	*aPtr++=TUint8(aVal);

	*aPtr++=TUint8(aVal>>8);

	return aPtr;

	}

LOCAL_C TUint8* WriteCardinality(TUint8* aPtr,TUint aVal)

// compress cardinality into the data stream

	{

	__ASSERT(aVal<(1u<<30));

	if ((aVal>>7)==0)

		{

		*aPtr++=TUint8(aVal<<1);

		return aPtr;

		}

	aVal=(aVal<<2)|1;

	if ((aVal>>16)==0)

		{

		*aPtr++=TUint8(aVal);

		*aPtr++=TUint8(aVal>>8);

		return aPtr;

		}

	return Write32(aPtr,aVal|2);

	}

LOCAL_C TUint ReadCardinality(const TUint8* aPtr)

// extract cardinality from the data stream

	{

	TUint x=aPtr[0];

	if ((x&1)==0)

		return x>>1;

	x|=aPtr[1]<<8;

	if (x&2)

		{

		x|=aPtr[2]<<16;

		x|=aPtr[3]<<24;

		}

	return x>>2;

	}

LOCAL_C const TUint8* ReadCardinality(const TUint8* aPtr,TInt& aVal)

// extract cardinality from the data stream

	{

	TUint x=*aPtr++;

	if ((x&1)==0)

		x>>=1;

	else

		{

		x|=*aPtr++<<8;

		if (x&2)

			{

			x|=*aPtr++<<16;

			x|=*aPtr++<<24;

			}

		x>>=2;

		}

	aVal=x;

	return aPtr;

	}

LOCAL_C TInt SizeOfCardinality(TUint aVal)

// report the externalized size of the Compressed value in bytes

	{

	if ((aVal>>7)==0)

		return 1;

	return (aVal>>14)==0 ? 2 : 4;

	}

LOCAL_C TUint8* WriteBlobId(TUint8* aPtr,TDbBlobId aId)

	{

	return WriteCardinality(aPtr,(aId>>24)|(aId<<8>>4));

	}

LOCAL_C const TUint8* ReadBlobId(const TUint8* aPtr,TDbBlobId& aId)

	{

	aPtr=ReadCardinality(aPtr,*reinterpret_cast<TInt*>(&aId));

	aId=(aId>>4)|(aId<<28>>4);

	return aPtr;

	}

LOCAL_C TInt SizeOfBlobId(TDbBlobId aId)

	{

	return SizeOfCardinality((aId>>24)|(aId<<8>>4));

	}

// Class CDbStoreTable

CDbStoreTable::CDbStoreTable(CDbStoreDatabase& aDatabase,const CDbTableDef& aDef)

	: CDbTable(aDatabase,aDef)

	{}

CDbRecordSpace* CDbStoreTable::RecordSpaceL()

//

// open records handler

//

	{

	return CDbStoreRecords::NewL(Database().ClusterCacheL(),Def());

	}

CDbBlobSpace* CDbStoreTable::BlobSpaceL()

//

// Open a blobs accessor for the table

//

	{

	return new(ELeave) CDbStoreBlobs(Database(),Def().InlineLimit());

	}

CDbRecordIndex* CDbStoreTable::RecordIndexL(const CDbTableIndexDef& anIndex)

//

// Open an index

//

	{

	return CDbStoreIndex::NewL(Database(),(const CDbStoreIndexDef&)anIndex,Def());

	}

static TUint8* CompressUnicode(TUint8* aRec,const TAny* aData,TInt aSize)

//

// initially assume the compressed data requires 1 byte for the length data

// Copy it if more is necessary. This avoids having to run the compressor twice

//

	{

	TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));

	TUnicodeCompressor compressor;

	TInt output;

	compressor.CompressL(aRec+1,source,KMaxTInt,aSize>>1,&output);

	TInt lenSize=SizeOfCardinality(output);

	if (lenSize!=1)

		Mem::Copy(aRec+lenSize,aRec+1,output);	// needs more space for length

	return WriteCardinality(aRec,output)+output;

	}

static TInt SizeOfCompressedUnicode(const TAny* aData,TInt aSize)

//

// bytes required to store the unicode data

//

	{

	TMemoryUnicodeSource source(reinterpret_cast<const TUint16*>(aData));

	TInt size=TUnicodeCompressor::CompressedSizeL(source,aSize>>1);

	return SizeOfCardinality(size)+size;

	}

static const TUint8* ExpandUnicodeL(const TUint8* aRec,TAny* aTarget,const TAny* aLimit,TInt& aChars)

//

// Read compressed unicode from the record

//

	{

	TInt bytes;

	aRec=ReadCardinality(aRec,bytes);

	TMemoryUnicodeSink unicode(reinterpret_cast<TUint16*>(aTarget));

	TUnicodeExpander expander;

	TInt used;

	expander.ExpandL(unicode,aRec,(TUint16*)aLimit-(TUint16*)aTarget,bytes,&aChars,&used);

	return bytes==used ? aRec+bytes : 0;	// signal corruption in data, could not fit text in space

	}

static TInt SizeOfExpandedUnicodeL(const TUint8* aData,TInt aSize)

//

// bytes required to store the unicode data

//

	{

	return TUnicodeExpander::ExpandedSizeL(aData,aSize)<<1;

	}

TInt CDbStoreTable::RecordLength(const RDbRow& aRow)

//

// Calculate the size of a record

//

	{

	TInt bits=SizeOfCardinality(OptimizedRowLength(aRow))<<3;		// record buffer size

	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

	const TDbCell* const last=aRow.Last();

	for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())

		{

		__ASSERT(col<Def().Columns().End());	// columns off end

		TInt size=column->Length();

		if ((col->iAttributes&TDbCol::ENotNull)==0)

			{	//nullable

			++bits;

			if (size==0)

				continue;			// no data

			}

		__ASSERT(size>0);	// must be non-null to reach here

		TDbColType type=col->Type();

		__ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);

		if (type==EDbColBit)

			++bits;

		else if (type<=EDbColDateTime)

			bits+=TRecordSize::FixedFieldSize(type)<<3;

		else if (type==EDbColText16)

			bits+=SizeOfCompressedUnicode(column->Data(),size)<<3;

		else if (type<=EDbColBinary)

			bits+=8+(size<<3);

		else

			{

			__ASSERT(type<=EDbColLongBinary);

			const TDbBlob& blob=*(const TDbBlob*)column->Data();

			if (!blob.IsInline())

				bits+=1+((SizeOfBlobId(blob.Id())+SizeOfCardinality(blob.Size()))<<3);

			else if (type!=EDbColLongText16)

				bits+=9+(blob.Size()<<3);

			else

				bits+=1+(SizeOfCompressedUnicode(blob.Data(),blob.Size())<<3);

			}

		}

	__ASSERT(bits<=(KDbStoreMaxRecordLength<<3));

	return (bits+7)>>3;

	}

TInt CDbStoreTable::OptimizedRowLength(const RDbRow& aRow)

//

// Calculate the minimal row buffer size (in words) to store the row data

//

	{

	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

	const TDbCell* const last=aRow.Last();

	TInt cellHead=0;

	TInt words=0;

	for (const TDbCell* column=aRow.First();column<last;++col,column=column->Next())

		{

		++cellHead;

		__ASSERT(col<Def().Columns().End());	// columns off end

		TInt size=column->Length();

		if (size==0)

			continue;

		words+=cellHead;

		cellHead=0;

		TDbColType type=col->Type();

		__ASSERT(type>=EDbColBit&&type<=EDbColLongBinary);

		if (type<=EDbColDateTime)

			__ASSERT(size==(size>>2<<2));

		else if (type<=EDbColBinary)

			;

		else

			size=((const TDbBlob*)column->Data())->CellSize();

		words+=(size+3)>>2;

		}

	return words;

	}

void CDbStoreTable::CopyFromRow(TUint8* aRecord,const RDbRow& aRow)

//

// translate the row buffer into its persistent format in the record buffer

//

	{

	aRecord=WriteCardinality(aRecord,OptimizedRowLength(aRow));	// internal size

//

	WRITEBITINIT(bits);

	HDbColumnSet::TIteratorC iter=Def().Columns().Begin();

	const TDbCell* const last=aRow.Last();

	for (const TDbCell* column=aRow.First();column<last;++iter,column=column->Next())

		{

		__ASSERT(iter<Def().Columns().End());	// columns off end

		TInt size=column->Length();

		if ((iter->iAttributes&TDbCol::ENotNull)==0)

			{	// nullable

			WRITEBIT(bits,aRecord,size!=0);

			if (size==0)

				continue;			// no data

			}

		__ASSERT(size>0);	// must be non-null to reach here

		const TUint32* data=(const TUint32*)column->Data();

		TDbColType type=iter->Type();

		switch (type)

			{

		default:

			__ASSERT(0);

		case EDbColBit:

			WRITEBIT(bits,aRecord,*data);

			break;

		case EDbColInt8:

		case EDbColUint8:

			*aRecord++=TUint8(*data);

			break;

		case EDbColInt16:

		case EDbColUint16:

			aRecord=Write16(aRecord,*data);

			break;

#if defined(__DOUBLE_WORDS_SWAPPED__)

		case EDbColReal64:

			aRecord=Write32(aRecord,data[1]);	// write low word out first

			// drop through to write high word next

#endif

		case EDbColInt32:

		case EDbColUint32:

		case EDbColReal32:

			aRecord=Write32(aRecord,*data);

			break;

#if !defined(__DOUBLE_WORDS_SWAPPED__)

		case EDbColReal64:

#endif

		case EDbColInt64:

		case EDbColDateTime:

			aRecord=Write32(aRecord,data[0]);

			aRecord=Write32(aRecord,data[1]);

			break;

		case EDbColText16:

			aRecord=CompressUnicode(aRecord,data,size);

			break;

		case EDbColText8:

		case EDbColBinary:

			*aRecord++=TUint8(size);

			aRecord=Mem::Copy(aRecord,data,size);

			break;

		case EDbColLongText8:

		case EDbColLongText16:

		case EDbColLongBinary:

			{

			const TDbBlob& blob=*reinterpret_cast<const TDbBlob*>(data);

			size=blob.Size();

			WRITEBIT(bits,aRecord,blob.IsInline());

			if (blob.IsInline())

				{

				if (type==EDbColLongText16)

					aRecord=CompressUnicode(aRecord,blob.Data(),size);

				else

					{

					*aRecord++=TUint8(size);

					aRecord=Mem::Copy(aRecord,blob.Data(),size);

					}

				}

			else

				{

				aRecord=WriteBlobId(aRecord,blob.Id());

				aRecord=WriteCardinality(aRecord,size);

				}

			}

			break;

			}

		}

	FLUSHBITS(bits);

	}

const TUint8* CDbStoreTable::CopyToRowL(TDbCell* aCell,TInt aSize,const TUint8* aRec)

//

// translate persistent record into the row buffer

//

	{

	__ASSERT(aSize>0);

//

	const TDbCell* const end=PtrAdd(aCell,aSize);

	READBITINIT(bits);

	HDbColumnSet::TIteratorC col=Def().Columns().Begin();

	HDbColumnSet::TIteratorC const cend=Def().Columns().End();

	for (;;)

		{

		TInt size=0; //null data

		if (col->iAttributes&TDbCol::ENotNull || READBIT(bits,aRec))	// have data

			{

			if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TUint32))

				return 0;

			size=sizeof(TUint32);	// for most types

			TDbColType type=col->Type();

			switch (type)

				{

			default:

				__ASSERT(0);

			case EDbColBit:

				*(TUint32*)aCell->Data()=READBIT(bits,aRec);

				break;

			case EDbColInt8:

				*(TInt32*)aCell->Data()=*(const TInt8*)aRec;

				aRec+=sizeof(TInt8);

				break;

			case EDbColUint8:

				*(TUint32*)aCell->Data()=*aRec;

				aRec+=sizeof(TUint8);

				break;

			case EDbColInt16:

				aRec=Read16s(aRec,(TUint32*)aCell->Data());

				break;

			case EDbColUint16:

				aRec=Read16(aRec,(TUint32*)aCell->Data());

				break;

	#if defined(__DOUBLE_WORDS_SWAPPED__)

			case EDbColReal64:

				if (TInt(end)-TInt(aCell)<=(TInt)sizeof(TReal64))

					return 0;

				size=sizeof(TReal64);

				aRec=Read32(aRec,(TUint32*)aCell->Data()+1);	// transfer low word first, to high address

				// drop through to transfer high word to low address!

	#endif

			case EDbColInt32:

			case EDbColUint32:

			case EDbColReal32:

				aRec=Read32(aRec,(TUint32*)aCell->Data());