#include <s32std.h>

#include <cntdef.h>

#include <cntfield.h>

#include <cntfldst.h>

#include <cntitem.h>

#include <versit.h>

//

// class TContactFieldAtts

//

const TUint32 KAttribsMask		    = 0xf0000fff;

const TUint32 KExtendedAttribsMask	= 0x000ff000;

const TUint32 KStorageTypeMask	    = 0x00f00000;

const TUint32 KTypeBitShift		    = 20;

const TUint32 KExtendedAttsBitShift = 12;

/** Set contact field attributes.

@param aAttribs contact field arributes to be set.

@internalTechnology

*/

void TContactFieldAtts::SetAttribs(TUint32 aAttribs)

	{

	iStorage |= aAttribs;

	}

/** Set contact field extended arributes.

@param aExtendedAttribs contact field extended arributes to be set.

@internalTechnology

*/

void TContactFieldAtts::SetExtendedAttribs(TUint32 aExtendedAttribs)

	{

	iStorage |= aExtendedAttribs << KExtendedAttsBitShift;

	}

/** Set storage type.

@param aType storage type to set.

@internalTechnology

*/

void TContactFieldAtts::SetType(TStorageType aType)

	{

	iStorage |= aType << KTypeBitShift;

	}

/** Get contact field arributes.

@return contact field arributes.

@internalTechnology

*/

TUint32 TContactFieldAtts::Attribs() const

	{

	return (iStorage & KAttribsMask);

	}

/** Get contact field extended arributes.

@return contact field extended arributes.

@internalTechnology

*/

TUint32 TContactFieldAtts::ExtendedAttribs() const

	{

	return (iStorage & KExtendedAttribsMask) >> KExtendedAttsBitShift;

	}

/** Get contact field storage type.

@return contact field storage type.

@internalTechnology

*/

TStorageType TContactFieldAtts::Type() const

	{

	return (iStorage & KStorageTypeMask) >> KTypeBitShift;

	}

/** Internalize implementation.

@internalTechnology

*/

void TContactFieldAtts::InternalizeL(RReadStream& aStream)

	{

	iStorage=aStream.ReadUint32L();

	}

/** Externalize implementation.

@internalTechnology

*/

void TContactFieldAtts::ExternalizeL(RWriteStream& aStream) const

	{

	aStream.WriteUint32L(iStorage);

	}

//

// class CContentType

//

EXPORT_C CContentType::~CContentType()

/** Frees all resources owned by the content type object, prior 

to its destruction. */

    {

	delete iFieldTypes;

	}

CContentType::CContentType()

    {

	}

CContentType::CContentType(TUid aMapping) : iMapping(aMapping)

	{

	}

/** Constructs a new content type based on a RReadStream.

@param aStream RReadStream containing object to internalize.

@return Pointer to the newly created CContentType. This is left on the cleanup stack. 

@internalTechnology

*/

CContentType* CContentType::NewLC(RReadStream& aStream)

	{ // static

	CContentType* type = NewL();

	CleanupStack::PushL(type);

	type->InternalizeL(aStream);

	return type;

	}		

EXPORT_C CContentType* CContentType::NewL()

/** Allocates and constructs a new default CContentType.

The object has no field types and the mapping is set to KNullUid

@return Pointer to the newly created content type object. */

	{

	CContentType* self=new(ELeave) CContentType(KNullUid);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();	// self

	return(self);

	}

EXPORT_C CContentType* CContentType::NewL(TFieldType aFieldType,TUid aMapping)

/** Allocates and constructs a new CContentType with a single field 

type and a mapping.

@param aFieldType The field type to add to the content type.

@param aMapping The mapping.

@return Pointer to the newly created content type object. */

	{

	CContentType* self=new(ELeave) CContentType(aMapping);

	CleanupStack::PushL(self);

	self->ConstructL();

	self->AddFieldTypeL(aFieldType);

	CleanupStack::Pop();	// self

	return(self);

	}

EXPORT_C CContentType* CContentType::NewL(const CContentType &aContentType)

/** Allocates and constructs a new CContentType based on another one.

@param aContentType The CContentType on which to base the new one.

@return Pointer to the newly created content type object. */

	{ // static

	CContentType* self=new(ELeave) CContentType;

	CleanupStack::PushL(self);

	self->ConstructL();

	self->CloneL(aContentType);

	CleanupStack::Pop();	// self

	return self;

	}

void CContentType::ConstructL()

	{

	iFieldTypes=new(ELeave) CArrayFixFlat<TUid>(2);

	}

EXPORT_C void CContentType::AddFieldTypeL(TFieldType aFieldType)

/** Appends a field type to the content type's list of field types.

Note that certain combinations of field types are not valid and should not be

used.

@param aFieldType The field type to append to the list of field types. */

	{

	const TInt KMaxFieldTypes=15;

	if (iFieldTypes->Count()==KMaxFieldTypes)

		{

		User::Leave(KErrOverflow);

		}

   	iFieldTypes->AppendL(aFieldType);

	}

EXPORT_C void CContentType::RemoveFieldType(TFieldType aFieldType)

/** Removes a field type from the list of field types.

@param aFieldType The field type to remove from the list of field types. */

	{

	for(TInt loop=0;loop<iFieldTypes->Count();loop++)

		if ((*iFieldTypes)[loop]==aFieldType)

			{

			iFieldTypes->Delete(loop);

			break;

			}

	}

EXPORT_C void CContentType::SetMapping(TUid aMapping)

/** Sets the vCard mapping.

@param aMapping The new vCard mapping for the content type. */

	{

	iMapping=aMapping;

	}

void CContentType::CloneL(const CContentType &aContentType)

	{

    iMapping=aContentType.iMapping;

	if (aContentType.iFieldTypes)

		for(TInt loop=0;loop<aContentType.iFieldTypes->Count();loop++)

			AddFieldTypeL((*aContentType.iFieldTypes)[loop]);

	}

EXPORT_C TInt CContentType::FieldTypeCount() const

/** Gets the number of field types in the content type's list of field types.

@return The number of field types in the content type. */

	{

	return(iFieldTypes->Count());

	}

EXPORT_C TFieldType CContentType::FieldType(TInt aIndex) const

/** Gets the indexed field type.

@param aIndex Index into the list of field types. The position is relative 

to zero; i.e. zero implies the first element in the array. This value must 

be non-negative and less than the number of objects currently within the array 

otherwise the operator raises a panic.

@return The indexed field type. */

	{

	__ASSERT_DEBUG(aIndex<iFieldTypes->Count(),Panic(ECntPanicFieldTypeIndex));

	return((*iFieldTypes)[aIndex]);

	}

EXPORT_C TUid CContentType::Mapping() const

/** Gets the vCard mapping.

@return The vCard mapping. */

	{

	return(iMapping);

	}

EXPORT_C TBool CContentType::ContainsFieldType(TFieldType aFieldType) const

/** Tests whether the content type object contains the specified field type UID 

either as the mapping value or in its list of field types.

@param aFieldType The field type of interest.

@return ETrue if the CContentType contains the specified field type. EFalse 

if not. */

	{

	if (iMapping==aFieldType)

		return(ETrue);

	for(TInt loop=0;loop<iFieldTypes->Count();loop++)

		if ((*iFieldTypes)[loop]==aFieldType)

			return(ETrue);

	return(EFalse);

	}

void CContentType::InternalizeAdditionalUidsL(TInt aCount,RReadStream& aStream)

	{

	for (TInt ii=0;ii<aCount;ii++) 

		iFieldTypes->AppendL(TUid::Uid(aStream.ReadInt32L()));

	}

EXPORT_C TBool CContentType::SupportsMultipleLines() const

/** Tests whether the content type supports multiple lines of text. If the content 

type object contains a field type which supports this, either in its list 

of field types, or as its mapping, the function returns ETrue. Examples of 

such field types are address fields (type KUidContactFieldAddress) and note 

fields (type KUidContactFieldNote).

@return ETrue if the CContentType supports multiple lines of text. EFalse 

if not. */

	{

	return(ContainsFieldType(KUidContactFieldAddress) || ContainsFieldType(KUidContactFieldNote));

	}

EXPORT_C TBool CContentType::operator==(const CContentType &aType) const

/** Compares two content type objects for equality. 

Two content type objects are equal according to this method if all following 

conditions are met:

- vCard property mapping matches

- same number of field types

- main field type matches

- additional field types and vCard property parameter mappings match

@param aType The content type to compare with this CContentType.

+@return ETrue if aType is equal with current content type. */

	{

	// Compare vCard property mapping.

	if (Mapping() != aType.Mapping())

		{

		return EFalse;

		}

	// Compare field type counts.

	const TInt typeCount = FieldTypeCount();

	if (typeCount != aType.FieldTypeCount())

		{

		return EFalse;

		}

	if (typeCount <= 0)

		{

		// Nothing more to compare.

		return ETrue;

		}

	// Compare main field type.

	if (FieldType(0) != aType.FieldType(0))

		{

		return EFalse;

		}

	// Compare additional field types and vCard property parameter mappings.

	for (TInt lhsIndex = 1; lhsIndex < typeCount; ++lhsIndex)

		{

		TInt rhsIndex = 1;

		for (rhsIndex = 1; rhsIndex < typeCount; ++rhsIndex)

			{

			if (FieldType(lhsIndex) == aType.FieldType(rhsIndex))

			    break;

			}

		if (rhsIndex == typeCount)

			{

			// No match found.

			return EFalse;

			}

		}

	return ETrue;

	}

EXPORT_C TBool CContentType::IsEqual(const CContentType &aType) const

/** Compares two content type objects for equality.

Two content type objects are equal according to this method if all following 

conditions are met:

- vCard property mapping matches

- same number of field types

- main field type matches

- additional field types and vCard property parameter mappings match

@param aType The content type to compare with this CContentType.

@return ETrue if aType is equal with current content type. */

	{

	// Compare vCard property mapping.

	if (iMapping!=aType.iMapping)

		{

		return(EFalse);	

		}

	// Compare field type counts.

	const TInt typeCount = aType.FieldTypeCount();

	if (FieldTypeCount()!= typeCount)

		{

		return(EFalse);	

		}

    if (typeCount <= 0)

        {

        // Nothing more to compare.

        return ETrue;

        }

    // Compare main field type.

    if (FieldType(0) != aType.FieldType(0))

        {

        return EFalse;

        }

    // Compare additional field types and vCard property parameter mappings.

    for (TInt leftIndex = 1; leftIndex < typeCount; ++leftIndex)

        {

        TUint rightIndex = 1;

        for (rightIndex = 1; rightIndex < typeCount; ++rightIndex)

            {

            if (FieldType(leftIndex) == aType.FieldType(rightIndex))

                break;

            }

        if (rightIndex == typeCount)

            {

            // No match found.

            return EFalse;

            }

        }

    return ETrue;

   	}

void CContentType::Reset()

	{

	iMapping=TUid::Uid(0);

	iFieldTypes->Reset();

	}

/*

 * Determine if content types are suitable to match for synchronization purpose. 

 * Some properties are subject to specific processing depending of the <code>CContentType</code> Mapping. 

 * Notably: VOICE, PREF, VoiceDial and SpeedDial. 

 * VOICE is a a default property parameter for all TEL properties.

 *

 * @param		"const CContentType& aType"

 *				The content type to compare with this

 *				<code>CContentType</code>. Beware, to do a proper comparison,

 *				the <code>aType</code> parameter must not contains VoiceDial or SpeedDial properties.

 *				Otherwise the fields will not match.				  

 *

 * @return 		"TBool"

 *				<code>ETrue</code> if <code>aType</code> match this content type.

 *				Field types do not need to be in the same order in the 

 *				list of field types for a match to be made.

 */

EXPORT_C TBool CContentType::IsEqualForSyncUpdate(const CContentType& aType) const

/** Tests whether the content types are suitable to match for synchronisation purpose. 

@param aType The content type to compare with this CContentType.

@return ETrue if aType is an identical content type

 */

	{

	if (iMapping!=aType.iMapping)

		return(EFalse);	

	switch (iMapping.iUid)

		{

	case KIntContactFieldVCardMapTEL:

		{

		TInt countModifier=0;

		TInt loop=0;

		if (aType.ContainsFieldType(KUidContactFieldVCardMapVOICE))

			{

			++countModifier;

			}

		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

			{

			++countModifier;

			}

		if (ContainsFieldType(KUidContactFieldVCardMapVOICE))

			{

			--countModifier;

			}

		if (ContainsFieldType(KUidContactFieldVCardMapPREF))

			{

			--countModifier;

			}

		if (ContainsFieldType(KUidContactsVoiceDialField))

			{

			--countModifier;

			}

		//look for speed dial property only in db field

		for(loop=0;loop<iFieldTypes->Count();loop++)

			{

			TInt uid = (*iFieldTypes)[loop].iUid;

			if (uid >= KUidSpeedDialOneValue && uid <= KUidSpeedDialNineValue)

				{

				--countModifier;

				break; //only one speed dial property allowed for a field

				}

			}

		//now check for field count	

		if ((FieldTypeCount()+countModifier)!=aType.FieldTypeCount())

			{

			return(EFalse);

			}

		//Check that all type from the imported field match a type in this field but VOICE and PREF

		for(loop=0;loop<aType.FieldTypeCount();loop++)

			{

			if (!ContainsFieldType(aType.FieldType(loop)))

				{

				if (aType.FieldType(loop).iUid==KIntContactFieldVCardMapVOICE || aType.FieldType(loop).iUid==KIntContactFieldVCardMapPREF)

					{

					continue;

					}

				return(EFalse);

				}

			}

		return(ETrue);

		}

	case KIntContactFieldVCardMapEMAILINTERNET:

		{

		TInt countModifier=0;		

		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

			{

			++countModifier;