--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/src/CNTDEF.CPP Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,249 @@
+// Copyright (c) 1997-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 <cntdef.h>
+#include "CNTSTD.H"
+
+//
+// class CContactIdArray
+//
+
+EXPORT_C CContactIdArray* CContactIdArray::NewL()
+/** Allocates and constructs a new contact ID array.
+
+@return Pointer to the newly created contact ID array. */
+ { // static
+ CContactIdArray* self=CContactIdArray::NewLC();
+ CleanupStack::Pop(); // self
+ return self;
+ }
+
+EXPORT_C CContactIdArray* CContactIdArray::NewLC()
+/** Allocates and constructs a new contact ID array.
+
+The pointer to the object is left on the cleanup stack.
+
+@return Pointer to the newly created contact ID array. */
+ { // static
+ CContactIdArray* self=new(ELeave) CContactIdArray;
+ CleanupStack::PushL(self);
+ self->ConstructL();
+ return self;
+ }
+
+EXPORT_C CContactIdArray* CContactIdArray::NewL(const CContactIdArray* aArray)
+/** Allocates and constructs a new contact ID array and then copies the contents of
+aArray into it.
+
+@param aArray Pointer to the contact ID array to copy.
+@return Pointer to the newly created contact ID array. */
+ {
+ CContactIdArray* self=CContactIdArray::NewLC(aArray);
+ CleanupStack::Pop(); // self
+ return self;
+ }
+
+EXPORT_C CContactIdArray* CContactIdArray::NewLC(const CContactIdArray* aArray)
+/** Allocates and constructs a new contact ID array and then copies the contents of
+aArray into it.
+
+The pointer to the object is left on the cleanup stack.
+
+@param aArray Pointer to the contact ID array to copy.
+@return Pointer to the newly created contact ID array. */
+ {
+ CContactIdArray* self=CContactIdArray::NewLC();
+ self->CloneL(aArray);
+ return self;
+ }
+
+/** Allocates and constructs a new contact ID array based on a RReadStream.
+
+The pointer to the object is left on the cleanup stack.
+
+@param aStream RReadStream containing object to internalize.
+@return Pointer to the newly created contact ID array
+@internalTechnology
+*/
+CContactIdArray* CContactIdArray::NewLC(RReadStream& aStream)
+ {
+ CContactIdArray* self=CContactIdArray::NewLC();
+ self->InternalizeL(aStream);
+ return self;
+ }
+
+void CContactIdArray::CloneL(const CContactIdArray* aArray)
+ {
+ const TInt arrayCount = aArray->Count();
+ for(TInt loop=0;loop<arrayCount;loop++)
+ AddL((*aArray)[loop]);
+ }
+
+CContactIdArray::CContactIdArray()
+ {}
+
+void CContactIdArray::ConstructL()
+ {
+ iIds=new(ELeave) CArrayFixFlat<TContactItemId>(4);
+ }
+
+EXPORT_C CContactIdArray::~CContactIdArray()
+/** The destructor frees all resources owned by the array, prior to its destruction. */
+ {
+ delete iIds;
+ }
+
+EXPORT_C TInt CContactIdArray::Find(TContactItemId aId) const
+/** Finds the index of the specified contact ID within the array.
+
+@param aId The contact ID to find.
+@return If the contact ID is found, its index within the array. KErrNotFound
+if the ID is not found. */
+ {
+ TInt pos;
+ TKeyArrayFix key(0,ECmpTInt);
+ if (iIds->Find(aId,key,pos)==KErrNone)
+ return pos;
+ return KErrNotFound;
+ }
+
+EXPORT_C void CContactIdArray::AddL(TContactItemId aId)
+/** Appends a contact ID to the array.
+
+@param aId The contact ID to append to the array. */
+ {
+// __ASSERT_DEBUG(Find(aId)<=KErrNotFound,Panic(ECntPanicDuplicateIds));
+ iIds->AppendL(aId);
+ }
+
+
+EXPORT_C void CContactIdArray::MoveL(TInt aOldIndex,TInt aNewIndex)
+/** Moves a contact ID within the array.
+
+Note: both indexes must be valid or a panic occurs.
+
+@param aOldIndex The index of the ID to move.
+@param aNewIndex The new index for the contact ID. */
+ {
+ /*
+ This function has unexpected behaviour. From the function prototype
+ one would expect this to provide simple swap functionality. However,
+ in fact, this function performs a slightly more complicated task:
+ it actually deletes the item at aOldIndex and moves it *after* the
+ item at aNewIndex. This behaviour is subtley different from a 'swap'
+ (see the example at the end of this comment).
+
+ This means that the only time this kind of code could be used:-
+
+ const TContactItemId id = (*iIds)[aOldIndex];
+ (*iIds)[aOldIndex] = (*iIds)[aNewIndex];
+ (*iIds)[aNewIndex] = id;
+
+ is when Abs(aNewIndex - aOldIndex) = 1, which is rare in the simple
+ testing that has been performed.
+
+ An example of the function pre and post execution is below
+
+ CContactIdArray::MoveL(aOld = 2, aNew = 7)
+ CContactIdArray::MoveL - Before operation...
+ iIds[0] = 5
+ iIds[1] = 6
+ iIds[2] = 7
+ iIds[3] = 4
+ iIds[4] = 1
+ iIds[5] = 2
+ iIds[6] = 3
+ iIds[7] = 8
+
+ CContactIdArray::MoveL - After operation...
+ iIds[0] = 5
+ iIds[1] = 6
+ iIds[2] = 4
+ iIds[3] = 1
+ iIds[4] = 2
+ iIds[5] = 3
+ iIds[6] = 8
+ iIds[7] = 7
+ */
+
+ if (aOldIndex==aNewIndex)
+ return;
+
+ if (aNewIndex>aOldIndex && aNewIndex<Count())
+ ++aNewIndex;
+ TContactItemId id=(*iIds)[aOldIndex];
+ iIds->InsertL(aNewIndex,id);
+ if (aOldIndex>aNewIndex)
+ ++aOldIndex;
+ Remove(aOldIndex);
+ }
+
+EXPORT_C void CContactIdArray::ReverseOrder()
+/** Reverses the order of the whole array. */
+ {
+ TInt count=Count();
+ TInt end=count/2;
+ TInt index2=count-1;
+ for(TInt index=0;index<end;index++)
+ {
+ TContactItemId id=(*iIds)[index];
+ (*iIds)[index]=(*iIds)[index2];
+ (*iIds)[index2]=id;
+ index2--;
+ }
+ }
+
+EXPORT_C void CContactIdArray::InternalizeL(RReadStream& aStream)
+/** Internalises a CContactIdArray object from a read stream. The presence of this
+function means that the standard templated operator>>() (defined in s32strm.h)
+is available to internalise objects of this class.
+
+@param aStream Stream from which the object should be internalised. */
+ {
+ TContactItemId anitem;
+ TInt count;
+ count=aStream.ReadInt32L();
+ for (TInt i=0;i<count;i++)
+ {
+ aStream >> anitem;
+ iIds->AppendL(anitem);
+ }
+ }
+
+EXPORT_C void CContactIdArray::ExternalizeL(RWriteStream& aStream) const
+/** Externalises a CContactIdArray object to a write stream. The presence of this
+function means that the standard templated operator<<() (defined in s32strm.h)
+is available to externalise objects of this class.
+
+@param aStream Stream to which the object should be externalised. */
+ {
+ TInt count;
+ TContactItemId anitem;
+ count=iIds->Count();
+ aStream.WriteInt32L(count);
+ for (TInt i=0;i<count;i++)
+ {
+ anitem=(*iIds)[i];
+ aStream << anitem;
+ }
+ }
+
+/* Sorts the array into ascending order.
+This function is intended for internal use only.*/
+void CContactIdArray::Sort()
+ {
+ TKeyArrayFix key(0,ECmpTInt);
+ iIds->Sort(key);
+ }