1 /*

     2 * Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

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

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 

    19 #include <s32std.h>

    20 

    21 #include "cntstd.h"

    22 #include <cntdef.h>

    23 #include <cntfield.h>

    24 #include <cntfldst.h>

    25 

    26 #include <cntitem.h>

    27 #include <versit.h>

    28 #include "cntprof.h"

    29 #ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

    30 #include "cntfieldheader.h"

    31 #include "cnthint.h"

    32 #include "cntfield_internal.h"

    33 #endif

    34 

    35 //

    36 // class TContactFieldAtts

    37 //

    38 const TUint32 KAttribsMask		    = 0xf0000fff;

    39 const TUint32 KExtendedAttribsMask	= 0x000ff000;

    40 const TUint32 KStorageTypeMask	    = 0x00f00000;

    41 

    42 const TUint32 KTypeBitShift		    = 20;

    43 const TUint32 KExtendedAttsBitShift = 12;

    44 

    45 /** Set contact field attributes.

    46 

    47 @param aAttribs contact field arributes to be set.

    48 @internalTechnology

    49 */

    50 void TContactFieldAtts::SetAttribs(TUint32 aAttribs)

    51 	{

    52 	iStorage |= aAttribs;

    53 	}

    54 	

    55 /** Set contact field extended arributes.

    56 

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

    58 @internalTechnology

    59 */

    60 void TContactFieldAtts::SetExtendedAttribs(TUint32 aExtendedAttribs)

    61 	{

    62 	iStorage |= aExtendedAttribs << KExtendedAttsBitShift;

    63 	}

    64 

    65 /** Set storage type.

    66 

    67 @param aType storage type to set.

    68 @internalTechnology

    69 */

    70 void TContactFieldAtts::SetType(TStorageType aType)

    71 	{

    72 	iStorage |= aType << KTypeBitShift;

    73 	}

    74 

    75 /** Get contact field arributes.

    76 

    77 @return contact field arributes.

    78 @internalTechnology

    79 */

    80 TUint32 TContactFieldAtts::Attribs() const

    81 	{

    82 	return (iStorage & KAttribsMask);

    83 	}

    84 	

    85 /** Get contact field extended arributes.

    86 

    87 @return contact field extended arributes.

    88 @internalTechnology

    89 */

    90 TUint32 TContactFieldAtts::ExtendedAttribs() const

    91 	{

    92 	return (iStorage & KExtendedAttribsMask) >> KExtendedAttsBitShift;

    93 	}

    94 	

    95 /** Get contact field storage type.

    96 

    97 @return contact field storage type.

    98 @internalTechnology

    99 */

   100 TStorageType TContactFieldAtts::Type() const

   101 	{

   102 	return (iStorage & KStorageTypeMask) >> KTypeBitShift;

   103 	}

   104 	

   105 /** Internalize implementation.

   106 

   107 @internalTechnology

   108 */

   109 void TContactFieldAtts::InternalizeL(RReadStream& aStream)

   110 	{

   111 	iStorage=aStream.ReadUint32L();

   112 	}

   113 	

   114 /** Externalize implementation.

   115 

   116 @internalTechnology

   117 */

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

   119 	{

   120 	aStream.WriteUint32L(iStorage);

   121 	}

   122 

   123 

   124 //

   125 // class CContentType

   126 //

   127    

   128 EXPORT_C CContentType::~CContentType()

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

   130 to its destruction. */

   131     {

   132 	delete iFieldTypes;

   133 	}

   134       

   135 CContentType::CContentType()

   136     {

   137 	}

   138       

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

   140 	{

   141 	}

   142 	

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

   144 

   145 @param aStream RReadStream containing object to internalize.

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

   147 @internalTechnology

   148 */

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

   150 	{ // static

   151 	CContentType* type = NewL();

   152 	CleanupStack::PushL(type);

   153 	type->InternalizeL(aStream);

   154 	

   155 	return type;

   156 	}		

   157 

   158 EXPORT_C CContentType* CContentType::NewL()

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

   160 

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

   162 

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

   164 	{

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

   166 	CleanupStack::PushL(self);

   167 	self->ConstructL();

   168 	CleanupStack::Pop();	// self

   169 	return(self);

   170 	}

   171 

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

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

   174 type and a mapping.

   175 

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

   177 @param aMapping The mapping.

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

   179 	{

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

   181 	CleanupStack::PushL(self);

   182 	self->ConstructL();

   183 	self->AddFieldTypeL(aFieldType);

   184 	CleanupStack::Pop();	// self

   185 	return(self);

   186 	}

   187 

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

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

   190 

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

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

   193 	{ // static

   194 	CContentType* self=new(ELeave) CContentType;

   195 	CleanupStack::PushL(self);

   196 	self->ConstructL();

   197 	self->CloneL(aContentType);

   198 	CleanupStack::Pop();	// self

   199 	return self;

   200 	}

   201  

   202 void CContentType::ConstructL()

   203 	{

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

   205 	}

   206 

   207 EXPORT_C void CContentType::AddFieldTypeL(TFieldType aFieldType)

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

   209 

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

   211 used.

   212 

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

   214 	{

   215 	const TInt KMaxFieldTypes=15;

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

   217 		{

   218 		User::Leave(KErrOverflow);

   219 		}

   220     		

   221    	iFieldTypes->AppendL(aFieldType);

   222 	}

   223 

   224 EXPORT_C void CContentType::RemoveFieldType(TFieldType aFieldType)

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

   226 

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

   228 	{

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

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

   231 			{

   232 			iFieldTypes->Delete(loop);

   233 			break;

   234 			}

   235 	}

   236 

   237 EXPORT_C void CContentType::SetMapping(TUid aMapping)

   238 /** Sets the vCard mapping.

   239 

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

   241 	{

   242 	iMapping=aMapping;

   243 	}

   244 

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

   246 	{

   247     iMapping=aContentType.iMapping;

   248 	if (aContentType.iFieldTypes)

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

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

   251 	}

   252 

   253 EXPORT_C TInt CContentType::FieldTypeCount() const

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

   255 

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

   257 	{

   258 	return(iFieldTypes->Count());

   259 	}

   260 

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

   262 /** Gets the indexed field type.

   263 

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

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

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

   267 otherwise the operator raises a panic.

   268 @return The indexed field type. */

   269 	{

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

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

   272 	}

   273 

   274 EXPORT_C TUid CContentType::Mapping() const

   275 /** Gets the vCard mapping.

   276 

   277 @return The vCard mapping. */

   278 	{

   279 	return(iMapping);

   280 	}

   281 

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

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

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

   285 

   286 @param aFieldType The field type of interest.

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

   288 if not. */

   289 	{

   290 	if (iMapping==aFieldType)

   291 		return(ETrue);

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

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

   294 			return(ETrue);

   295 	return(EFalse);

   296 	}

   297 

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

   299 	{

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

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

   302 	}

   303 

   304 EXPORT_C TBool CContentType::SupportsMultipleLines() const

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

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

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

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

   309 fields (type KUidContactFieldNote).

   310 

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

   312 if not. */

   313 	{

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

   315 	}

   316 

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

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

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

   320 conditions are met:

   321 - vCard property mapping matches

   322 - same number of field types

   323 - main field type matches

   324 - additional field types and vCard property parameter mappings match

   325  

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

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

   328 	{

   329 	// Compare vCard property mapping.

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

   331 		{

   332 		return EFalse;

   333 		}

   334 	

   335 	// Compare field type counts.

   336 	const TInt typeCount = FieldTypeCount();

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

   338 		{

   339 		return EFalse;

   340 		}

   341 	if (typeCount <= 0)

   342 		{

   343 		// Nothing more to compare.

   344 		return ETrue;

   345 		}

   346 	

   347 	// Compare main field type.

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

   349 		{

   350 		return EFalse;

   351 		}

   352 	

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

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

   355 		{

   356 		TInt rhsIndex = 1;

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

   358 			{

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

   360 			    break;

   361 			}

   362 		if (rhsIndex == typeCount)

   363 			{

   364 			// No match found.

   365 			return EFalse;

   366 			}

   367 		}

   368 	

   369 	return ETrue;

   370 	}

   371 

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

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

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

   375 conditions are met:

   376 - vCard property mapping matches

   377 - same number of field types

   378 - main field type matches

   379 - additional field types and vCard property parameter mappings match

   380  

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

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

   383 	{

   384 	// Compare vCard property mapping.

   385 	if (iMapping!=aType.iMapping)

   386 		{

   387 		return(EFalse);	

   388 		}

   389 	

   390 	// Compare field type counts.

   391 	const TInt typeCount = aType.FieldTypeCount();

   392 	if (FieldTypeCount()!= typeCount)

   393 		{

   394 		return(EFalse);	

   395 		}

   396 		

   397     if (typeCount <= 0)

   398         {

   399         // Nothing more to compare.

   400         return ETrue;

   401         }

   402 			

   403     // Compare main field type.

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

   405         {

   406         return EFalse;

   407         }

   408 

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

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

   411         {

   412         TUint rightIndex = 1;

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

   414             {

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

   416                 break;

   417             }

   418         if (rightIndex == typeCount)

   419             {

   420             // No match found.

   421             return EFalse;

   422             }

   423         }

   424 

   425     return ETrue;

   426    	}

   427   	

   428 void CContentType::Reset()

   429 	{

   430 	iMapping=TUid::Uid(0);

   431 	iFieldTypes->Reset();

   432 	}

   433 

   434 

   435 /*

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

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

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

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

   440  *

   441  * @param		"const CContentType& aType"

   442  *				The content type to compare with this

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

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

   445  *				Otherwise the fields will not match.				  

   446  *

   447  * @return 		"TBool"

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

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

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

   451  */

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

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

   454 

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

   456 @return ETrue if aType is an identical content type

   457  */

   458 	{

   459 	if (iMapping!=aType.iMapping)

   460 		return(EFalse);	

   461 

   462 	switch (iMapping.iUid)

   463 		{

   464 	case KIntContactFieldVCardMapTEL:

   465 		{

   466 		TInt countModifier=0;

   467 		TInt loop=0;

   468 

   469 		if (aType.ContainsFieldType(KUidContactFieldVCardMapVOICE))

   470 			{

   471 			++countModifier;

   472 			}

   473 

   474 		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

   475 			{

   476 			++countModifier;

   477 			}

   478 		

   479 		if (ContainsFieldType(KUidContactFieldVCardMapVOICE))

   480 			{

   481 			--countModifier;

   482 			}

   483 

   484 		if (ContainsFieldType(KUidContactFieldVCardMapPREF))

   485 			{

   486 			--countModifier;

   487 			}

   488 

   489 		if (ContainsFieldType(KUidContactsVoiceDialField))

   490 			{

   491 			--countModifier;

   492 			}

   493 

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

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

   496 			{

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

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

   499 				{

   500 				--countModifier;

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

   502 				}

   503 			}

   504 	

   505 		//now check for field count	

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

   507 			{

   508 			return(EFalse);

   509 			}

   510 				

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

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

   513 			{

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

   515 				{

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

   517 					{

   518 					continue;

   519 					}

   520 				return(EFalse);

   521 				}

   522 			}

   523 		return(ETrue);

   524 		}

   525 

   526 	case KIntContactFieldVCardMapEMAILINTERNET:

   527 		{

   528 		TInt countModifier=0;		

   529 

   530 		if (aType.ContainsFieldType(KUidContactFieldVCardMapPREF))

   531 			{

   532 			++countModifier;

   533 			}

   534 		

   535 		if (ContainsFieldType(KUidContactFieldVCardMapPREF))

   536 			{

   537 			--countModifier;

   538 			}

   539 	

   540 		//now check for field count	

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

   542 			{

   543 			return(EFalse);

   544 			}

   545 				

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

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

   548 			{

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

   550 				{

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

   552 					{

   553 					continue;

   554 					}

   555 				return(EFalse);

   556 				}

   557 			}

   558 		return(ETrue);

   559 		}

   560 	

   561 	case KIntContactFieldVCardMapAGENT:

   562 		{

   563 		return(ETrue);

   564 		}	

   565 

   566 	default:

   567 		return *this==aType;

   568 		}

   569 	}

   570 	

   571 void CContentType::InternalizeL(RReadStream& aStream)

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

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

   574 	{

   575     // TUid iMapping;

   576 	iMapping.iUid = aStream.ReadInt32L();

   577 	

   578 	// CArrayFix<TUid>* iFieldTypes;

   579 	const TInt count=aStream.ReadInt32L();

   580 

   581 	// Allocated in constructor

   582 	TUid tempID;

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

   584 		{

   585 		

   586 		aStream>>tempID;		

   587 		iFieldTypes->AppendL(tempID);

   588 		}

   589 	}

   590 

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

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

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

   594 	{

   595 	aStream.WriteInt32L(iMapping.iUid);

   596 	

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

   598 	aStream.WriteInt32L(count);	

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

   600 		{

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

   602 		}

   603 	}		

   604 

   605 

   606 //

   607 // class CContactItemField

   608 //

   609 

   610 EXPORT_C CContactItemField* CContactItemField::NewLC()

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

   612 

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

   614 The ESynchronize attribute is set.

   615 

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

   617 	{

   618     CContactItemField* self=new(ELeave) CContactItemField;

   619     CleanupStack::PushL(self);

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

   621     return self;

   622 	}

   623 

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

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

   626 

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

   628 

   629 @param aType The field's storage type.

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

   631 	{

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

   633     CleanupStack::Pop(); // self

   634     return self;

   635 	}

   636 

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

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

   639 

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

   641 

   642 @param aType The field's storage type.

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

   644 the cleanup stack. */

   645 	{

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

   647     CleanupStack::PushL(self);

   648     self->ConstructStorageL();

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

   650     return self;

   651 	}

   652 

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

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

   655 and a field type.

   656 

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

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

   659 unspecified.

   660 

   661 @param aType The field's storage type.

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

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

   664     { // static

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

   666     CleanupStack::Pop(); // self

   667     return self;

   668     }

   669 

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

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

   672 and a field type.

   673 

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

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

   676 unspecified.

   677 

   678 @param aType The field's storage type.

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

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

   681 the cleanup stack. */

   682     { // static

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

   684     CleanupStack::PushL(self);

   685     self->ConstructStorageL();

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

   687     return self;

   688     }

   689 

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

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

   692 

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

   694 from the specified field.

   695 

   696 @param aField The contact field to copy.

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

   698 	{ // static

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

   700 	CleanupStack::Pop(); // self

   701 	return self;

   702 	}

   703 

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

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

   706 

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

   708 from the specified field.

   709 

   710 @param aField The contact field to copy.

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

   712 the cleanup stack. */

   713 	{ // static

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

   715 	CleanupStack::PushL(self);

   716 	self->ConstructStorageL();

   717 	self->CloneL(aField);

   718 	return self;

   719 	}

   720  

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

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

   723 and a storage type. 

   724 

   725 The field's label is unspecified.

   726 

   727 @param aType The field's storage type.

   728 @param aContentType The field's content type. 

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

   730 	{ // static

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

   732 	CleanupStack::Pop(); // self

   733 	return self;

   734 	}

   735 

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

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

   738 and a storage type. 

   739 

   740 The field's label is unspecified.

   741 

   742 @param aType The field's storage type.

   743 @param aContentType The field's content type. 

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

   745 the cleanup stack. */

   746 	{ // static

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

   748 	CleanupStack::PushL(self);

   749 	self->ConstructStorageL();

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

   751 	return self;

   752 	}

   753  

   754 CContactItemField::CContactItemField(TStorageType aType)

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

   756     {}

   757 

   758 CContactItemField::CContactItemField()

   759 	: iAttributes(ESynchronize),iTemplateFieldId(KNullFieldId)

   760     {}

   761 

   762 void CContactItemField::ConstructStorageL()

   763     {

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

   765     switch (iStorageType)

   766         {

   767     case KStorageTypeText:

   768         iStorage=new(ELeave) CContactTextField;

   769         break;

   770     case KStorageTypeStore:

   771         iStorage=new(ELeave) CContactStoreField;

   772         break;

   773     case KStorageTypeDateTime:

   774         iStorage=new(ELeave) CContactDateField;

   775         break;

   776     case KStorageTypeContactItemId:

   777         iStorage=new(ELeave) CContactAgentField;

   778         break;

   779     default:

   780     	User::Leave(KErrNotSupported);

   781     	break;

   782         }

   783     }

   784 

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

   786 	{

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

   788 	if (aField.iLabel)

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

   790 	iAttributes=aField.iAttributes;

   791 	// copy extended attributes as well

   792 	iExtendedAttributes=aField.iExtendedAttributes; 

   793 	iTemplateFieldId=aField.iTemplateFieldId;

   794 	CopyStorageL(aField);

   795 	}

   796 

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

   798 	{

   799 	switch(aField.StorageType())

   800 		{

   801 		case KStorageTypeText:

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

   803 			break;

   804 		case KStorageTypeDateTime:

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

   806 			break;

   807 		case KStorageTypeContactItemId:

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

   809 			break;

   810 		case KStorageTypeStore:

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

   812 				{

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

   814 				}

   815 			break;

   816 		}

   817 	}

   818 

   819 EXPORT_C CContactItemField::~CContactItemField()

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

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

   822     {

   823     delete iLabel;

   824     delete iStorage;

   825 	delete iContentType;

   826     }

   827 

   828 /**

   829 @internalTechnology

   830   */

   831 EXPORT_C void CContactItemField::Reset()

   832 	{

   833     delete iLabel;

   834 	iLabel=NULL;

   835     delete iStorage;

   836 	iStorage=NULL;

   837 	iContentType->Reset();

   838 	iStorageType=0;

   839 	iId=KNullFieldId	;

   840 	iAttributes=ESynchronize;

   841 	iExtendedAttributes=0;

   842 	iTemplateFieldId=KNullFieldId;

   843 	}

   844 

   845 void CContactItemField::MapHintsToFieldTypesL(THint aHint)

   846 	{

   847 	if (aHint.IsPhone())

   848 		AddFieldTypeL(KUidContactFieldPhoneNumber);

   849 	if (aHint.IsMsg())

   850 		AddFieldTypeL(KUidContactFieldMsg);

   851 	if (aHint.IsCompanyName())

   852 		AddFieldTypeL(KUidContactFieldCompanyName);

   853 	if (aHint.IsFamilyName())

   854 		AddFieldTypeL(KUidContactFieldFamilyName);

   855 	if (aHint.IsGivenName())

   856 		AddFieldTypeL(KUidContactFieldGivenName);

   857 	if (aHint.IsCompanyNamePronunciation())

   858 		AddFieldTypeL(KUidContactFieldCompanyNamePronunciation);

   859 	if (aHint.IsFamilyNamePronunciation())

   860 		AddFieldTypeL(KUidContactFieldFamilyNamePronunciation);

   861 	if (aHint.IsGivenNamePronunciation())

   862 		AddFieldTypeL(KUidContactFieldGivenNamePronunciation);

   863 	if (aHint.IsAddress())

   864 		AddFieldTypeL(KUidContactFieldAddress);

   865 	if (aHint.IsAdditionalName())

   866 		AddFieldTypeL(KUidContactFieldAdditionalName);

   867 	if (aHint.IsSuffixName())

   868 		AddFieldTypeL(KUidContactFieldSuffixName);

   869 	if (aHint.IsPrefixName())

   870 		AddFieldTypeL(KUidContactFieldPrefixName);

   871 	if (aHint.IsEmail())

   872 		AddFieldTypeL(KUidContactFieldEMail);

   873 	if (aHint.IsStorageInline())

   874 		AddFieldTypeL(KUidContactStorageInline);

   875 	}

   876 

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

   878   	{

   879 	TBool matchedHint = ETrue;

   880 	switch(aFieldType.iUid)

   881 		{

   882 		case KUidContactFieldAddressValue:

   883 			aHint.SetIsAddress();

   884 			break;

   885 		case KUidContactFieldCompanyNameValue:

   886 			aHint.SetIsCompanyName();

   887 			break;

   888 		case KUidContactFieldPhoneNumberValue:

   889 			aHint.SetIsPhone();

   890 			break;

   891 		case KUidContactFieldGivenNameValue:

   892 			aHint.SetIsGivenName();

   893 			break;

   894 		case KUidContactFieldFamilyNameValue:

   895 			aHint.SetIsFamilyName();

   896 			break;

   897 		case KUidContactFieldCompanyNamePronunciationValue:

   898 			aHint.SetIsCompanyNamePronunciation();

   899 			break;

   900 		case KUidContactFieldGivenNamePronunciationValue:

   901 			aHint.SetIsGivenNamePronunciation();

   902 			break;

   903 		case KUidContactFieldFamilyNamePronunciationValue:

   904 			aHint.SetIsFamilyNamePronunciation();

   905 			break;

   906 		case KUidContactFieldAdditionalNameValue:

   907 			aHint.SetIsAdditionalName();

   908 			break;

   909 		case KUidContactFieldSuffixNameValue:

   910 			aHint.SetIsSuffixName();

   911 			break;

   912 		case KUidContactFieldPrefixNameValue:

   913 			aHint.SetIsPrefixName();

   914 			break;

   915 		case KUidContactFieldEMailValue:

   916 			aHint.SetIsEmail();

   917 			break;

   918 		case KUidContactFieldMsgValue:

   919 			aHint.SetIsMsg();

   920 			break;

   921 		case KUidContactFieldStorageInlineValue:

   922 			aHint.SetStorageIsInline();

   923 			break;

   924 		default:

   925 			matchedHint=EFalse;

   926 			break;

   927 		}

   928 	return(matchedHint);

   929 	}

   930 

   931 

   932 /**

   933 Encode contact field data into stream store.

   934 

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

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

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

   938 

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

   940 @internalTechnology 

   941 */

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

   943 	{

   944 	TStreamId streamId = KNullStreamIdValue;

   945 	if (iStorageType == KStorageTypeText)

   946 		{

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

   948 		}

   949 	else

   950 	    {

   951 		streamId = iStorage->StoreL(aBlobStore);

   952 	    }

   953 	

   954 	TContactFieldAtts atts;

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

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

   957 	atts.SetAttribs(iAttributes);

   958 	atts.SetExtendedAttribs(iExtendedAttributes);

   959 	atts.SetType(iStorageType);

   960     return TFieldHeader(atts, iId, streamId);

   961 	}

   962 

   963 

   964 /**

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

   966 

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

   968 @param aSystemTemplateFields cached template fields.

   969 

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

   971 @internalTechnology 

   972 */

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

   974   	{

   975 	THint hint;

   976 	TStreamId nestedId(KNullStreamIdValue);

   977 	TContactFieldAtts fieldAtts;

   978 

   979 	aStream >> fieldAtts;

   980 	

   981 	iAttributes = fieldAtts.Attribs();

   982 	iExtendedAttributes = fieldAtts.ExtendedAttribs();

   983 	iStorageType = fieldAtts.Type();

   984 	

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

   986         {

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

   988         aStream >> nestedId;

   989         }

   990         

   991     iId = aStream.ReadUint32L();

   992     iTemplateFieldId = aStream.ReadUint32L();

   993     

   994 	const CContactItemField* templateField = NULL;

   995 	

   996 	if (UsesTemplateTypes() || !OverRidesLabel())

   997 		{

   998 		if (aSystemTemplateFields == NULL)

   999 		    {

  1000 			User::Leave(KErrCorrupt);

  1001 		    }

  1002 		templateField = aSystemTemplateFields->FindById(iTemplateFieldId);

  1003 		}

  1004 		

  1005 	if (templateField)

  1006 		{

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

  1008 		}

  1009 		

  1010 	if (UsesTemplateTypes() && templateField)

  1011 		{

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

  1013 		delete iContentType;

  1014 		iContentType = NULL;

  1015 		iContentType=newContent;

  1016 		}

  1017 	else

  1018 		{

  1019   		hint = aStream.ReadInt32L();

  1020   		

  1021  		if(hint.HasVCardMappingUid())

  1022  		    {

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

  1024  		    }

  1025  		    

  1026 		MapHintsToFieldTypesL(hint);

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

  1028 		}

  1029 		

  1030 	ConstructStorageL();

  1031 	

  1032 	if (OverRidesLabel())

  1033 		{

  1034 		const TInt length = aStream.ReadInt32L();

  1035 		if (length)

  1036 		    {

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

  1038 		    }

  1039 		}

  1040 	else if(templateField)

  1041 	    {

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

  1043 	    }

  1044 		    

  1045 	return nestedId;

  1046     }

  1047 	

  1048 

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

  1050     {

  1051     RStoreReadStream stream;

  1052     stream.OpenLC(aStore,aId);

  1053 	iStorage->RestoreL(aStore,stream);

  1054 	CleanupStack::PopAndDestroy(); // stream

  1055 	}

  1056 

  1057 /**

  1058 @internalTechnology 

  1059 */

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

  1061     {

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

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

  1064 	}

  1065 

  1066 /**

  1067 @internalTechnology 

  1068 */

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

  1070 	{

  1071 	TStreamId nestedId;

  1072 	nestedId=RestoreFieldTypesL(aStream,aSystemTemplateFields);

  1073 	TBool match=EFalse;

  1074 	if (aFieldDef==NULL)

  1075 		match=ETrue;

  1076 	else

  1077 		{

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

  1079 			{

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

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

  1082 				{

  1083 				match=ETrue;

  1084 				break;

  1085 				}

  1086 			}

  1087 		}

  1088 	if (match && iStorageType==KStorageTypeText)

  1089 		RestoreTextL(aTextStream,aTextIndex);

  1090 	return match;

  1091 	}

  1092 	        

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

  1094 	{

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

  1096 	CleanupStack::PushL(fieldDef);

  1097 	fieldDef->AppendL(aFieldType);

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

  1099 	CleanupStack::PopAndDestroy();	// fieldDef

  1100 	return(ret);

  1101 	}

  1102 

  1103 EXPORT_C TStorageType CContactItemField::StorageType() const

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

  1105 

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

  1107     {

  1108     return iStorageType;

  1109     }

  1110 

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

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

  1113 

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

  1115     {

  1116     return *iContentType;

  1117     }

  1118 

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

  1120 	{

  1121 	if (UsesTemplateTypes() || OverRidesLabel())

  1122 		return(*iContentType);

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

  1124 	if (!templateField)

  1125 		return(*iContentType);

  1126 	return(templateField->ContentType());

  1127 	}

  1128 

  1129 EXPORT_C TPtrC CContactItemField::Label() const

  1130 /** Gets the field's label.

  1131 

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

  1133     {

  1134     TPtrC label;

  1135     if (iLabel)