sl@0: // Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
sl@0: // All rights reserved.
sl@0: // This component and the accompanying materials are made available
sl@0: // under the terms of "Eclipse Public License v1.0"
sl@0: // which accompanies this distribution, and is available
sl@0: // at the URL "http://www.eclipse.org/legal/epl-v10.html".
sl@0: //
sl@0: // Initial Contributors:
sl@0: // Nokia Corporation - initial contribution.
sl@0: //
sl@0: // Contributors:
sl@0: //
sl@0: // Description:
sl@0: //
sl@0: 
sl@0: #include "SqlUtil.h"
sl@0: #include "SqlBufFlat.h"
sl@0: #include "OstTraceDefinitions.h"
sl@0: 
sl@0: /**
sl@0: Sets the flat buffer pointer to NULL
sl@0: */
sl@0: RSqlBufFlat::RSqlBufFlat() :
sl@0: 	iBuf(NULL),
sl@0: 	iMaxSize(0),
sl@0: 	iBufPtr(NULL, 0)
sl@0: 	{
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: "Resource acquisiton" method.
sl@0: Sets the elements count of a new or already existing flat buffer.
sl@0: 
sl@0: The occupied memory won't be freed (in case of buffer resizing).
sl@0: The buffer content is not preserved (in case of buffer resizing).
sl@0: 
sl@0: All elements set to have:
sl@0: - invalid type;
sl@0: - zero length;
sl@0: - zero data position;
sl@0: 
sl@0: @param aCount Desired flat buffer elements count
sl@0: 
sl@0: @return KErrNone, The operation has completed successfully;
sl@0: 		KErrNoMemory, Out of memory condition has occured.
sl@0: */
sl@0: TInt RSqlBufFlat::SetCount(TInt aCount)
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(aCount >= 0, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	TInt headerSize = sizeof(RSqlBufFlat::TCell) * aCount;
sl@0: 	TInt newSize = headerSize + sizeof(RSqlBufFlat::TBufFlat);
sl@0: 	if(DoReAlloc(newSize) != KErrNone)
sl@0: 		{
sl@0: 		return KErrNoMemory;	
sl@0: 		}
sl@0: 	TBufFlat& buf = *iBuf;
sl@0: 	buf.iCount = aCount;
sl@0: 	buf.iHeaderSize = headerSize;
sl@0: 	buf.iSize = newSize;
sl@0: 	buf.iReserved = 0;
sl@0: 	DoInit();
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	return KErrNone;	
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reallocates the amount of the occupied by the flat buffer memory.
sl@0: The operation preserves the content of the flat buffer.
sl@0: Note: if the new size is less or equal to the max size of the buffer,
sl@0: 	  no memory will be allocated.
sl@0: 
sl@0: @param aSize Desired flat buffer size in bytes
sl@0: 
sl@0: @return KErrNone, The operation has completed successfully;
sl@0: 		KErrNoMemory, Out of memory condition has occured.
sl@0: */
sl@0: TInt RSqlBufFlat::ReAlloc(TInt aSize)
sl@0: 	{
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	TInt err = DoReAlloc(aSize);
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	return err;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Cleans up the flat buffer content and 
sl@0: frees the occupied memory if the memory is above KBufLimit.
sl@0: The count of elements is preserved.
sl@0: 
sl@0: If the buffer size is bigger than KBufLimit,
sl@0: the buffer will be reallocated and the buffer content - not preserved.
sl@0: 
sl@0: If the buffer size is less or equal to KBufLimit,
sl@0: no memory will be reallocated and the buffer preserves its content.
sl@0: 
sl@0: It is guaranteed that the reallocated buffer will have the same address in the heap 
sl@0: as the original one.
sl@0: */	
sl@0: void RSqlBufFlat::ResetAndMinimize()
sl@0: 	{
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	Reset();
sl@0: #ifdef _DEBUG	
sl@0: 	const TInt KBufLimit = Max((TInt)RSqlBufFlat::EExpandSize, SysDataSize());
sl@0: 	const TBufFlat* oldBuf = iBuf;
sl@0: #else
sl@0: 	const TInt KBufLimit = Max((8 * 1024), SysDataSize());
sl@0: #endif
sl@0: 	if(iMaxSize > KBufLimit)
sl@0: 		{
sl@0: 		iMaxSize = KBufLimit - 1;  //to force the reallocation
sl@0: 		(void)DoReAlloc(KBufLimit);//User::ReAlloc() does not fail if the new requested size is less than the current block size
sl@0: 		}
sl@0: 	__ASSERT_DEBUG(oldBuf == iBuf, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Cleans up the flat buffer content but does not free the occupied memory.
sl@0: The count of elements is preserved.
sl@0: 
sl@0: All elements set to have:
sl@0: - invalid type;
sl@0: - zero length;
sl@0: - zero data position;
sl@0: 
sl@0: The element count is preserved.
sl@0: */
sl@0: void RSqlBufFlat::Reset()
sl@0: 	{
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	iBuf->iSize = SysDataSize();
sl@0: 	DoInit();
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Closes the flat bufer and frees the allocated memory.
sl@0: */
sl@0: void RSqlBufFlat::Close()
sl@0: 	{
sl@0: 	User::Free(iBuf);
sl@0: 	iBuf = NULL;	
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Sets the content of a field.
sl@0: 
sl@0: @param aIndex Field index
sl@0: @param aType Field type
sl@0: @param aData Field data, may be NULL
sl@0: @param aDataLength Field data length, may be 0
sl@0: 
sl@0: @return KErrNone, The operation has completed successfully;
sl@0: 		KErrNoMemory, Out of memory condition has occured.
sl@0: */
sl@0: TInt RSqlBufFlat::SetField(TInt aIndex, TInt aType, const void* aData, TInt aDataLength)
sl@0: 	{
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	__ASSERT_DEBUG((TUint)aIndex < iBuf->iCount, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG((TUint)aType < RSqlBufFlat::EMaxType, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG((TUint)aDataLength < RSqlBufFlat::EMaxLength, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	if(aData)						//field value "present"
sl@0: 		{
sl@0: 		__ASSERT_DEBUG(aDataLength >= 0, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 		if(aDataLength > 0)
sl@0: 			{
sl@0: 			if(Reserve(aDataLength) != KErrNone)
sl@0: 				{
sl@0: 				return KErrNoMemory;	
sl@0: 				}
sl@0: 			}
sl@0: 		DoSet(aIndex, aType, aData, aDataLength);
sl@0: 		}
sl@0: 	else if(aDataLength == 0)		//data is NULL, length is 0 - "null" field
sl@0: 		{
sl@0: 		DoSet(aIndex, aType, NULL, 0);
sl@0: 		}
sl@0: 	else							//field value "not present"
sl@0: 		{
sl@0: 		RSqlBufFlat::TCell& cell = *(Header() + aIndex);
sl@0: 		cell.iBits = (TUint)(((TUint)aType << RSqlBufFlat::EWidthLen) | (TUint)aDataLength);
sl@0: 		cell.iPos = 0;
sl@0: 		}
sl@0: 	SQLFLATBUF_INVARIANT();
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 	
sl@0: /**
sl@0: Initialzies the flat buffer header.
sl@0: All field set:
sl@0: - invalid type;
sl@0: - zero length;
sl@0: - "Not present";
sl@0: */	
sl@0: void RSqlBufFlat::DoInit()
sl@0: 	{
sl@0: 	TBufFlat& buf = *iBuf;
sl@0: 	__ASSERT_DEBUG(buf.iCount >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iSize <= iMaxSize, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iHeaderSize == sizeof(RSqlBufFlat::TCell) * buf.iCount, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	if(buf.iHeaderSize > 0)
sl@0: 		{
sl@0: 		Mem::FillZ(Header(), buf.iHeaderSize);
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Reallocates the amount of the occupied by the flat buffer memory
sl@0: (only in case the requested size is bigger than the buffer size or the buffer does not exist).
sl@0: The operation preserves the content of the flat buffer.
sl@0: 
sl@0: @param aSize Desired flat buffer size in bytes.
sl@0: 
sl@0: @return KErrNone, The operation has completed successfully;
sl@0: 		KErrNoMemory, Out of memory condition has occured.
sl@0: */
sl@0: TInt RSqlBufFlat::DoReAlloc(TInt aSize)
sl@0: 	{
sl@0: 	if(!iBuf || iMaxSize < aSize)
sl@0: 		{
sl@0: 		//Calculate buffer new size (sometimes allocates more, for example, if
sl@0: 		//aSize % RSqlBufFlat::EExpandSize == 0, then one more RSqlBufFlat::EExpandSize page is allocated).
sl@0: 		TInt newSize = (aSize / RSqlBufFlat::EExpandSize + 1) * RSqlBufFlat::EExpandSize;
sl@0: 		RSqlBufFlat::TBufFlat* newBuf = static_cast <RSqlBufFlat::TBufFlat*> (User::ReAlloc(iBuf, newSize));
sl@0: 		if(!newBuf)
sl@0: 			{
sl@0: 			return KErrNoMemory;	
sl@0: 			}
sl@0: 		iBuf = newBuf;
sl@0: 		iMaxSize = newSize;
sl@0: 		}
sl@0: 	return KErrNone;
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Initialzes a flat buffer field.
sl@0: A memory for the field data has to be allocated before the call.
sl@0: 
sl@0: @param aIndex Field index
sl@0: @param aType Field type
sl@0: @param aData Field data, may be NULL
sl@0: @param aDataLength Field data length, may be 0
sl@0: */
sl@0: void RSqlBufFlat::DoSet(TInt aIndex, TInt aType, const void* aData, TInt aDataLength)
sl@0: 	{
sl@0: 	TBufFlat& buf = *iBuf;
sl@0: 	__ASSERT_DEBUG((TUint)aDataLength < RSqlBufFlat::EMaxLength, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aDataLength > 0 ? aData != NULL : ETrue, __SQLPANIC(ESqlPanicBadArgument));
sl@0: 	__ASSERT_DEBUG(aDataLength <= (iMaxSize - buf.iSize), __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(::IsAligned8(buf.iSize), __SQLPANIC(ESqlPanicInternalError));
sl@0: 	RSqlBufFlat::TCell& cell = *(Header() + aIndex);
sl@0: 	cell.iBits = (TUint)(((TUint)aType << RSqlBufFlat::EWidthLen) | (TUint)aDataLength);
sl@0: 	cell.iPos = 1;	//not 0, because 0 means "not present"
sl@0: 	if(aDataLength > 0)	//for fields with length > 0 set the data and reinitalize cell.iPos
sl@0: 		{
sl@0: #ifdef _DEBUG
sl@0: 		Mem::Copy(reinterpret_cast <TUint8*> (iBuf) + buf.iSize, &KSqlBufFlatMagicValue, sizeof(KSqlBufFlatMagicValue));
sl@0: 		buf.iSize += sizeof(KSqlBufFlatMagicValue);
sl@0: #endif		
sl@0: 		cell.iPos = buf.iSize - sizeof(RSqlBufFlat::TBufFlat);
sl@0: 		Mem::Copy(reinterpret_cast <TUint8*> (iBuf) + buf.iSize, reinterpret_cast <const TUint8*> (aData), aDataLength);
sl@0: 		buf.iSize += ::AlignedLen8(aDataLength);	//align the next field start position
sl@0: 				                                  	//it is guaranteed that this "+" operation will not make iSize bigger than
sl@0: 				                                   	//iMaxSize, because the memory allocations are 8-byte aligned 
sl@0: 				                                   	//(even RSqlBufFlat::EExpandSize aligned)
sl@0: 		}
sl@0: 	}
sl@0: 
sl@0: /**
sl@0: Makes sure that the flat buffer has enough free space for a block of data with "aLength" length.
sl@0: The function may reallocated the buffer if there is not enough space.
sl@0: 
sl@0: @param aLength The requested free memory length.
sl@0: 
sl@0: @return KErrNone, The operation has completed successfully;
sl@0: 		KErrNoMemory, Out of memory condition has occured.
sl@0: */
sl@0: TInt RSqlBufFlat::Reserve(TInt aLength)
sl@0: 	{
sl@0: #ifdef _DEBUG
sl@0: 	TInt diff = aLength + sizeof(KSqlBufFlatMagicValue) - Available();
sl@0: #else
sl@0: 	TInt diff = aLength - Available();
sl@0: #endif		
sl@0: 	return diff > 0 ? DoReAlloc(iMaxSize + diff) : KErrNone;
sl@0: 	}
sl@0: 
sl@0: #ifdef _DEBUG
sl@0: /**
sl@0: Panics in _DEBUG mode if the flat buffer content is inconsistent.
sl@0: */
sl@0: void RSqlBufFlat::Invariant() const
sl@0: 	{
sl@0: 	__ASSERT_DEBUG(iBuf != NULL, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	const TBufFlat& buf = *iBuf;
sl@0: 	__ASSERT_DEBUG(buf.iCount >= 0, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iHeaderSize == sizeof(RSqlBufFlat::TCell) * buf.iCount, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(::IsAligned8(buf.iSize), __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iSize >= buf.iHeaderSize + sizeof(RSqlBufFlat::TBufFlat), __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iSize <= iMaxSize, __SQLPANIC(ESqlPanicInternalError));
sl@0: 	__ASSERT_DEBUG(buf.iSize <= User::AllocLen(iBuf), __SQLPANIC(ESqlPanicInternalError));	
sl@0: 	for(TInt i=0;i<(TInt)buf.iCount;++i)
sl@0: 		{
sl@0: 		const RSqlBufFlat::TCell& cell = *((reinterpret_cast <const RSqlBufFlat::TCell*> (iBuf + 1)) + i);
sl@0: 		__ASSERT_DEBUG(cell.Type() < RSqlBufFlat::EMaxType, __SQLPANIC(ESqlPanicInternalError));
sl@0: 		if(cell.Size() > 0 && cell.iPos >= buf.iHeaderSize) //only for present fields with length > 0
sl@0: 			{
sl@0: 			__ASSERT_DEBUG((TUint)cell.Size() <= buf.iSize, __SQLPANIC(ESqlPanicInternalError));
sl@0: 			__ASSERT_DEBUG(cell.iPos < (buf.iSize - sizeof(RSqlBufFlat::TBufFlat)), __SQLPANIC(ESqlPanicInternalError));
sl@0: 			TUint64 val = *(TUint64*)(reinterpret_cast <TUint8*> (iBuf) + cell.iPos + sizeof(RSqlBufFlat::TBufFlat) - sizeof(KSqlBufFlatMagicValue));
sl@0: 			__ASSERT_DEBUG(val == KSqlBufFlatMagicValue, __SQLPANIC(ESqlPanicInternalError));
sl@0: 			}
sl@0: 		}
sl@0: 	}
sl@0: #endif//_DEBUG