1 // Copyright (c) 1997-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 //

    15 

    16 #include <s32std.h>

    17 

    18 #include "CNTSTD.H"

    19 #include <cntdef.h>

    20 #include <cntfield.h>

    21 #include <cntfldst.h>

    22 

    23 #include <cntitem.h>

    24 #include <versit.h>

    25 #include "CNTPROF.H"

    26 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    27 #include "cntfieldheader.h"

    28 #include "cnthint.h"

    29 #include "cntfield_internal.h"

    30 #endif

    31 

    32 //

    33 // class TContactFieldAtts

    34 //

    35 const TUint32 KAttribsMask		    = 0xf0000fff;

    36 const TUint32 KExtendedAttribsMask	= 0x000ff000;

    37 const TUint32 KStorageTypeMask	    = 0x00f00000;

    38 

    39 const TUint32 KTypeBitShift		    = 20;

    40 const TUint32 KExtendedAttsBitShift = 12;

    41 

    42 /** Set contact field attributes.

    43 

    44 @param aAttribs contact field arributes to be set.

    45 @internalTechnology

    46 */

    47 void TContactFieldAtts::SetAttribs(TUint32 aAttribs)

    48 	{

    49 	iStorage |= aAttribs;

    50 	}

    51 	

    52 /** Set contact field extended arributes.

    53 

    54 @param aExtendedAttribs contact field extended arributes to be set.

    55 @internalTechnology

    56 */

    57 void TContactFieldAtts::SetExtendedAttribs(TUint32 aExtendedAttribs)

    58 	{

    59 	iStorage |= aExtendedAttribs << KExtendedAttsBitShift;

    60 	}

    61 

    62 /** Set storage type.

    63 

    64 @param aType storage type to set.

    65 @internalTechnology

    66 */

    67 void TContactFieldAtts::SetType(TStorageType aType)

    68 	{

    69 	iStorage |= aType << KTypeBitShift;

    70 	}

    71 

    72 /** Get contact field arributes.

    73 

    74 @return contact field arributes.

    75 @internalTechnology

    76 */

    77 TUint32 TContactFieldAtts::Attribs() const

    78 	{

    79 	return (iStorage & KAttribsMask);

    80 	}

    81 	

    82 /** Get contact field extended arributes.

    83 

    84 @return contact field extended arributes.

    85 @internalTechnology

    86 */

    87 TUint32 TContactFieldAtts::ExtendedAttribs() const

    88 	{

    89 	return (iStorage & KExtendedAttribsMask) >> KExtendedAttsBitShift;

    90 	}

    91 	

    92 /** Get contact field storage type.

    93 

    94 @return contact field storage type.

    95 @internalTechnology

    96 */

    97 TStorageType TContactFieldAtts::Type() const

    98 	{

    99 	return (iStorage & KStorageTypeMask) >> KTypeBitShift;

   100 	}

   101 	

   102 /** Internalize implementation.

   103 

   104 @internalTechnology

   105 */

   106 void TContactFieldAtts::InternalizeL(RReadStream& aStream)

   107 	{

   108 	iStorage=aStream.ReadUint32L();

   109 	}

   110 	

   111 /** Externalize implementation.

   112 

   113 @internalTechnology

   114 */

   115 void TContactFieldAtts::ExternalizeL(RWriteStream& aStream) const

   116 	{

   117 	aStream.WriteUint32L(iStorage);

   118 	}

   119 

   120 

   121 //

   122 // class CContentType

   123 //

   124    

   125 EXPORT_C CContentType::~CContentType()

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

   127 to its destruction. */

   128     {

   129 	delete iFieldTypes;

   130 	}

   131       

   132 CContentType::CContentType()

   133     {

   134 	}

   135       

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

   137 	{

   138 	}

   139 	

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

   141 

   142 @param aStream RReadStream containing object to internalize.

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

   144 @internalTechnology

   145 */

   146 CContentType* CContentType::NewLC(RReadStream& aStream)

   147 	{ // static

   148 	CContentType* type = NewL();

   149 	CleanupStack::PushL(type);

   150 	type->InternalizeL(aStream);

   151 	

   152 	return type;

   153 	}		

   154 

   155 EXPORT_C CContentType* CContentType::NewL()

   156 /** Allocates and constructs a new default CContentType.

   157 

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

   159 

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

   161 	{

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

   163 	CleanupStack::PushL(self);

   164 	self->ConstructL();

   165 	CleanupStack::Pop();	// self

   166 	return(self);

   167 	}

   168 

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

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

   171 type and a mapping.

   172 

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

   174 @param aMapping The mapping.

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

   176 	{

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

   178 	CleanupStack::PushL(self);

   179 	self->ConstructL();

   180 	self->AddFieldTypeL(aFieldType);

   181 	CleanupStack::Pop();	// self

   182 	return(self);

   183 	}

   184 

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

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

   187 

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

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

   190 	{ // static

   191 	CContentType* self=new(ELeave) CContentType;

   192 	CleanupStack::PushL(self);

   193 	self->ConstructL();

   194 	self->CloneL(aContentType);

   195 	CleanupStack::Pop();	// self

   196 	return self;

   197 	}

   198  

   199 void CContentType::ConstructL()

   200 	{

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

   202 	}

   203 

   204 EXPORT_C void CContentType::AddFieldTypeL(TFieldType aFieldType)

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

   206 

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

   208 used.

   209 

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

   211 	{

   212 	const TInt KMaxFieldTypes=15;

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

   214 		{

   215 		User::Leave(KErrOverflow);

   216 		}

   217     		

   218    	iFieldTypes->AppendL(aFieldType);

   219 	}

   220 

   221 EXPORT_C void CContentType::RemoveFieldType(TFieldType aFieldType)

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

   223 

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

   225 	{

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

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

   228 			{

   229 			iFieldTypes->Delete(loop);

   230 			break;

   231 			}

   232 	}

   233 

   234 EXPORT_C void CContentType::SetMapping(TUid aMapping)

   235 /** Sets the vCard mapping.

   236 

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

   238 	{

   239 	iMapping=aMapping;

   240 	}

   241 

   242 void CContentType::CloneL(const CContentType &aContentType)

   243 	{

   244     iMapping=aContentType.iMapping;

   245 	if (aContentType.iFieldTypes)

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

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

   248 	}

   249 

   250 EXPORT_C TInt CContentType::FieldTypeCount() const

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

   252 

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

   254 	{

   255 	return(iFieldTypes->Count());

   256 	}

   257 

   258 EXPORT_C TFieldType CContentType::FieldType(TInt aIndex) const

   259 /** Gets the indexed field type.

   260 

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

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

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

   264 otherwise the operator raises a panic.

   265 @return The indexed field type. */

   266 	{

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

   268 	return((*iFieldTypes)[aIndex]);

   269 	}

   270 

   271 EXPORT_C TUid CContentType::Mapping() const

   272 /** Gets the vCard mapping.

   273 

   274 @return The vCard mapping. */

   275 	{

   276 	return(iMapping);

   277 	}

   278 

   279 EXPORT_C TBool CContentType::ContainsFieldType(TFieldType aFieldType) const

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

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

   282 

   283 @param aFieldType The field type of interest.

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

   285 if not. */

   286 	{

   287 	if (iMapping==aFieldType)

   288 		return(ETrue);

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

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

   291 			return(ETrue);

   292 	return(EFalse);

   293 	}

   294 

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

   296 	{

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

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

   299 	}

   300 

   301 EXPORT_C TBool CContentType::SupportsMultipleLines() const

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

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

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

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

   306 fields (type KUidContactFieldNote).

   307 

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

   309 if not. */

   310 	{

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

   312 	}

   313 

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

   315 /** Compares two content type objects for equality. 

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

   317 conditions are met:

   318 - vCard property mapping matches

   319 - same number of field types

   320 - main field type matches

   321 - additional field types and vCard property parameter mappings match

   322  

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

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

   325 	{

   326 	// Compare vCard property mapping.

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

   328 		{

   329 		return EFalse;

   330 		}

   331 	

   332 	// Compare field type counts.

   333 	const TInt typeCount = FieldTypeCount();

   334 	if (typeCount != aType.FieldTypeCount())

   335 		{

   336 		return EFalse;

   337 		}

   338 	if (typeCount <= 0)

   339 		{

   340 		// Nothing more to compare.

   341 		return ETrue;

   342 		}

   343 	

   344 	// Compare main field type.

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

   346 		{

   347 		return EFalse;

   348 		}

   349 	

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

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

   352 		{

   353 		TInt rhsIndex = 1;

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

   355 			{

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

   357 			    break;

   358 			}

   359 		if (rhsIndex == typeCount)

   360 			{

   361 			// No match found.

   362 			return EFalse;

   363 			}

   364 		}

   365 	

   366 	return ETrue;

   367 	}

   368 

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

   370 /** Compares two content type objects for equality.

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

   372 conditions are met:

   373 - vCard property mapping matches

   374 - same number of field types

   375 - main field type matches

   376 - additional field types and vCard property parameter mappings match

   377  

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

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

   380 	{

   381 	// Compare vCard property mapping.

   382 	if (iMapping!=aType.iMapping)

   383 		{

   384 		return(EFalse);	

   385 		}

   386 	

   387 	// Compare field type counts.

   388 	const TInt typeCount = aType.FieldTypeCount();

   389 	if (FieldTypeCount()!= typeCount)

   390 		{

   391 		return(EFalse);	

   392 		}

   393 		

   394     if (typeCount <= 0)

   395         {

   396         // Nothing more to compare.

   397         return ETrue;

   398         }

   399 			

   400     // Compare main field type.

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

   402         {

   403         return EFalse;

   404         }

   405 

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

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

   408         {

   409         TUint rightIndex = 1;

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

   411             {

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

   413                 break;

   414             }

   415         if (rightIndex == typeCount)

   416             {

   417             // No match found.

   418             return EFalse;

   419             }

   420         }

   421 

   422     return ETrue;

   423    	}

   424   	

   425 void CContentType::Reset()

   426 	{

   427 	iMapping=TUid::Uid(0);

   428 	iFieldTypes->Reset();

   429 	}

   430 

   431 

   432 /*

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

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

   435  * Notably: VOICE, PREF, VoiceDial and SpeedDial. 

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

   437  *

   438  * @param		"const CContentType& aType"

   439  *				The content type to compare with this

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

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

   442  *				Otherwise the fields will not match.				  

   443  *

   444  * @return 		"TBool"

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

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

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

   448  */

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

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

   451 

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

   453 @return ETrue if aType is an identical content type

   454  */

   455 	{

   456 	if (iMapping!=aType.iMapping)

   457 		return(EFalse);	

   458 

   459 	switch (iMapping.iUid)

   460 		{

   461 	case KIntContactFieldVCardMapTEL:

   462 		{

   463 		TInt countModifier=0;

   464 		TInt loop=0;

   465 

   466 		if (aType.ContainsFieldType(KUidContactFieldVCardMapVOICE))

   467 			{

   468 			++countModifier;

   469 			}

   470 

   471 		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

   472 			{

   473 			++countModifier;

   474 			}

   475 		

   476 		if (ContainsFieldType(KUidContactFieldVCardMapVOICE))

   477 			{

   478 			--countModifier;

   479 			}

   480 

   481 		if (ContainsFieldType(KUidContactFieldVCardMapPREF))

   482 			{

   483 			--countModifier;

   484 			}

   485 

   486 		if (ContainsFieldType(KUidContactsVoiceDialField))

   487 			{

   488 			--countModifier;

   489 			}

   490 

   491 		//look for speed dial property only in db field

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

   493 			{

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

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

   496 				{

   497 				--countModifier;

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

   499 				}

   500 			}

   501 	

   502 		//now check for field count	

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

   504 			{

   505 			return(EFalse);

   506 			}

   507 				

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

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

   510 			{

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

   512 				{

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

   514 					{

   515 					continue;

   516 					}

   517 				return(EFalse);

   518 				}

   519 			}

   520 		return(ETrue);

   521 		}

   522 

   523 	case KIntContactFieldVCardMapEMAILINTERNET:

   524 		{

   525 		TInt countModifier=0;		

   526 

   527 		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

   528 			{

   529 			++countModifier;

   530 			}

   531 		

   532 		if (ContainsFieldType(KUidContactFieldVCardMapPREF))

   533 			{

   534 			--countModifier;

   535 			}

   536 	

   537 		//now check for field count	

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

   539 			{

   540 			return(EFalse);

   541 			}

   542 				

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

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

   545 			{

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

   547 				{

   548 				if (aType.FieldType(loop).iUid==KIntContactFieldVCardMapPREF)

   549 					{

   550 					continue;

   551 					}

   552 				return(EFalse);

   553 				}

   554 			}

   555 		return(ETrue);

   556 		}

   557 	

   558 	case KIntContactFieldVCardMapAGENT:

   559 		{

   560 		return(ETrue);

   561 		}	

   562 

   563 	default:

   564 		return *this==aType;

   565 		}

   566 	}

   567 	

   568 void CContentType::InternalizeL(RReadStream& aStream)

   569 /** Internalises a CContentType object from a read stream. 

   570 @param aStream Stream from which the object should be internalised. */

   571 	{

   572     // TUid iMapping;

   573 	iMapping.iUid = aStream.ReadInt32L();

   574 	

   575 	// CArrayFix<TUid>* iFieldTypes;

   576 	const TInt count=aStream.ReadInt32L();

   577 

   578 	// Allocated in constructor

   579 	TUid tempID;

   580 	for(TInt index=0; index<count; ++index)

   581 		{

   582 		

   583 		aStream>>tempID;		

   584 		iFieldTypes->AppendL(tempID);

   585 		}

   586 	}

   587 

   588 void CContentType::ExternalizeL(RWriteStream& aStream) const 

   589 /** Externalises a CContentType object to a write stream.

   590 @param aStream Stream to which the object should be externalised. */

   591 	{

   592 	aStream.WriteInt32L(iMapping.iUid);

   593 	

   594 	const TInt count = iFieldTypes->Count();

   595 	aStream.WriteInt32L(count);	

   596 	for(TInt index=0; index<count; ++index)

   597 		{

   598 		aStream<<iFieldTypes->At(index);

   599 		}

   600 	}		

   601 

   602 

   603 //

   604 // class CContactItemField

   605 //

   606 

   607 EXPORT_C CContactItemField* CContactItemField::NewLC()

   608 /** Allocates and constructs a new default contact item field. 

   609 

   610 The field's storage type, content type and label are unspecified. 

   611 The ESynchronize attribute is set.

   612 

   613 @return Pointer to the newly created contact item field. */

   614 	{

   615     CContactItemField* self=new(ELeave) CContactItemField;

   616     CleanupStack::PushL(self);

   617 	self->iContentType=CContentType::NewL();

   618     return self;

   619 	}

   620 

   621 EXPORT_C CContactItemField* CContactItemField::NewL(TStorageType aType)

   622 /** Allocates and constructs a contact item field with a storage type. 

   623 

   624 The field's label and content type are unspecified.

   625 

   626 @param aType The field's storage type.

   627 @return Pointer to the newly created contact item field. */

   628 	{

   629     CContactItemField* self=CContactItemField::NewLC(aType);

   630     CleanupStack::Pop(); // self

   631     return self;

   632 	}

   633 

   634 EXPORT_C CContactItemField* CContactItemField::NewLC(TStorageType aType)

   635 /** Allocates and constructs a contact item field with a storage type. 

   636 

   637 The field's label and content type are unspecified.

   638 

   639 @param aType The field's storage type.

   640 @return Pointer to the newly created contact item field. This is left on 

   641 the cleanup stack. */

   642 	{

   643     CContactItemField* self=new(ELeave) CContactItemField(aType);

   644     CleanupStack::PushL(self);

   645     self->ConstructStorageL();

   646 	self->iContentType=CContentType::NewL();

   647     return self;

   648 	}

   649 

   650 EXPORT_C CContactItemField* CContactItemField::NewL(TStorageType aType, TFieldType aFieldType)

   651 /** Allocates and constructs a contact item field with a storage type 

   652 and a field type.

   653 

   654 The field's content type is initialised with the field type, 

   655 and its vCard mapping is set by default to KNullUid. The field's label is 

   656 unspecified.

   657 

   658 @param aType The field's storage type.

   659 @param aFieldType The field type as defined in cntdef.h.

   660 @return Pointer to the newly created contact item field. */

   661     { // static

   662     CContactItemField* self=CContactItemField::NewLC(aType,aFieldType);

   663     CleanupStack::Pop(); // self

   664     return self;

   665     }

   666 

   667 EXPORT_C CContactItemField* CContactItemField::NewLC(TStorageType aType, TFieldType aFieldType)

   668 /** Allocates and constructs a contact item field with a storage type 

   669 and a field type.

   670 

   671 The field's content type is initialised with the field type, 

   672 and its vCard mapping is set by default to KNullUid. The field's label is 

   673 unspecified.

   674 

   675 @param aType The field's storage type.

   676 @param aFieldType The field type as defined in cntdef.h.

   677 @return Pointer to the newly created contact item field. This is left on 

   678 the cleanup stack. */

   679     { // static

   680     CContactItemField* self=new(ELeave) CContactItemField(aType);

   681     CleanupStack::PushL(self);

   682     self->ConstructStorageL();

   683 	self->iContentType=CContentType::NewL(aFieldType);

   684     return self;

   685     }

   686 

   687 EXPORT_C CContactItemField* CContactItemField::NewL(const CContactItemField &aField)

   688 /** Allocates and constructs a contact item field based on another one.

   689 

   690 All details (content type, storage type, attributes and label) are copied 

   691 from the specified field.

   692 

   693 @param aField The contact field to copy.

   694 @return Pointer to the newly created contact item field. */

   695 	{ // static

   696 	CContactItemField* self=CContactItemField::NewLC(aField);

   697 	CleanupStack::Pop(); // self

   698 	return self;

   699 	}

   700 

   701 EXPORT_C CContactItemField* CContactItemField::NewLC(const CContactItemField &aField)

   702 /** Allocates and constructs a contact item field based on another one.

   703 

   704 All details (content type, storage type, attributes and label) are copied 

   705 from the specified field.

   706 

   707 @param aField The contact field to copy.

   708 @return Pointer to the newly created contact item field. This is left on 

   709 the cleanup stack. */

   710 	{ // static

   711 	CContactItemField* self=new(ELeave) CContactItemField(aField.StorageType());

   712 	CleanupStack::PushL(self);

   713 	self->ConstructStorageL();

   714 	self->CloneL(aField);

   715 	return self;

   716 	}

   717  

   718 EXPORT_C CContactItemField* CContactItemField::NewL(TStorageType aType, const CContentType &aContentType)

   719 /** Allocates and constructs a contact item field with a content type 

   720 and a storage type. 

   721 

   722 The field's label is unspecified.

   723 

   724 @param aType The field's storage type.

   725 @param aContentType The field's content type. 

   726 @return Pointer to the newly created contact item field. */

   727 	{ // static

   728 	CContactItemField* self=CContactItemField::NewLC(aType,aContentType);

   729 	CleanupStack::Pop(); // self

   730 	return self;

   731 	}

   732 

   733 EXPORT_C CContactItemField* CContactItemField::NewLC(TStorageType aType, const CContentType &aContentType)

   734 /** Allocates and constructs a contact item field with a content type 

   735 and a storage type. 

   736 

   737 The field's label is unspecified.

   738 

   739 @param aType The field's storage type.

   740 @param aContentType The field's content type. 

   741 @return Pointer to the newly created contact item field. This is left on 

   742 the cleanup stack. */

   743 	{ // static

   744 	CContactItemField* self=new(ELeave) CContactItemField(aType);

   745 	CleanupStack::PushL(self);

   746 	self->ConstructStorageL();

   747 	self->iContentType=CContentType::NewL(aContentType);

   748 	return self;

   749 	}

   750  

   751 CContactItemField::CContactItemField(TStorageType aType)

   752 	: iStorageType(aType), iAttributes(ESynchronize|EOverRidesLabel|ELabelUnspecified),iTemplateFieldId(KNullFieldId)

   753     {}

   754 

   755 CContactItemField::CContactItemField()

   756 	: iAttributes(ESynchronize),iTemplateFieldId(KNullFieldId)

   757     {}

   758 

   759 void CContactItemField::ConstructStorageL()

   760     {

   761 	__ASSERT_DEBUG(iStorage==NULL,Panic(ECntPanicStorageAlreadyAllocated));

   762     switch (iStorageType)

   763         {

   764     case KStorageTypeText:

   765         iStorage=new(ELeave) CContactTextField;

   766         break;

   767     case KStorageTypeStore:

   768         iStorage=new(ELeave) CContactStoreField;

   769         break;

   770     case KStorageTypeDateTime:

   771         iStorage=new(ELeave) CContactDateField;

   772         break;

   773     case KStorageTypeContactItemId:

   774         iStorage=new(ELeave) CContactAgentField;

   775         break;

   776     default:

   777     	User::Leave(KErrNotSupported);

   778     	break;

   779         }

   780     }

   781 

   782 void CContactItemField::CloneL(const CContactItemField &aField)

   783 	{

   784 	iContentType=CContentType::NewL(aField.ContentType());

   785 	if (aField.iLabel)

   786 		iLabel=aField.iLabel->AllocL();

   787 	iAttributes=aField.iAttributes;

   788 	// copy extended attributes as well

   789 	iExtendedAttributes=aField.iExtendedAttributes; 

   790 	iTemplateFieldId=aField.iTemplateFieldId;

   791 	CopyStorageL(aField);

   792 	}

   793 

   794 void CContactItemField::CopyStorageL(const CContactItemField &aField)

   795 	{

   796 	switch(aField.StorageType())

   797 		{

   798 		case KStorageTypeText:

   799 			TextStorage()->SetTextL(aField.TextStorage()->Text());

   800 			break;

   801 		case KStorageTypeDateTime:

   802 			DateTimeStorage()->SetTime(aField.DateTimeStorage()->Time());

   803 			break;

   804 		case KStorageTypeContactItemId:

   805 			AgentStorage()->SetAgentId(aField.AgentStorage()->Value());

   806 			break;

   807 		case KStorageTypeStore:

   808 			if (aField.StoreStorage()->Thing())

   809 				{

   810 				StoreStorage()->SetThingL(*aField.StoreStorage()->Thing());

   811 				}

   812 			break;

   813 		}

   814 	}

   815 

   816 EXPORT_C CContactItemField::~CContactItemField()

   817 /** Frees all resources owned by the field (the label, the stored 

   818 data and the content type), prior to its destruction. */

   819     {

   820     delete iLabel;

   821     delete iStorage;

   822 	delete iContentType;

   823     }

   824 

   825 /**

   826 @internalTechnology

   827   */

   828 EXPORT_C void CContactItemField::Reset()

   829 	{

   830     delete iLabel;

   831 	iLabel=NULL;

   832     delete iStorage;

   833 	iStorage=NULL;

   834 	iContentType->Reset();

   835 	iStorageType=0;

   836 	iId=KNullFieldId	;

   837 	iAttributes=ESynchronize;

   838 	iExtendedAttributes=0;

   839 	iTemplateFieldId=KNullFieldId;

   840 	}

   841 

   842 void CContactItemField::MapHintsToFieldTypesL(THint aHint)

   843 	{

   844 	if (aHint.IsPhone())

   845 		AddFieldTypeL(KUidContactFieldPhoneNumber);

   846 	if (aHint.IsMsg())

   847 		AddFieldTypeL(KUidContactFieldMsg);

   848 	if (aHint.IsCompanyName())

   849 		AddFieldTypeL(KUidContactFieldCompanyName);

   850 	if (aHint.IsFamilyName())

   851 		AddFieldTypeL(KUidContactFieldFamilyName);

   852 	if (aHint.IsGivenName())

   853 		AddFieldTypeL(KUidContactFieldGivenName);

   854 	if (aHint.IsCompanyNamePronunciation())

   855 		AddFieldTypeL(KUidContactFieldCompanyNamePronunciation);

   856 	if (aHint.IsFamilyNamePronunciation())

   857 		AddFieldTypeL(KUidContactFieldFamilyNamePronunciation);

   858 	if (aHint.IsGivenNamePronunciation())

   859 		AddFieldTypeL(KUidContactFieldGivenNamePronunciation);

   860 	if (aHint.IsAddress())

   861 		AddFieldTypeL(KUidContactFieldAddress);

   862 	if (aHint.IsAdditionalName())

   863 		AddFieldTypeL(KUidContactFieldAdditionalName);

   864 	if (aHint.IsSuffixName())

   865 		AddFieldTypeL(KUidContactFieldSuffixName);

   866 	if (aHint.IsPrefixName())

   867 		AddFieldTypeL(KUidContactFieldPrefixName);

   868 	if (aHint.IsEmail())

   869 		AddFieldTypeL(KUidContactFieldEMail);

   870 	if (aHint.IsStorageInline())

   871 		AddFieldTypeL(KUidContactStorageInline);

   872 	}

   873 

   874 TBool CContactItemField::AddFieldToHint(TFieldType aFieldType, CContactItemField::THint &aHint) const 

   875   	{

   876 	TBool matchedHint = ETrue;

   877 	switch(aFieldType.iUid)

   878 		{

   879 		case KUidContactFieldAddressValue:

   880 			aHint.SetIsAddress();

   881 			break;

   882 		case KUidContactFieldCompanyNameValue:

   883 			aHint.SetIsCompanyName();

   884 			break;

   885 		case KUidContactFieldPhoneNumberValue:

   886 			aHint.SetIsPhone();

   887 			break;

   888 		case KUidContactFieldGivenNameValue:

   889 			aHint.SetIsGivenName();

   890 			break;

   891 		case KUidContactFieldFamilyNameValue:

   892 			aHint.SetIsFamilyName();

   893 			break;

   894 		case KUidContactFieldCompanyNamePronunciationValue:

   895 			aHint.SetIsCompanyNamePronunciation();

   896 			break;

   897 		case KUidContactFieldGivenNamePronunciationValue:

   898 			aHint.SetIsGivenNamePronunciation();

   899 			break;

   900 		case KUidContactFieldFamilyNamePronunciationValue:

   901 			aHint.SetIsFamilyNamePronunciation();

   902 			break;

   903 		case KUidContactFieldAdditionalNameValue:

   904 			aHint.SetIsAdditionalName();

   905 			break;

   906 		case KUidContactFieldSuffixNameValue:

   907 			aHint.SetIsSuffixName();

   908 			break;

   909 		case KUidContactFieldPrefixNameValue:

   910 			aHint.SetIsPrefixName();

   911 			break;

   912 		case KUidContactFieldEMailValue:

   913 			aHint.SetIsEmail();

   914 			break;

   915 		case KUidContactFieldMsgValue:

   916 			aHint.SetIsMsg();

   917 			break;

   918 		case KUidContactFieldStorageInlineValue:

   919 			aHint.SetStorageIsInline();

   920 			break;

   921 		default:

   922 			matchedHint=EFalse;

   923 			break;

   924 		}

   925 	return(matchedHint);

   926 	}

   927 

   928 

   929 /**

   930 Encode contact field data into stream store.

   931 

   932 @param aTextStream the text blob stream to export text data.

   933 @param aBlobStore the binary blob stream to export binary data.

   934 @param aTextFieldIndex the index of text field stored in the storage

   935 

   936 @return field header which is to be stored into header blob. 

   937 @internalTechnology 

   938 */

   939 TFieldHeader CContactItemField::StoreL(RWriteStream& aTextStream, CStreamStore& aBlobStore, TInt aTextFieldIndex)

   940 	{

   941 	TStreamId streamId = KNullStreamIdValue;

   942 	if (iStorageType == KStorageTypeText)

   943 		{

   944 		STATIC_CAST(CContactTextField*,iStorage)->ExternalizeL(aTextStream, ETrue, aTextFieldIndex);

   945 		}

   946 	else

   947 	    {

   948 		streamId = iStorage->StoreL(aBlobStore);

   949 	    }

   950 	

   951 	TContactFieldAtts atts;

   952 	/* sets all attributes of the field:- hidden private etc.. + type (text etc..)

   953 	   into TContactFieldAtts which is then stored ahead of the field data */

   954 	atts.SetAttribs(iAttributes);

   955 	atts.SetExtendedAttribs(iExtendedAttributes);

   956 	atts.SetType(iStorageType);

   957     return TFieldHeader(atts, iId, streamId);

   958 	}

   959 

   960 

   961 /**

   962 Decode given blob header stream into contact field relevent data.

   963 

   964 @param aStream reference to the blob header stream to be decoded.

   965 @param aSystemTemplateFields cached template fields.

   966 

   967 @return the stream id of content data stored in data store 

   968 @internalTechnology 

   969 */

   970 EXPORT_C TStreamId CContactItemField::RestoreFieldTypesL(RReadStream &aStream, const CContactItemFieldSet *aSystemTemplateFields)

   971   	{

   972 	THint hint;

   973 	TStreamId nestedId(KNullStreamIdValue);

   974 	TContactFieldAtts fieldAtts;

   975 

   976 	aStream >> fieldAtts;

   977 	

   978 	iAttributes = fieldAtts.Attribs();

   979 	iExtendedAttributes = fieldAtts.ExtendedAttribs();

   980 	iStorageType = fieldAtts.Type();

   981 	

   982     if(fieldAtts.Type() != KStorageTypeText)

   983         {

   984    	    //Only import stream id when the storage type is not text

   985         aStream >> nestedId;

   986         }

   987         

   988     iId = aStream.ReadUint32L();

   989     iTemplateFieldId = aStream.ReadUint32L();

   990     

   991 	const CContactItemField* templateField = NULL;

   992 	

   993 	if (UsesTemplateTypes() || !OverRidesLabel())

   994 		{

   995 		if (aSystemTemplateFields == NULL)

   996 		    {

   997 			User::Leave(KErrCorrupt);

   998 		    }

   999 		templateField = aSystemTemplateFields->FindById(iTemplateFieldId);

  1000 		}

  1001 		

  1002 	if (templateField)

  1003 		{

  1004 		iAttributes |= (templateField->iAttributes&ETemplateMask);

  1005 		}

  1006 		

  1007 	if (UsesTemplateTypes() && templateField)

  1008 		{

  1009 		CContentType* newContent=CContentType::NewL(templateField->ContentType());

  1010 		delete iContentType;

  1011 		iContentType = NULL;

  1012 		iContentType=newContent;

  1013 		}

  1014 	else

  1015 		{

  1016   		hint = aStream.ReadInt32L();

  1017   		

  1018  		if(hint.HasVCardMappingUid())

  1019  		    {

  1020         	iContentType->SetMapping(TUid::Uid(aStream.ReadInt32L()));

  1021  		    }

  1022  		    

  1023 		MapHintsToFieldTypesL(hint);

  1024  		iContentType->InternalizeAdditionalUidsL(hint.AdditionalUidsNum(),aStream);

  1025 		}

  1026 		

  1027 	ConstructStorageL();

  1028 	

  1029 	if (OverRidesLabel())

  1030 		{

  1031 		const TInt length = aStream.ReadInt32L();

  1032 		if (length)

  1033 		    {

  1034 			iLabel = HBufC::NewL(aStream,length);

  1035 		    }

  1036 		}

  1037 	else if(templateField)

  1038 	    {

  1039 		iLabel = templateField->Label().AllocL();

  1040 	    }

  1041 		    

  1042 	return nestedId;

  1043     }

  1044 	

  1045 

  1046 void CContactItemField::RestoreDataL(CStreamStore& aStore,TStreamId aId)

  1047     {

  1048     RStoreReadStream stream;

  1049     stream.OpenLC(aStore,aId);

  1050 	iStorage->RestoreL(aStore,stream);

  1051 	CleanupStack::PopAndDestroy(); // stream

  1052 	}

  1053 

  1054 /**

  1055 @internalTechnology 

  1056 */

  1057 EXPORT_C void CContactItemField::RestoreTextL(HBufC *aTextStream,TInt aTextFieldIndex)

  1058     {

  1059 	__ASSERT_ALWAYS(iStorageType==KStorageTypeText,Panic(ECntPanicInvalidStorageType));

  1060     STATIC_CAST(CContactTextField*,iStorage)->InternalizeL(aTextStream,aTextFieldIndex);

  1061 	}

  1062 

  1063 /**

  1064 @internalTechnology 

  1065 */

  1066 EXPORT_C TBool CContactItemField::RestoreIfMatchL(RReadStream& aStream,const CContactItemFieldDef *aFieldDef, const CContactItemFieldSet *aSystemTemplateFields,HBufC *aTextStream,TInt aTextIndex)

  1067 	{

  1068 	TStreamId nestedId;

  1069 	nestedId=RestoreFieldTypesL(aStream,aSystemTemplateFields);

  1070 	TBool match=EFalse;

  1071 	if (aFieldDef==NULL)

  1072 		match=ETrue;

  1073 	else

  1074 		{

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

  1076 			{

  1077 			TUid fieldType=(*aFieldDef)[loop];

  1078 			if (fieldType==KUidContactFieldMatchAll || iContentType->ContainsFieldType(fieldType))

  1079 				{

  1080 				match=ETrue;

  1081 				break;

  1082 				}

  1083 			}

  1084 		}

  1085 	if (match && iStorageType==KStorageTypeText)

  1086 		RestoreTextL(aTextStream,aTextIndex);

  1087 	return match;

  1088 	}

  1089 	        

  1090 TBool CContactItemField::RestoreIfMatchL(RReadStream& aRootStream,TFieldType aFieldType, const CContactItemFieldSet *aSystemTemplateFields,HBufC *aTextStream,TInt aTextIndex)

  1091 	{

  1092 	CContactItemFieldDef* fieldDef=new(ELeave) CContactItemFieldDef();

  1093 	CleanupStack::PushL(fieldDef);

  1094 	fieldDef->AppendL(aFieldType);

  1095 	TBool ret=RestoreIfMatchL(aRootStream,fieldDef, aSystemTemplateFields,aTextStream,aTextIndex);

  1096 	CleanupStack::PopAndDestroy();	// fieldDef

  1097 	return(ret);

  1098 	}

  1099 

  1100 EXPORT_C TStorageType CContactItemField::StorageType() const

  1101 /** Gets the field's storage type.

  1102 

  1103 @return The field's storage type. */

  1104     {

  1105     return iStorageType;

  1106     }

  1107 

  1108 EXPORT_C const CContentType &CContactItemField::ContentType() const

  1109 /** Gets the field's content type.

  1110 

  1111 @return Reference to the field's content type. */

  1112     {

  1113     return *iContentType;

  1114     }

  1115 

  1116 const CContentType &CContactItemField::TemplateContentType(const CContactItemFieldSet &aSystemTemplateFields) const

  1117 	{

  1118 	if (UsesTemplateTypes() || OverRidesLabel())

  1119 		return(*iContentType);

  1120 	const CContactItemField *templateField=aSystemTemplateFields.FindById(iTemplateFieldId);

  1121 	if (!templateField)

  1122 		return(*iContentType);

  1123 	return(templateField->ContentType());

  1124 	}

  1125 

  1126 EXPORT_C TPtrC CContactItemField::Label() const

  1127 /** Gets the field's label.

  1128 

  1129 @return The field label. If no label has been set, its length is zero. */

  1130     {

  1131     TPtrC label;

  1132     if (iLabel)

  1133         label.Set(*iLabel);

  1134     return label;

  1135     }