diff -r 000000000000 -r e686773b3f54 phonebookengines/contactsmodel/src/cntitemdef.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/phonebookengines/contactsmodel/src/cntitemdef.cpp	Tue Feb 02 10:12:17 2010 +0200
@@ -0,0 +1,463 @@
+// Copyright (c) 2004-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 <cntfield.h>
+#include <cntitem.h>
+#include "CNTSTD.H"
+
+//
+// TContactTextDefItem
+//
+
+EXPORT_C TContactTextDefItem::TContactTextDefItem() : iFieldType(KNullUid)
+/** Default constructor; initialises the field type to KNullUid. */
+	{}
+
+EXPORT_C TContactTextDefItem::TContactTextDefItem(TFieldType aFieldType) : iFieldType(aFieldType)
+/** Constructs the text definition item with a field type. 
+
+@param aFieldType The field type. */	
+	{}
+
+EXPORT_C TContactTextDefItem::TContactTextDefItem(TFieldType aFieldType, const TDesC &aSeperator) : iFieldType(aFieldType)
+/** C++ constructor with a field type and a separator string. 
+
+@param aFieldType The field type.
+@param aSeperator The string used to separate fields in the text definition. */
+	{
+	iSeperator.Copy(aSeperator);
+	}
+
+//
+// CContactTextDef
+//
+
+CContactTextDef::CContactTextDef()
+	: CArrayFixFlat<TContactTextDefItem>(5),
+	iFallbackFieldType(KUidContactFieldNone),
+	iExactMatchOnly(EFalse)
+	{}
+
+EXPORT_C CContactTextDef* CContactTextDef::NewL()
+/** Allocates and constructs a new text definition. The fallback field type is 
+initialised to KUidContactFieldNone.
+
+@return Pointer to the newly created text definition. */
+	{
+	return new(ELeave) CContactTextDef;
+	}
+
+EXPORT_C CContactTextDef* CContactTextDef::NewLC()
+/** Allocates and constructs a new text definition. If the text definition is successfully 
+constructed, it is left on the cleanup stack. The fallback field type is initialised 
+to KUidContactFieldNone.
+
+@return Pointer to the newly created text definition. */
+	{
+	CContactTextDef* textDef=CContactTextDef::NewL();
+	CleanupStack::PushL(textDef);
+	return textDef;
+	}
+
+/** Allocates and constructs a new text definition based on a RReadStream. If the text definition is successfully 
+constructed, it is left on the cleanup stack. The fallback field type is initialised 
+to KUidContactFieldNone.
+
+@param aStream RReadStream containing object to internalize.
+@return Pointer to the newly created text definition. 
+@internalTechnology 
+*/	
+CContactTextDef* CContactTextDef::NewLC(RReadStream& aStream)
+	{
+	CContactTextDef* textDef=CContactTextDef::NewLC();
+	textDef->InternalizeL(aStream);	
+	return textDef;
+	}	
+
+EXPORT_C void CContactTextDef::SetFallbackField(TFieldType aFieldType)
+/** Sets the fallback field type.
+
+@param aFieldType The fallback field type. */
+	{
+	iFallbackFieldType=aFieldType;
+	}
+
+EXPORT_C TFieldType CContactTextDef::FallbackField() const
+/** Gets the fallback field type.
+
+@return The fallback field type. */
+	{
+	return(iFallbackFieldType);
+	}
+
+EXPORT_C TBool CContactTextDef::ExactMatchOnly()
+/** Gets the exact match for contact fields
+@return ETrue if it gets the exact match   */
+	{
+	return iExactMatchOnly;
+	}
+
+EXPORT_C void CContactTextDef::SetExactMatchOnly(TBool aExactMatchOnly)
+/** Sets the exact match for contact fields
+@param aExactMatchOnly Contains the value for exact match. It takes ETrue when an exact match is required, EFalse otherwise.   */
+	{
+	iExactMatchOnly=aExactMatchOnly;
+	}
+
+void CContactTextDef::InternalizeL(RReadStream& aStream)
+/** Internalises a CContactItem object from a read stream. 
+@param aStream Stream from which the object should be internalised. */
+	{
+	this->Reset();
+	TInt count = aStream.ReadInt32L();
+
+	TInt separatorLength = 0;
+	for (TInt i=0; i<count; ++i)
+		{
+		TContactTextDefItem textDefItem;
+		textDefItem.iFieldType.iUid = aStream.ReadInt32L();
+		separatorLength = aStream.ReadInt32L();
+		if(separatorLength)
+			{
+			aStream>>textDefItem.iSeperator;
+			}
+
+		this->AppendL(textDefItem);
+		}
+	
+	TFieldType fieldType;
+	fieldType.iUid = aStream.ReadInt32L();
+	SetFallbackField(fieldType);
+	SetExactMatchOnly(aStream.ReadInt32L());
+		
+	}
+
+void CContactTextDef::ExternalizeL(RWriteStream& aStream) const 
+/** Externalises a CContactItem object to a write stream.
+@param aStream Stream to which the object should be externalised. */
+	{
+	TInt count = this->Count();
+	aStream.WriteInt32L(count);	
+	
+	TInt separatorLength = 0;
+	for(TInt i=0; i<count;++i)
+		{
+		aStream.WriteInt32L(this->At(i).iFieldType.iUid);
+		separatorLength = this->At(i).iSeperator.Length();
+		aStream.WriteInt32L(separatorLength);
+		if(separatorLength)
+			{
+			aStream << this->At(i).iSeperator;
+			}			
+		}
+	aStream.WriteInt32L(this->FallbackField().iUid);	
+	aStream.WriteInt32L(const_cast<CContactTextDef*>(this)->ExactMatchOnly());
+		
+	}
+
+EXPORT_C CContactItemViewDef* CContactItemViewDef::NewL(TUse aUse, TMode aMode)
+/** Allocates and constructs a new CContactItemViewDef, with a use and a mode.
+
+@param aUse Specifies whether to include or exclude specified fields.
+@param aMode Specifies whether to include or exclude hidden fields.
+@return Pointer to the newly created view definition. */
+	{ // static
+	return new(ELeave) CContactItemViewDef(aUse, aMode);
+	}
+
+EXPORT_C CContactItemViewDef* CContactItemViewDef::NewLC(TUse aUse, TMode aMode)
+/** Allocates and constructs a new CContactItemViewDef, specifying a use and a 
+mode, leaving the object on the cleanup stack.
+
+@param aUse Specifies whether to include or exclude specified fields.
+@param aMode Specifies whether to include or exclude hidden fields.
+@return Pointer to the newly created view definition. */
+	{ // static
+	CContactItemViewDef* viewDef=CContactItemViewDef::NewL(aUse, aMode);
+	CleanupStack::PushL(viewDef);
+	return viewDef;
+	}
+
+/** Allocates and constructs a new CContactItemViewDef based on a RReadStream, 
+specifying a use and a mode, leaving the object on the cleanup stack.
+
+@param aStream RReadStream containing object to internalize.
+@return Pointer to the newly created view definition. 
+@internalTechnology
+*/
+CContactItemViewDef* CContactItemViewDef::NewLC(RReadStream& aStream)
+	{
+	CContactItemViewDef::TUse aUse = (CContactItemViewDef::TUse)aStream.ReadInt32L();
+	CContactItemViewDef::TMode aMode = (CContactItemViewDef::TMode)aStream.ReadInt32L();	
+	CContactItemViewDef* viewDef=CContactItemViewDef::NewLC(aUse, aMode);
+	viewDef->InternalizeL(aStream);
+	
+	return viewDef;
+	}	
+
+CContactItemViewDef::CContactItemViewDef(TUse aUse, TMode aMode)
+	: iFieldTypes(5),iUse(aUse),iMode(aMode)
+	{}
+
+EXPORT_C TInt CContactItemViewDef::Find(TFieldType aFieldType) const
+/** Searches the view definition for the specified field type.
+
+@param aFieldType The field type to search for.
+@return The index in the view definition of the matching field type, or KErrNotFound. */
+	{
+	const TInt count=Count();
+	for (TInt ii=0;ii<count;ii++)
+		{
+		TUid fieldType=iFieldTypes[ii];
+		if (fieldType==KUidContactFieldMatchAll || aFieldType==KUidContactFieldMatchAll || fieldType==aFieldType)
+			return ii;
+		}
+	return KErrNotFound;
+	}
+
+EXPORT_C TInt CContactItemViewDef::Find(const CContentType &aContentType) const
+/** Searches the view definition for any field type contained in the specified 
+content type.
+
+@param aContentType Content type containing the field types to search for.
+@return The index in the view definition of the first matching field type or 
+KErrNotFound. */
+	{
+	TInt ret=KErrNotFound;
+	for(TInt loop=0;loop<aContentType.FieldTypeCount();loop++)
+		{
+		ret=Find(aContentType.FieldType(loop));
+		if (ret!=KErrNotFound)
+			break;
+		}
+	return(ret);
+	}
+
+EXPORT_C TBool CContactItemViewDef::MatchesAll() const
+/** Tests whether the view definition contains a field type with the value KUidContactFieldMatchAll. 
+
+If this is the case, all fields in the contact item are retrieved, regardless 
+of the other field types specified in the view definition.
+
+@return ETrue if all field types are matched, EFalse if not. */
+	{
+	const TInt count=Count();
+	for (TInt ii=0;ii<count;ii++)
+		{
+		TUid fieldType=iFieldTypes[ii];
+		if (fieldType==KUidContactFieldMatchAll)
+			return(ETrue);
+		}
+	return(EFalse);
+	}
+
+EXPORT_C void CContactItemViewDef::AddL(TFieldType aFieldType)
+/** Appends a field type to the view definition's array of field types.
+
+@param aFieldType The field type to append to the array of field types. */
+	{
+	__ASSERT_DEBUG(Find(aFieldType)<=KErrNotFound,Panic(ECntPanicDuplicateViewFields));
+	iFieldTypes.AppendL(aFieldType);
+	}
+
+EXPORT_C void CContactItemViewDef::Remove(TFieldType aFieldType)
+/** Removes a field type, identified by its UID.
+
+@param aFieldType The field type to remove from the list. This must be 
+present in the CContactItemViewDef object, or the function raises a panic. */
+	{
+	const TInt index=Find(aFieldType);
+	__ASSERT_ALWAYS(index!=KErrNotFound,Panic(ECntPanicFieldDoesNotExist));
+	iFieldTypes.Delete(index);
+	}
+
+EXPORT_C void CContactItemViewDef::Remove(TInt aIndex)
+/** Removes a field type, identified by its index into the array of field types.
+
+@param aIndex The index of the element to delete. The position is relative 
+to zero. This value must not be negative and must not be greater than the 
+number of elements currently in the list, or the function raises a panic. */
+	{ // inline this ?? !!!
+	iFieldTypes.Delete(aIndex);
+	}
+
+EXPORT_C void CContactItemViewDef::InternalizeL(RReadStream& aStream)
+/** Internalises the item view definition 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 item view definition should be internalised. */
+	{
+	iUse=STATIC_CAST(CContactItemViewDef::TUse,aStream.ReadInt32L());
+	TInt count;
+	count=aStream.ReadInt32L();
+	Reset();
+	for(TInt ii=0;ii<count;ii++)
+		{
+		TUid fieldType;
+		aStream>>fieldType;
+		iFieldTypes.AppendL(fieldType);
+		}
+	}
+
+EXPORT_C void CContactItemViewDef::ExternalizeL(RWriteStream& aStream) const
+/** Externalises the item view definition 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 item view definition should be externalised. */
+	{
+	aStream.WriteInt32L(iUse);
+	TInt count=Count();
+	aStream.WriteInt32L(count);
+	for(TInt ii=0;ii<count;ii++)
+		aStream << iFieldTypes[ii];
+	}
+
+EXPORT_C TBool CContactItemViewDef::Contains(const CContactItem& aItem)
+/** Tests whether a contact item complies with the view definition.
+
+This indicates whether or not the item will be included in the view. 
+
+@param aItem The contact item to test.
+@return ETrue if any of the item's fields are contained in the view definition 
+(so that the item will be included in the view), EFalse if none of the item's 
+fields are contained in the view definition (so that the item will not be 
+included in the view). */
+	{
+	CContactItemFieldSet& fieldSet=aItem.CardFields();
+	const TInt count=fieldSet.Count();
+	for (TInt ii=0;ii<count;ii++)
+		if (Find(iFieldTypes[ii])!=KErrNotFound)
+			return ETrue;
+	return EFalse;
+	}
+
+//
+// class CContactViewDef
+//
+
+EXPORT_C CContactViewDef* CContactViewDef::NewL()
+/**  Allocates and constructs a view definition.
+
+@return Pointer to the new view definition. */
+	{
+	CContactViewDef* viewDef=CContactViewDef::NewLC();
+	CleanupStack::Pop(viewDef);
+	return viewDef;
+	}
+
+EXPORT_C CContactViewDef* CContactViewDef::NewLC()
+/** Allocates and constructs a view definition, leaving it on the cleanup stack.
+
+@return Pointer to the new view definition. */
+	{
+	CContactViewDef* viewDef=new(ELeave) CContactViewDef();
+	CleanupStack::PushL(viewDef);
+	return(viewDef);
+	}
+
+EXPORT_C CContactViewDef* CContactViewDef::NewL(CContactItemViewDef* aItemDef)
+/** Allocates and constructs a view definition. 
+
+@param aItemDef Pointer to the item view definition. This contains the view definition's 
+field types, use and mode. The view definition takes ownership of this.
+@return Pointer to the new view definition. */
+	{ // static
+	CContactViewDef* viewDef=CContactViewDef::NewLC(aItemDef);
+	CleanupStack::Pop(viewDef);
+	return viewDef;
+	}
+
+EXPORT_C CContactViewDef* CContactViewDef::NewLC(CContactItemViewDef* aItemDef)
+/** Allocates and constructs a view definition. 
+
+@param aItemDef Pointer to the item view definition. This contains the view definition's 
+field types, use and mode. The view definition takes ownership of this.
+@return Pointer to the new view definition. This is left on the cleanup 
+stack.*/
+	{ // static
+	CContactViewDef* viewDef=new(ELeave) CContactViewDef();
+	CleanupStack::PushL(viewDef);
+	viewDef->ConstructL(aItemDef);
+	return viewDef;
+	}
+	
+/** Allocates and constructs a view definition based on a RReadStream.
+
+@param aStream RReadStream containing object to internalize.
+@return Pointer to the new view definition. This is left on the cleanup stack. 
+@internalTechnology 
+*/
+CContactViewDef* CContactViewDef::NewLC(RReadStream& aStream)
+	{
+	CContactViewDef* viewDef=CContactViewDef::NewLC();
+	CContactItemViewDef* itemDef=CContactItemViewDef::NewLC(aStream);	
+	viewDef->ConstructL(itemDef);
+	CleanupStack::Pop(itemDef);
+	return viewDef;
+	}		
+
+EXPORT_C CContactViewDef::~CContactViewDef()
+/** Destroys the view definition object and deletes its owned item view definition. */
+	{
+	delete iItemDef;
+	}
+
+EXPORT_C void CContactViewDef::InternalizeL(RReadStream& aStream)
+/** Internalises the object's item view definition from a read stream.
+
+@param aStream Stream from which the object should be internalised. */
+	{
+	CContactItemViewDef* itemDef=CContactItemViewDef::NewLC(CContactItemViewDef::EIncludeFields,CContactItemViewDef::EIncludeHiddenFields);
+	itemDef->InternalizeL(aStream);
+	CleanupStack::Pop(itemDef);
+	delete iItemDef;
+	iItemDef=itemDef;
+	}
+
+EXPORT_C void CContactViewDef::ExternalizeL(RWriteStream& aStream) const
+/** Externalises the object's item view definition to a write stream.
+
+@param aStream Stream to which the object should be externalised. */
+	{
+	iItemDef->ExternalizeL(aStream);
+	}
+	
+CContactViewDef::CContactViewDef()
+	{}
+
+void CContactViewDef::ConstructL(CContactItemViewDef* aItemDef)
+	{
+	iItemDef=aItemDef;
+	}
+	
+EXPORT_C CContactItemViewDef& CContactViewDef::ItemDef() const
+/** Gets the object's item view definition.
+
+@return Reference to the item view definition. */
+	{
+	return *iItemDef;
+	}
+
+EXPORT_C CContactIdArray& CContactViewDef::Groups() const
+/** This function is not supported. 
+
+If called, it leaves with KErrNotSupported. */
+	{
+	User::Leave(KErrNotSupported); // leaves...
+	CContactIdArray* contactIds=NULL;
+	return *contactIds;
+	}