Symaptic: os/persistentdata/persistentstorage/dbms/udbms/UD

     1 // Copyright (c) 2003-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    16 #include "UD_STD.H"

    18 const TInt KPakArrayGranularity=0x80;

    20 // class TDbCol

    21 EXPORT_C TDbCol::TDbCol(const TDesC &aName,TDbColType aType)

    22 	: iType(aType), iAttributes(0), iName(aName)

    23 	{

    24 	iMaxLength=(aType==EDbColText8 || aType==EDbColText16)

    25 		? KDbDefaultTextColLength : KDbUndefinedLength;

    26 	}

    28 EXPORT_C TDbCol::TDbCol(const TDesC &aName,TDbColType aType,TInt aMaxLength)

    29 	: iType(aType), iMaxLength(aMaxLength), iAttributes(0), iName(aName)

    30 /** Constructs a TDbCol with the given name, optional type and optional maximum

    31 length.

    33 Note: The iAttributes member is initialised to 0.

    35 @param aName The column name.

    36 @param aType The column type.

    37 @param aMaxLength If present, this specifies a limit on how many characters

    38 may be stored in a Text column, or how many bytes can be stored in a Binary

    39 column. By default this is set to KDbDefaultTextColLength for Text (but not

    40 LongText) columns and KDbUndefinedLength for other columns. */

    41 	{}

    43 // class CDbColSet

    44 EXPORT_C CDbColSet::CDbColSet()

    45 : iColumns(KPakArrayGranularity)

    46 /** Constructs an empty column set. */

    47 	{}

    49 EXPORT_C CDbColSet* CDbColSet::NewL()

    50 /** Constructs a new empty column set and returns a pointer to it.

    52 @return A pointer to the column set object. */

    53 	{

    54 	return new(ELeave) CDbColSet;

    55 	}

    57 EXPORT_C CDbColSet* CDbColSet::NewLC()

    58 /** Constructs a new empty column set and returns a pointer to it — placing

    59 the pointer onto the cleanup stack. This allows the column set object and

    60 allocated resources to be cleaned up if a subsequent leave occurs.

    62 @return A pointer to the column set object. */

    63 	{

    64 	CDbColSet* cs=NewL();

    65 	CleanupStack::PushL(cs);

    66 	return cs;

    67 	}

    69 EXPORT_C CDbColSet::~CDbColSet()

    70 /** Frees resources owned by the object. */

    71 	{}

    73 EXPORT_C const TDbCol* CDbColSet::Col(const TDesC &aColName) const

    74 /** Returns a named column definition in the set. If such a column does not

    75 exist in the set NULL is returned.

    77 @param aColName The name of the column to find.

    78 @return A pointer to the column definition found, or NULL. */

    79 	{

    80 	TDbColNo col=ColNo(aColName);

    81 	if (col==KDbNullColNo)

    82 		return NULL;

    83 	else

    84 		return &(*this)[col];

    85 	}

    87 EXPORT_C TDbColNo CDbColSet::ColNo(const TDesC &aColName) const

    88 /** Returns the ordinal for a particular column name in this column set. If

    89 such a column does not exist in the set the special ordinal KDbNullColNo is

    90 returned.

    92 This function is particularly important when accessing data through a rowset.

    93 If the set of columns to be returned by a rowset is not explicitly specified,

    94 no assumptions should be made about the ordering of the columns returned.

    95 In such a case, in order to access the column data a column ordinal is required,

    96 and this can be obtained by using this function on the column set returned

    97 by RDbRowSet::ColSetL().

    99 @param aColName The name of the column to find.

   100 @return The ordinal number of the column. */

   101 	{

   102 	TInt pos;

   103 	TKeyArrayPak key(_FOFF(TDbCol,iName),ECmpFolded);

   104 	if (iColumns.Find(TDbCol(aColName),key,pos))

   105 		return KDbNullColNo;

   106 	else

   107 		return pos+1;

   108 	}

   110 EXPORT_C CDbColSet& CDbColSet::AddL(const TDbCol& aCol)

   111 /** Adds a column to the column set.

   113 @param aCol The column to add to the set.

   114 @return A reference to this object. */

   115 	{

   116 	iColumns.AppendL(aCol,REINTERPRET_CAST(const TUint8*,aCol.iName.Ptr())+aCol.iName.Size()-REINTERPRET_CAST(const TUint8*,&aCol));

   117 	return *this;

   118 	}

   120 EXPORT_C void CDbColSet::Remove(const TDesC &aColName)

   121 /** Removes the named column from the set.

   123 @param aColName The name of the column to remove from the set. */

   124 	{

   125 	TDbColNo col=ColNo(aColName);

   126 	__ASSERT_ALWAYS(col!=KDbNullColNo,Panic(EDbInvalidColumn));

   127 	iColumns.Delete(col-1);

   128 	}

   130 // Class TDbColSetIter

   131 EXPORT_C TDbColSetIter::TDbColSetIter(const CDbColSet& aColSet)

   132 	: iIndex(-1),iArray(&aColSet.iColumns)

   133 /** Constructs a column set iterator over a column set. The iterator now

   134 references the first column in the set.

   136 @param aColSet The column set to iterate over. */

   137 	{

   138 	++(*this);

   139 	}

   141 EXPORT_C TDbColSetIter& TDbColSetIter::operator++()

   142 /** Moves the iterator to the next column in the set -- post increment operator.

   144 Note that this is implemented in terms of the pre-increment operator, and

   145 is less efficient.

   147 @param Unused: required for the C++ compiler to resolve the ambiguity with

   148 the pre-increment operator.

   149 @return A copy of this iterator, referring to the column definition before

   150 the increment operation is performed. */

   151 	{

   152 	__ASSERT(iIndex<iArray->Count());

   153 	iColumn=++iIndex<iArray->Count() ? &(*iArray)[iIndex] : 0;

   154 	return *this;

   155 	}

   157 // class TDbKeyCol

   158 EXPORT_C TDbKeyCol::TDbKeyCol(const TDesC& aName,TOrder anOrder)

   159 	: iOrder(anOrder),iLength(KDbUndefinedLength),iName(aName)

   160 	{}

   162 EXPORT_C TDbKeyCol::TDbKeyCol(const TDesC& aName,TInt aLength,TOrder anOrder)

   163 	: iOrder(anOrder),iLength(aLength),iName(aName)

   164 /** Constructs an object with the given name, ordering and optional truncation

   165 length.

   167 @param aName The column name.

   168 @param aLength If present, this specifies a limit on how many characters of

   169 a Text or LongText column are used for the key. This should only be used for

   170 the last key column in an index. It is required for keys on LongText columns.

   171 @param anOrder The ordering for the key column. By default this is ascending

   172 order. */

   173 	{}

   175 // class CDbKey

   177 EXPORT_C CDbKey::CDbKey()

   178 	: iKeys(KPakArrayGranularity)

   179 /** Constructs an empty key. It is initialised to non-unique, non-primary and

   180 normal text comparison. */

   181 	{}

   183 EXPORT_C CDbKey *CDbKey::NewL()

   184 /** Constructs and returns a pointer to a new empty key.

   186 @return A pointer to the key object. */

   187 	{

   188 	return new(ELeave) CDbKey;

   189 	}

   191 EXPORT_C CDbKey *CDbKey::NewLC()

   192 /** Constructs and returns a new empty key and return a pointer to it, leaving

   193 a pointer to the key object on the cleanup stack. This allows the key object

   194 and allocated resources to be cleaned up if a subsequent leave occurs.

   196 @return A pointer to the key object. */

   197 	{

   198 	CDbKey* key=NewL();

   199 	CleanupStack::PushL(key);

   200 	return key;

   201 	}

   203 EXPORT_C CDbKey::~CDbKey()

   204 /** Frees resources owned by the object. */

   205 	{}

   207 EXPORT_C CDbKey& CDbKey::AddL(const TDbKeyCol& aKey)

   208 /** Adds a key column to the end of the key.

   210 @param aKeyCol The key column to add to the key.

   211 @return A reference to this object. */

   212 	{

   213 	iKeys.AppendL(aKey,REINTERPRET_CAST(const TUint8*,aKey.iName.Ptr())+aKey.iName.Size()-REINTERPRET_CAST(const TUint8*,&aKey));

   214 	return *this;

   215 	}

   217 EXPORT_C void CDbKey::Remove(const TDesC& aColName)

   218 /** Removes the named column from the key.

   220 @param aColName The name of the column to remove from the key. */

   221 	{

   222 	TInt pos;

   223 	TKeyArrayPak key(_FOFF(TDbKeyCol,iName),ECmpFolded);

   224 	__ASSERT_ALWAYS(!iKeys.Find(TDbKeyCol(aColName),key,pos),Panic(EDbInvalidColumn));

   225 	iKeys.Delete(pos);

   226 	}

   228 EXPORT_C void CDbKey::Clear()

   229 /** Resets the key to its initial empty state. */

   230 	{

   231 	iKeys.Reset();

   232 	iAttributes=0;

   233 	iComparison=EDbCompareNormal;

   234 	}

   236 // Class TDbLookupKey

   238 TDbLookupKey::SColumn& TDbLookupKey::NextKey()

   239 	{

   240 	return iKey[iCount++];

   241 	}

   243 void TDbLookupKey::Add(TInt aKey)

   244 	{

   245 	SColumn& key=NextKey();

   246 	key.iType=EDbColInt32;

   247 	key.iInt32=aKey;

   248 	}

   250 void TDbLookupKey::Add(TUint aKey)

   251 	{

   252 	SColumn& key=NextKey();

   253 	key.iType=EDbColUint32;

   254 	key.iUint32=aKey;

   255 	}

   257 void TDbLookupKey::Add(TInt64 aKey)

   258 	{

   259 	SColumn& key=NextKey();

   260 	key.iType=EDbColInt64;

   261 	key.iInt64()=aKey;

   262 	}

   264 void TDbLookupKey::Add(TReal32 aKey) __SOFTFP

   265 	{

   266 	SColumn& key=NextKey();

   267 	key.iType=EDbColReal32;

   268 	key.iReal32=aKey;

   269 	}

   271 void TDbLookupKey::Add(TReal64 aKey) __SOFTFP

   272 	{

   273 	SColumn& key=NextKey();

   274 	key.iType=EDbColReal64;

   275 	key.iReal64=aKey;

   276 	}

   278 void TDbLookupKey::Add(TTime aKey)

   279 	{

   280 	SColumn& key=NextKey();

   281 	key.iType=EDbColDateTime;

   282 	key.iTime()=aKey;

   283 	}

   285 void TDbLookupKey::Add(const TDesC8& aKey)

   286 	{

   287 	SColumn& key=NextKey();

   288 	key.iType=EDbColText8;

   289 	key.iDes8.iPtr=aKey.Ptr();

   290 	key.iDes8.iLength=aKey.Length();

   291 	}

   293 void TDbLookupKey::Add(const TDesC16& aKey)

   294 	{

   295 	SColumn& key=NextKey();

   296 	key.iType=EDbColText16;

   297 	key.iDes16.iPtr=aKey.Ptr();

   298 	key.iDes16.iLength=aKey.Length();

   299 	}

   301 // Class TDbSeekKey

   303 TDbLookupKey& TDbSeekKey::Check()

   304 	{

   305 	__ASSERT_ALWAYS(iKey.Count()<iMaxKeys,Panic(EDbTooManyKeys));

   306 	return iKey;

   307 	}

   309 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TInt aKey)

   310 /** Appends a key value for an TInt8, TInt16 or TInt32 column.

   312 @param aKey The key value to lookup.

   313 @return A reference to this database key value object. */

   314 	{

   315 	Check().Add(aKey);

   316 	return *this;

   317 	}

   319 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TUint aKey)

   320 /** Appends a key value for a Bit, TUint8, TUint16 or TUint32 column.

   322 @param aKey The key value to lookup.

   323 @return A reference to this database key value object. */

   324 	{

   325 	Check().Add(aKey);

   326 	return *this;

   327 	}

   329 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TInt64 aKey)

   330 /** Appends a key value for an TInt64 column.

   332 @param aKey The key value to lookup.

   333 @return A reference to this database key value object. */

   334 	{

   335 	Check().Add(aKey);

   336 	return *this;

   337 	}

   339 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TReal32 aKey) __SOFTFP

   340 /** Appends a key value for a TReal32 column.

   342 @param aKey The key value to lookup.

   343 @return A reference to this database key value object. */

   344 	{

   345 	Check().Add(aKey);

   346 	return *this;

   347 	}

   349 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TReal64 aKey) __SOFTFP

   350 /** Appends a key value for a TReal64 column.

   352 @param aKey The key value to lookup.

   353 @return A reference to this database key value object. */

   354 	{

   355 	Check().Add(aKey);

   356 	return *this;

   357 	}

   359 EXPORT_C TDbSeekKey& TDbSeekKey::Add(TTime aKey)

   360 /** Appends a key value for a DateTime column.

   362 @param aKey The key value to lookup. TTime may be either local time or universal time.

   363 DBMS doesn't interpret the value of TTime, it is left up to the user to decide which should be used.

   364 @return A reference to this database key value object. */

   365 	{

   366 	Check().Add(aKey);

   367 	return *this;

   368 	}

   370 EXPORT_C TDbSeekKey& TDbSeekKey::Add(const TDesC8& aKey)

   371 /** Appends a key value for a non-Unicode text column.

   373 Note that the seek key does not copy the text data contained by the descriptor.

   374 This needs to be retained until the seek key is no longer required.

   376 @param aKey The key value to lookup.

   377 @return A reference to this database key value object. */

   378 	{

   379 	Check().Add(aKey);

   380 	return *this;

   381 	}

   383 EXPORT_C TDbSeekKey& TDbSeekKey::Add(const TDesC16& aKey)

   384 /** Appends a key value for a Unicode text column.

   386 Note that the seek key does not copy the text data contained by the descriptor.

   387 This needs to be retained until the seek key is no longer required.

   389 @param aKey The key value to lookup.

   390 @return A reference to this database key value object. */

   391 	{

   392 	Check().Add(aKey);

   393 	return *this;

   394 	}

   396 // Class CDbNames

   398 inline CDbNames::CDbNames()

   399 	: iList(KPakArrayGranularity)

   400 	{}

   402 CDbNames* CDbNames::NewLC()

   403 	{

   404 	CDbNames* self=new(ELeave) CDbNames;

   405 	CleanupStack::PushL(self);

   406 	return self;

   407 	}

   409 CDbNames::~CDbNames()

   410 	{}

   412 EXPORT_C void CDbNames::AddL(const TDesC& aName)

   413 	{

   414 	TDbNameC name(aName);

   415 	iList.AppendL(name,(const TUint8*)name.Ptr()+name.Size()-(const TUint8*)&name);

   416 	}

   418 ////////////////////////////////////////////////////////////////////////////////////////////////

   419 // Class CDbStrings

   421 /**

   422 Granularity of CDbStrings array.

   423 @internalComponent

   424 */

   425 const TInt KPakArrayGranularity2 = KDbMaxStrLen * 2;

   427 /**

   428 @internalComponent

   429 */

   430 inline CDbStrings::CDbStrings() :

   431 	iList(KPakArrayGranularity2)

   432 	{

   433 	}

   435 /**

   436 Standard phase-one creation method for CDbStrings objects.

   437 @return A pointer to the created CDbStrings object.

   438 @leave KErrNoMemory - Out of memory.

   439 */

   440 CDbStrings* CDbStrings::NewLC()

   441 	{

   442 	CDbStrings* self = new(ELeave) CDbStrings;

   443 	CleanupStack::PushL(self);

   444 	return self;

   445 	}

   447 /**

   448 @internalComponent

   449 */

   450 CDbStrings::~CDbStrings()

   451 	{

   452 	}

   454 /**

   455 Adds a string to the array.

   456 @param aStr String to be added to the array.

   457 @leave KErrNoMemory - Out of memory.

   458 @internalComponent

   459 */

   460 void CDbStrings::AddL(const TDesC& aStr)

   461 	{

   462 	TDbStringC str(aStr);

   463 	iList.AppendL(str, (const TUint8*)str.Ptr() + str.Size() - (const TUint8*)&str);

   464 	}

author	sl
	Tue, 10 Jun 2014 14:32:02 +0200
changeset 1	260cb5ec6c19
permissions	-rw-r--r--