1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/os/persistentdata/persistentstorage/sql/SRC/Common/SqlBufFlat.cpp Fri Jun 15 03:10:57 2012 +0200
1.3 @@ -0,0 +1,316 @@
1.4 +// Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
1.5 +// All rights reserved.
1.6 +// This component and the accompanying materials are made available
1.7 +// under the terms of "Eclipse Public License v1.0"
1.8 +// which accompanies this distribution, and is available
1.9 +// at the URL "http://www.eclipse.org/legal/epl-v10.html".
1.10 +//
1.11 +// Initial Contributors:
1.12 +// Nokia Corporation - initial contribution.
1.13 +//
1.14 +// Contributors:
1.15 +//
1.16 +// Description:
1.17 +//
1.18 +
1.19 +#include "SqlUtil.h"
1.20 +#include "SqlBufFlat.h"
1.21 +#include "OstTraceDefinitions.h"
1.22 +
1.23 +/**
1.24 +Sets the flat buffer pointer to NULL
1.25 +*/
1.26 +RSqlBufFlat::RSqlBufFlat() :
1.27 + iBuf(NULL),
1.28 + iMaxSize(0),
1.29 + iBufPtr(NULL, 0)
1.30 + {
1.31 + }
1.32 +
1.33 +/**
1.34 +"Resource acquisiton" method.
1.35 +Sets the elements count of a new or already existing flat buffer.
1.36 +
1.37 +The occupied memory won't be freed (in case of buffer resizing).
1.38 +The buffer content is not preserved (in case of buffer resizing).
1.39 +
1.40 +All elements set to have:
1.41 +- invalid type;
1.42 +- zero length;
1.43 +- zero data position;
1.44 +
1.45 +@param aCount Desired flat buffer elements count
1.46 +
1.47 +@return KErrNone, The operation has completed successfully;
1.48 + KErrNoMemory, Out of memory condition has occured.
1.49 +*/
1.50 +TInt RSqlBufFlat::SetCount(TInt aCount)
1.51 + {
1.52 + __ASSERT_DEBUG(aCount >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.53 + TInt headerSize = sizeof(RSqlBufFlat::TCell) * aCount;
1.54 + TInt newSize = headerSize + sizeof(RSqlBufFlat::TBufFlat);
1.55 + if(DoReAlloc(newSize) != KErrNone)
1.56 + {
1.57 + return KErrNoMemory;
1.58 + }
1.59 + TBufFlat& buf = *iBuf;
1.60 + buf.iCount = aCount;
1.61 + buf.iHeaderSize = headerSize;
1.62 + buf.iSize = newSize;
1.63 + buf.iReserved = 0;
1.64 + DoInit();
1.65 + SQLFLATBUF_INVARIANT();
1.66 + return KErrNone;
1.67 + }
1.68 +
1.69 +/**
1.70 +Reallocates the amount of the occupied by the flat buffer memory.
1.71 +The operation preserves the content of the flat buffer.
1.72 +Note: if the new size is less or equal to the max size of the buffer,
1.73 + no memory will be allocated.
1.74 +
1.75 +@param aSize Desired flat buffer size in bytes
1.76 +
1.77 +@return KErrNone, The operation has completed successfully;
1.78 + KErrNoMemory, Out of memory condition has occured.
1.79 +*/
1.80 +TInt RSqlBufFlat::ReAlloc(TInt aSize)
1.81 + {
1.82 + SQLFLATBUF_INVARIANT();
1.83 + TInt err = DoReAlloc(aSize);
1.84 + SQLFLATBUF_INVARIANT();
1.85 + return err;
1.86 + }
1.87 +
1.88 +/**
1.89 +Cleans up the flat buffer content and
1.90 +frees the occupied memory if the memory is above KBufLimit.
1.91 +The count of elements is preserved.
1.92 +
1.93 +If the buffer size is bigger than KBufLimit,
1.94 +the buffer will be reallocated and the buffer content - not preserved.
1.95 +
1.96 +If the buffer size is less or equal to KBufLimit,
1.97 +no memory will be reallocated and the buffer preserves its content.
1.98 +
1.99 +It is guaranteed that the reallocated buffer will have the same address in the heap
1.100 +as the original one.
1.101 +*/
1.102 +void RSqlBufFlat::ResetAndMinimize()
1.103 + {
1.104 + SQLFLATBUF_INVARIANT();
1.105 + Reset();
1.106 +#ifdef _DEBUG
1.107 + const TInt KBufLimit = Max((TInt)RSqlBufFlat::EExpandSize, SysDataSize());
1.108 + const TBufFlat* oldBuf = iBuf;
1.109 +#else
1.110 + const TInt KBufLimit = Max((8 * 1024), SysDataSize());
1.111 +#endif
1.112 + if(iMaxSize > KBufLimit)
1.113 + {
1.114 + iMaxSize = KBufLimit - 1; //to force the reallocation
1.115 + (void)DoReAlloc(KBufLimit);//User::ReAlloc() does not fail if the new requested size is less than the current block size
1.116 + }
1.117 + __ASSERT_DEBUG(oldBuf == iBuf, __SQLPANIC(ESqlPanicInternalError));
1.118 + SQLFLATBUF_INVARIANT();
1.119 + }
1.120 +
1.121 +/**
1.122 +Cleans up the flat buffer content but does not free the occupied memory.
1.123 +The count of elements is preserved.
1.124 +
1.125 +All elements set to have:
1.126 +- invalid type;
1.127 +- zero length;
1.128 +- zero data position;
1.129 +
1.130 +The element count is preserved.
1.131 +*/
1.132 +void RSqlBufFlat::Reset()
1.133 + {
1.134 + SQLFLATBUF_INVARIANT();
1.135 + iBuf->iSize = SysDataSize();
1.136 + DoInit();
1.137 + SQLFLATBUF_INVARIANT();
1.138 + }
1.139 +
1.140 +/**
1.141 +Closes the flat bufer and frees the allocated memory.
1.142 +*/
1.143 +void RSqlBufFlat::Close()
1.144 + {
1.145 + User::Free(iBuf);
1.146 + iBuf = NULL;
1.147 + }
1.148 +
1.149 +/**
1.150 +Sets the content of a field.
1.151 +
1.152 +@param aIndex Field index
1.153 +@param aType Field type
1.154 +@param aData Field data, may be NULL
1.155 +@param aDataLength Field data length, may be 0
1.156 +
1.157 +@return KErrNone, The operation has completed successfully;
1.158 + KErrNoMemory, Out of memory condition has occured.
1.159 +*/
1.160 +TInt RSqlBufFlat::SetField(TInt aIndex, TInt aType, const void* aData, TInt aDataLength)
1.161 + {
1.162 + SQLFLATBUF_INVARIANT();
1.163 + __ASSERT_DEBUG((TUint)aIndex < iBuf->iCount, __SQLPANIC(ESqlPanicBadArgument));
1.164 + __ASSERT_DEBUG((TUint)aType < RSqlBufFlat::EMaxType, __SQLPANIC(ESqlPanicBadArgument));
1.165 + __ASSERT_DEBUG((TUint)aDataLength < RSqlBufFlat::EMaxLength, __SQLPANIC(ESqlPanicBadArgument));
1.166 + if(aData) //field value "present"
1.167 + {
1.168 + __ASSERT_DEBUG(aDataLength >= 0, __SQLPANIC(ESqlPanicBadArgument));
1.169 + if(aDataLength > 0)
1.170 + {
1.171 + if(Reserve(aDataLength) != KErrNone)
1.172 + {
1.173 + return KErrNoMemory;
1.174 + }
1.175 + }
1.176 + DoSet(aIndex, aType, aData, aDataLength);
1.177 + }
1.178 + else if(aDataLength == 0) //data is NULL, length is 0 - "null" field
1.179 + {
1.180 + DoSet(aIndex, aType, NULL, 0);
1.181 + }
1.182 + else //field value "not present"
1.183 + {
1.184 + RSqlBufFlat::TCell& cell = *(Header() + aIndex);
1.185 + cell.iBits = (TUint)(((TUint)aType << RSqlBufFlat::EWidthLen) | (TUint)aDataLength);
1.186 + cell.iPos = 0;
1.187 + }
1.188 + SQLFLATBUF_INVARIANT();
1.189 + return KErrNone;
1.190 + }
1.191 +
1.192 +/**
1.193 +Initialzies the flat buffer header.
1.194 +All field set:
1.195 +- invalid type;
1.196 +- zero length;
1.197 +- "Not present";
1.198 +*/
1.199 +void RSqlBufFlat::DoInit()
1.200 + {
1.201 + TBufFlat& buf = *iBuf;
1.202 + __ASSERT_DEBUG(buf.iCount >= 0, __SQLPANIC(ESqlPanicInternalError));
1.203 + __ASSERT_DEBUG(buf.iSize <= iMaxSize, __SQLPANIC(ESqlPanicInternalError));
1.204 + __ASSERT_DEBUG(buf.iHeaderSize == sizeof(RSqlBufFlat::TCell) * buf.iCount, __SQLPANIC(ESqlPanicInternalError));
1.205 + if(buf.iHeaderSize > 0)
1.206 + {
1.207 + Mem::FillZ(Header(), buf.iHeaderSize);
1.208 + }
1.209 + }
1.210 +
1.211 +/**
1.212 +Reallocates the amount of the occupied by the flat buffer memory
1.213 +(only in case the requested size is bigger than the buffer size or the buffer does not exist).
1.214 +The operation preserves the content of the flat buffer.
1.215 +
1.216 +@param aSize Desired flat buffer size in bytes.
1.217 +
1.218 +@return KErrNone, The operation has completed successfully;
1.219 + KErrNoMemory, Out of memory condition has occured.
1.220 +*/
1.221 +TInt RSqlBufFlat::DoReAlloc(TInt aSize)
1.222 + {
1.223 + if(!iBuf || iMaxSize < aSize)
1.224 + {
1.225 + //Calculate buffer new size (sometimes allocates more, for example, if
1.226 + //aSize % RSqlBufFlat::EExpandSize == 0, then one more RSqlBufFlat::EExpandSize page is allocated).
1.227 + TInt newSize = (aSize / RSqlBufFlat::EExpandSize + 1) * RSqlBufFlat::EExpandSize;
1.228 + RSqlBufFlat::TBufFlat* newBuf = static_cast <RSqlBufFlat::TBufFlat*> (User::ReAlloc(iBuf, newSize));
1.229 + if(!newBuf)
1.230 + {
1.231 + return KErrNoMemory;
1.232 + }
1.233 + iBuf = newBuf;
1.234 + iMaxSize = newSize;
1.235 + }
1.236 + return KErrNone;
1.237 + }
1.238 +
1.239 +/**
1.240 +Initialzes a flat buffer field.
1.241 +A memory for the field data has to be allocated before the call.
1.242 +
1.243 +@param aIndex Field index
1.244 +@param aType Field type
1.245 +@param aData Field data, may be NULL
1.246 +@param aDataLength Field data length, may be 0
1.247 +*/
1.248 +void RSqlBufFlat::DoSet(TInt aIndex, TInt aType, const void* aData, TInt aDataLength)
1.249 + {
1.250 + TBufFlat& buf = *iBuf;
1.251 + __ASSERT_DEBUG((TUint)aDataLength < RSqlBufFlat::EMaxLength, __SQLPANIC(ESqlPanicBadArgument));
1.252 + __ASSERT_DEBUG(aDataLength > 0 ? aData != NULL : ETrue, __SQLPANIC(ESqlPanicBadArgument));
1.253 + __ASSERT_DEBUG(aDataLength <= (iMaxSize - buf.iSize), __SQLPANIC(ESqlPanicInternalError));
1.254 + __ASSERT_DEBUG(::IsAligned8(buf.iSize), __SQLPANIC(ESqlPanicInternalError));
1.255 + RSqlBufFlat::TCell& cell = *(Header() + aIndex);
1.256 + cell.iBits = (TUint)(((TUint)aType << RSqlBufFlat::EWidthLen) | (TUint)aDataLength);
1.257 + cell.iPos = 1; //not 0, because 0 means "not present"
1.258 + if(aDataLength > 0) //for fields with length > 0 set the data and reinitalize cell.iPos
1.259 + {
1.260 +#ifdef _DEBUG
1.261 + Mem::Copy(reinterpret_cast <TUint8*> (iBuf) + buf.iSize, &KSqlBufFlatMagicValue, sizeof(KSqlBufFlatMagicValue));
1.262 + buf.iSize += sizeof(KSqlBufFlatMagicValue);
1.263 +#endif
1.264 + cell.iPos = buf.iSize - sizeof(RSqlBufFlat::TBufFlat);
1.265 + Mem::Copy(reinterpret_cast <TUint8*> (iBuf) + buf.iSize, reinterpret_cast <const TUint8*> (aData), aDataLength);
1.266 + buf.iSize += ::AlignedLen8(aDataLength); //align the next field start position
1.267 + //it is guaranteed that this "+" operation will not make iSize bigger than
1.268 + //iMaxSize, because the memory allocations are 8-byte aligned
1.269 + //(even RSqlBufFlat::EExpandSize aligned)
1.270 + }
1.271 + }
1.272 +
1.273 +/**
1.274 +Makes sure that the flat buffer has enough free space for a block of data with "aLength" length.
1.275 +The function may reallocated the buffer if there is not enough space.
1.276 +
1.277 +@param aLength The requested free memory length.
1.278 +
1.279 +@return KErrNone, The operation has completed successfully;
1.280 + KErrNoMemory, Out of memory condition has occured.
1.281 +*/
1.282 +TInt RSqlBufFlat::Reserve(TInt aLength)
1.283 + {
1.284 +#ifdef _DEBUG
1.285 + TInt diff = aLength + sizeof(KSqlBufFlatMagicValue) - Available();
1.286 +#else
1.287 + TInt diff = aLength - Available();
1.288 +#endif
1.289 + return diff > 0 ? DoReAlloc(iMaxSize + diff) : KErrNone;
1.290 + }
1.291 +
1.292 +#ifdef _DEBUG
1.293 +/**
1.294 +Panics in _DEBUG mode if the flat buffer content is inconsistent.
1.295 +*/
1.296 +void RSqlBufFlat::Invariant() const
1.297 + {
1.298 + __ASSERT_DEBUG(iBuf != NULL, __SQLPANIC(ESqlPanicInternalError));
1.299 + const TBufFlat& buf = *iBuf;
1.300 + __ASSERT_DEBUG(buf.iCount >= 0, __SQLPANIC(ESqlPanicInternalError));
1.301 + __ASSERT_DEBUG(buf.iHeaderSize == sizeof(RSqlBufFlat::TCell) * buf.iCount, __SQLPANIC(ESqlPanicInternalError));
1.302 + __ASSERT_DEBUG(::IsAligned8(buf.iSize), __SQLPANIC(ESqlPanicInternalError));
1.303 + __ASSERT_DEBUG(buf.iSize >= buf.iHeaderSize + sizeof(RSqlBufFlat::TBufFlat), __SQLPANIC(ESqlPanicInternalError));
1.304 + __ASSERT_DEBUG(buf.iSize <= iMaxSize, __SQLPANIC(ESqlPanicInternalError));
1.305 + __ASSERT_DEBUG(buf.iSize <= User::AllocLen(iBuf), __SQLPANIC(ESqlPanicInternalError));
1.306 + for(TInt i=0;i<(TInt)buf.iCount;++i)
1.307 + {
1.308 + const RSqlBufFlat::TCell& cell = *((reinterpret_cast <const RSqlBufFlat::TCell*> (iBuf + 1)) + i);
1.309 + __ASSERT_DEBUG(cell.Type() < RSqlBufFlat::EMaxType, __SQLPANIC(ESqlPanicInternalError));
1.310 + if(cell.Size() > 0 && cell.iPos >= buf.iHeaderSize) //only for present fields with length > 0
1.311 + {
1.312 + __ASSERT_DEBUG((TUint)cell.Size() <= buf.iSize, __SQLPANIC(ESqlPanicInternalError));
1.313 + __ASSERT_DEBUG(cell.iPos < (buf.iSize - sizeof(RSqlBufFlat::TBufFlat)), __SQLPANIC(ESqlPanicInternalError));
1.314 + TUint64 val = *(TUint64*)(reinterpret_cast <TUint8*> (iBuf) + cell.iPos + sizeof(RSqlBufFlat::TBufFlat) - sizeof(KSqlBufFlatMagicValue));
1.315 + __ASSERT_DEBUG(val == KSqlBufFlatMagicValue, __SQLPANIC(ESqlPanicInternalError));
1.316 + }
1.317 + }
1.318 + }
1.319 +#endif//_DEBUG