// CNTDB.H
//
// Copyright (c) 1997-1999 Symbian Ltd.  All rights reserved.
//

#if !defined(__CNTDB_H__)
#define __CNTDB_H__

#if !defined(__E32BASE_H__)
#include <e32base.h>
#endif

#if !defined(__D32DBMS_H__)
#include <d32dbms.h>
#endif

#if !defined(__CNTDEF_H__)
#include <cntdef.h>
#endif

#if !defined(__CNTDBOBS_H__)
#include <cntdbobs.h>
#endif

#if !defined(__S32FILE_H__)
#include <s32file.h>
#endif

#if !defined(__BADESCA_H__)
#include <badesca.h>
#endif

class CContactItem;
class CContactGroup;
class RFs;
class RFile;
class CContactItemFieldDef;
class CPrivateChangeNotifier;
class CPrivateChangeEventNotifier;
class CContactDatabase;
class CContactSrvSession;
class CTextFieldMinimal;
class CCnaConverterList;
class CPrivItemTableColSet;
class CPrivFindViewColSet;
class CContentType;
class CContactDateField;
class CContactItemField;
class CContactItemFieldSet;
class CFoundMatches;	

const TInt KMaxContactTextSeperator=4;
const TInt KTextFieldMinimalLength=64;

const TInt KMajorVersion=1;
const TInt KMinorVersion=0;
const TInt KBuildNumber=40;
//
// Classes used for compact 
//

class MContactUiCompactObserver
	{
public:
	virtual void Step(TInt aStep)=0;
	virtual void HandleError(TInt aError)=0;
	};

class MContactUiActive
	{
public:
	virtual void Cancel()=0;
	virtual void SetObserver(MContactUiCompactObserver *aObserver)=0;
	virtual TInt StepsTogo() const=0;
	virtual TInt Step()=0;
	virtual TInt Error() const=0;
	};

class CContactActiveBase : public CBase, public MContactUiActive
	{
public:
	~CContactActiveBase();
	void SetObserver(MContactUiCompactObserver *aObserver);
	void Cancel();
	TInt StepsTogo() const;
	TInt Step();
	TInt Error() const;
protected:
	void ConstructL();
	static TInt CompactCallBack(TAny *aThis);
protected:
	MContactUiCompactObserver *iObserver;
	RDbIncremental iDbInc;
	CIdle *iIdle;
	TInt iStep;
	TInt iError;
	};

class CContactActiveCompress : public CContactActiveBase
	{
public:
	void ConstructL(RDbNamedDatabase &aDataBase);
	};

class CContactActiveRecover : public CContactActiveBase
	{
public:
	void ConstructL(RDbNamedDatabase &aDataBase);
	};

/////

class TContactTextDefItem
	{
public:
	IMPORT_C TContactTextDefItem();
	IMPORT_C TContactTextDefItem(TFieldType aFieldType);
	IMPORT_C TContactTextDefItem(TFieldType aFieldType, const TDesC &aSeperator);
public:
	TFieldType iFieldType;
	TBuf<KMaxContactTextSeperator> iSeperator;
	};

class CContactTextDef : public CArrayFixFlat<TContactTextDefItem>
	{
	friend class CContactDatabase;
public:
	CContactTextDef();
	IMPORT_C static CContactTextDef* NewL();
	IMPORT_C static CContactTextDef* NewLC();
	IMPORT_C void SetFallbackField(TFieldType iFieldType);
	IMPORT_C TFieldType FallbackField() const;
private:
	TFieldType iFallbackFieldType;
	};

class CContactItemViewDef : public CBase
	{
public:
	enum TUse { EIncludeFields,EMaskFields };
	enum TMode { EIncludeHiddenFields,EMaskHiddenFields };
public:
	IMPORT_C static CContactItemViewDef* NewL(TUse aUse, TMode aMode);
	IMPORT_C static CContactItemViewDef* NewLC(TUse aUse, TMode aMode);
    inline TUid operator[](TInt aIndex) const;
    IMPORT_C TInt Find(const CContentType &aContentType) const;
    IMPORT_C TInt Find(TFieldType aFieldType) const;
    inline TInt Count() const;
    inline void Reset();
	IMPORT_C void AddL(TFieldType aFieldType);
	IMPORT_C void Remove(TFieldType aFieldType);
	IMPORT_C void Remove(TInt aIndex);
	inline TUse Use() const;
	inline void SetUse(TUse aUse);
	inline TMode Mode() const;
	inline void SetMode(TMode aMode);
	IMPORT_C TBool Contains(const CContactItem& aItem);
	IMPORT_C void InternalizeL(RReadStream& aStream);
	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;	
	IMPORT_C TBool MatchesAll() const;
private:
	CContactItemViewDef(TUse aUse,TMode aMode);
private:
    CArrayFixFlat<TUid> iFieldTypes;
	TUse iUse;
	TMode iMode;
	};

class CContactViewDef : public CBase
	{
public:
	IMPORT_C static CContactViewDef* NewL();
	IMPORT_C static CContactViewDef* NewLC();
	IMPORT_C static CContactViewDef* NewL(CContactItemViewDef* aItemDef);
	IMPORT_C static CContactViewDef* NewLC(CContactItemViewDef* aItemDef);
	IMPORT_C ~CContactViewDef();
	IMPORT_C void InternalizeL(RReadStream& aStream);
	IMPORT_C void ExternalizeL(RWriteStream& aStream) const;
	IMPORT_C CContactItemViewDef& ItemDef() const;
	IMPORT_C CContactIdArray& Groups() const;
	inline void AddL(TFieldType aFieldType);
private:
	CContactViewDef();
	void ConstructL(CContactItemViewDef* aItemDef);
private:
	CContactItemViewDef* iItemDef;
//	CContactIdArray* iGroupIds; // unused for now
	};

class TContactIter
	{
public:
	IMPORT_C TContactIter(CContactDatabase &aDatabase);
	IMPORT_C TContactItemId FirstL();
	IMPORT_C TContactItemId NextL();
	IMPORT_C TContactItemId PreviousL();
	IMPORT_C TContactItemId LastL();
	IMPORT_C void GotoL(TContactItemId aContactId);
	IMPORT_C void Reset();
private:
	void GotoIndexL(TInt aPos);
private:
	CContactDatabase &iDatabase;
	TContactItemId iCursorId;
	};

class MIdleFindObserver
	{
public:
	virtual void IdleFindCallback()=0;
	};

struct SFindInTextDefWordParser
	{
public:
	inline SFindInTextDefWordParser(const TDesC *aSearchString, CDesCArray *aWordArray) : iSearchString(aSearchString), iWordArray(aWordArray) {};
public:
	const TDesC *iSearchString;
	CDesCArray *iWordArray;
	};

class CIdleFinder : public CIdle
	{
public:
	~CIdleFinder();
	IMPORT_C TBool IsComplete() const;
	IMPORT_C CContactIdArray *TakeContactIds();
	IMPORT_C TInt Error() const;
	TInt doFindL();
private:
	friend class CContactDatabase;
	static CIdleFinder *NewL(CContactDatabase &aContactDatabase, const TDesC& aText, const CContactItemFieldDef *aFieldDef, MIdleFindObserver *aObserver);
	static CIdleFinder *NewL(CContactDatabase &aContactDatabase, const MDesCArray* aFindWords,const CContactTextDef* aTextDef, MIdleFindObserver *aObserver, const TCallBack &aWordParserCallback);
	void Start();
	IMPORT_C static TInt CallbackL(TAny *aSelf);
	void ConstructL(const TDesC *aText, const MDesCArray* aFindWords, const TCallBack *aWordParserCallback);
	TBool ScanForMatch(const TDesC &aFieldText,const TDesC &aFindText, CFoundMatches *aFoundMatches) const;
	TBool CheckFindL(const CContactItemFieldSet *aFieldSet);
	CIdleFinder(CContactDatabase &aContactDatabase, const CContactItemFieldDef *aFieldDef, const CContactTextDef* aTextDef, MIdleFindObserver *aObserver);
	void DoCancel();
private:
	CContactDatabase *iContactDatabase;
	CContactIdArray *iIdsFound;
	TBool iOwnsIds;
	CDesCArray* iFindWords;
	CDesCArray* iFindWords2;
	HBufC *iText;
	const CContactItemFieldDef* iFieldDef;
	const CContactTextDef* iTextDef;
	MIdleFindObserver *iObserver;
	TInt iError;
	TCallBack iWordParserCallback;
	};

class MContactDbPrivObserver
	{
public:
	virtual void HandleDatabaseEventL(RDbNotifier::TEvent)=0;
	virtual void HandleDatabaseEventL(const TContactDbObserverEvent &aEvent)=0;
	};

class CContactDatabase : public CBase, public MContactDbPrivObserver
	{
	friend class TContactIter;
	friend class CContactActiveRecover;
	friend class CIdleFinder;
public:
	class TSortPref
		{
	public:
		enum TOrder {EAsc,EDesc};
	public:
		inline TSortPref();
		inline TSortPref(TFieldType aFieldType,TOrder aOrder=EAsc);
		void ExternalizeL(RWriteStream& aStream) const;
		void InternalizeL(RReadStream& aStream);
	public:
		TOrder iOrder;
		TFieldType iFieldType;
		};
	enum TOptions 
  		{
  		EDefault=0x0,
		EIncludeX =0x01,
  		ETTFormat =0x02,
		EExcludeUid=0x04,
		EDecreaseAccessCount=0x08,
		EImportSingleContact=0x10,
		EIncreaseAccessCount=0x20,
  		};
public:
	IMPORT_C static CContactDatabase* OpenL();
	IMPORT_C static CContactDatabase* OpenL(const TDesC& aFileName);
	IMPORT_C static CContactDatabase* CreateL();
	IMPORT_C static CContactDatabase* CreateL(const TDesC& aFileName);
	IMPORT_C static CContactDatabase* ReplaceL();
	IMPORT_C static CContactDatabase* ReplaceL(const TDesC& aFileName);
	IMPORT_C static TBool DatabaseDrive(TDriveUnit &aDriveUnit);
	IMPORT_C static TBool FindContactFile(TDes &aFileName);
	IMPORT_C static void SetDatabaseDriveL(TDriveUnit aDriveUnit, TBool aCopy=ETrue);
	IMPORT_C static void GetDefaultNameL(TDes &aDes);
	IMPORT_C static void DeleteDefaultFileL();
	IMPORT_C ~CContactDatabase();

	IMPORT_C void SetViewDefinitionL(CContactViewDef* aView);
	IMPORT_C void SetTextDefinitionL(CContactTextDef* aView);
	IMPORT_C const CContactTextDef* TextDefinition() const;
	IMPORT_C TInt CountL();
	
	IMPORT_C TContactItemId AddNewContactL(CContactItem& aContact);
	IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId);
	IMPORT_C CArrayPtr<CContactItem>* ReadContactAndAgentL(TContactItemId aContactId);
	IMPORT_C CContactItem* ReadContactL(TContactItemId aContactId,const CContactItemViewDef& aViewDef);
	IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId);
	IMPORT_C CContactItem* ReadContactLC(TContactItemId aContactId,const CContactItemViewDef& aViewDef);
	IMPORT_C void ReadContactTextDefL(const CContactItem &aItem, TDes &aResult);
	IMPORT_C void ReadContactTextDefL(const CContactItem &aItem, TDes &aResult,CContactTextDef* aTextDef);
	IMPORT_C void ReadContactTextDefL(TContactItemId aContactId, TDes &aResult);
	IMPORT_C void ReadContactTextDefL(TContactItemId aContactId, TDes &aResult,CContactTextDef* aTextDef);
	IMPORT_C CContactItem* OpenContactL(TContactItemId aContactId);
	IMPORT_C CContactItem* OpenContactL(TContactItemId aContactId,const CContactItemViewDef& aViewDef);
	IMPORT_C CContactItem* OpenContactLX(TContactItemId aContactId);
	IMPORT_C CContactItem* OpenContactLX(TContactItemId aContactId,const CContactItemViewDef& aViewDef);
	IMPORT_C void CloseContactL(TContactItemId aContactId);
	IMPORT_C void CommitContactL(const CContactItem& aContact);
	IMPORT_C void DeleteContactL(TContactItemId aContactId);
	IMPORT_C void DeleteContactsL(const CContactIdArray& aContactIds);
  	IMPORT_C CArrayPtr<CContactItem>* ImportContactsL(const TUid& aFormat,RReadStream& aReadStream,TBool& aImportSuccessful,TInt aOption);
  	IMPORT_C void ExportSelectedContactsL(const TUid& aFormat,const CContactIdArray& aSelectedContactIds,RWriteStream& aWriteStream,TInt aOption);
	IMPORT_C void CompactL();

	IMPORT_C CContactIdArray* FindLC(const TDesC& aText,const CContactItemFieldDef *aFieldDef);
	IMPORT_C CIdleFinder* FindAsyncL(const TDesC& aText,const CContactItemFieldDef *aFieldDef, MIdleFindObserver *aObserver);
	IMPORT_C CContactIdArray* FindInTextDefLC(const MDesCArray& aFindWords, const TCallBack &aWordParserCallback);
	IMPORT_C CContactIdArray* FindInTextDefLC(const MDesCArray& aFindWords,CContactTextDef* aTextDef, const TCallBack &aWordParserCallback);
	IMPORT_C CIdleFinder* FindInTextDefAsyncL(const MDesCArray& aFindWords, MIdleFindObserver *aObserver, const TCallBack &aWordParserCallback);
	IMPORT_C CIdleFinder* FindInTextDefAsyncL(const MDesCArray& aFindWords,const CContactTextDef* aTextDef, MIdleFindObserver *aObserver, const TCallBack &aWordParserCallback);
	IMPORT_C CContactIdArray* SortArrayL(const CContactIdArray* aIdArray, const CArrayFix<TSortPref>* aSortOrder);
	IMPORT_C void SortL(CArrayFix<TSortPref>* aSortOrder);
	IMPORT_C void ReplacePrefL(TInt anId);
	IMPORT_C void ReadPrefL(TInt32 anId);
	IMPORT_C TInt32 CreatePrefL();
  	IMPORT_C TPtrC FileUid();
	IMPORT_C CContactActiveCompress* CreateCompressorLC();
	IMPORT_C CContactActiveRecover* CreateRecoverLC();
	IMPORT_C void RecoverL();
	IMPORT_C TBool IsDamaged() const;
	IMPORT_C void CompressL();
	IMPORT_C TBool CompressRequired();
	IMPORT_C void CloseTables();
	IMPORT_C void OpenTablesL();
	IMPORT_C static CContactDatabase* LockServerConnectL(const TDesC& aFileName);
	IMPORT_C TInt InitLoadPhoneMatchesL();
	IMPORT_C TInt LoadPhoneMatchesL();
	IMPORT_C CContactIdArray *PhoneMatchListL(const TDesC &aNumber) const;
	IMPORT_C const CContactIdArray* SortedItemsL();
	IMPORT_C TContactItemId TemplateId() const;
	IMPORT_C void SetDateFormatTextL(const TDesC &aFormat);
	IMPORT_C CContactIdArray* ContactsChangedSinceL(const TTime& aTime);
	IMPORT_C TInt FileSize() const;
	IMPORT_C TUint ConnectionId() const;
	IMPORT_C const CContentType &TemplateContentType(const CContactItemField &aField) const;
	IMPORT_C TVersion Version() const;
	void UnlockLastLockedContact();
	void CancelItemTableTransaction();
	void CancelGroupTableTransaction();
	void CancelPrefTableTransaction();
	TBool doFindL(CContactIdArray *aIdsFound, const TDesC& aText,const CContactItemFieldDef *aFieldDef);
	TBool doFindInTextDefL(CIdleFinder *iIdleFinder);
	void EndFind();
	void SendChangeEvent(TContactDbObserverEventType aType, TContactItemId aId);
public:	// For test code only
	IMPORT_C void DamageDatabaseL(TInt aSecretCode);	// Don't use this, you don't really want to damage your database do you?
	IMPORT_C void OverrideMachineUniqueId(TInt64 aMachineUniqueId);
	IMPORT_C TInt CntServerResourceCount();
	IMPORT_C void SetCntServerHeapFailure(RHeap::TAllocFail aType,TInt aRate);
	IMPORT_C TInt BlobSizeL(TContactItemId aContactId);
	IMPORT_C CContactIdArray* DeletedContactsLC();
public:	// For cnt server only
	IMPORT_C void HandleDatabaseEventL(const TContactDbObserverEvent &aEvent);
	IMPORT_C static TInt TextToPhoneMatchNumber(const TDesC &aText, TInt &aNumDigits);
private:
	void DeleteFindView();
	TContactItemId FindMatchingUidStringL(const TDesC &aUidString);
	TBool CheckFindL(CIdleFinder *aIdleFinder);
	TInt NumRetries() const;
	void ItemTableUpdateWithRetryL();
	void ItemTableInsertWithRetryL();
	void ItemTableDeleteWithRetryL();
	friend class CContactChangeNotifier;
	static void CleanupDatabaseRollback(TAny *aDatabase);
	void DatabaseBeginLC(TBool aIsInTransaction);
	void DatabaseCommitLP(TBool aIsInTransaction);
	void StartLockServerL(const TDesC& aFileName);
	TBool CheckSortError(TInt aError);
	void AddObserverL(MContactDbObserver *aChangeNotifier);
	void RemoveObserver(const MContactDbObserver *aChangeNotifier);
	CEmbeddedStore* OpenBlobStreamLC(RDbColReadStream &aBlob, TDbColNo aCol, RStoreReadStream &aRootStream, TInt &aFieldCount);
	void doReadContactTextDefL(const CContactItemFieldSet* aFieldSet, TBool aReadFromDb,TDes &aResult,CContactTextDef* aTextDef);
	void LockRecordLC(TContactItemId aContactId);
	void UnlockRecord(TContactItemId aContactId);
  	CContactItem *UpdateContactLC(TContactItemId aContactId,CContactItem* aNewContact);
	TBool FindFieldNameColLC(const CContentType &aType);
	void CreatePrefInternalL();
	TBool ReadPrefInternalL();
	void CancelSystemTemplate();
	CContactItem *SystemTemplateL() const;
private:
	typedef TBuf<KTextFieldMinimalLength> TTextFieldMinimal;
	class CSortArray : public CBase
		{
	public:
		CSortArray();
		~CSortArray();
		void AppendL(const TDesC &Text, TContactItemId aId);
		void SortL(TSortPref::TOrder aOrder);
		inline TInt Count() const;
		TContactItemId Id(TInt aIndex) const;
		HBufC *Text(TInt aIndex) const;
		void Merge(CSortArray *aDuplicates,TInt aStartPos);
	private:
		CArrayPtrFlat<CTextFieldMinimal> iArray;
		};
	enum TDirection {EAsc,EDesc};
private:
	CContactDatabase();
	static void ConnectFsLC(RFs &aFs);
	void doOpenL(const TDesC& aFileName);
	void doCreateL(const TDesC& aFileName, TBool aReplace);
	TContactItemId doAddNewContactL(CContactItem& aContact,TBool aIsTemplate,TBool aIsInTransaction);
	void doDeleteContactsL(const CContactIdArray& aContactIds, TBool &aCommited);
	void doDeleteContactL(TContactItemId aContactId, TBool aIsInTransaction, TBool aSendChangedEvent, TBool aDecAccessCount=EFalse);
	void doCommitContactL(const CContactItem& aContact,TBool aIsInTransaction, TBool aSendChangedEvent);
	CContactItem* doReadContactLC(TContactItemId aContactId,const CContactItemViewDef& aViewDef, TBool aDontUseTemplate);
	void CreateTemplateAndPrefsL();
	void WriteBlobColL(const CContactItem& aContact,TDbColNo aColNo,const CContactItem* aTemplate);
	void HandleRetryError(TInt aErr,TInt &aAttemptsLeft, TBool aRetryNotFound);
	void BlobOpenWithRetryL(RDbColReadStream &aBlob, TDbColNo aColNo);
	void ReadBlobColL(CContactItem& aContact,TDbColNo aColNo,const CContactItemViewDef& aViewDef,const CContactItem* aTemplate);
#ifdef CNTDB_GROUPS
	void WriteIdsColL(TDbColNo aColNo,CContactIdArray* aIdArray);
	void ReadIdsColL(CContactGroup& aGroup,TDbColNo aColNo);
#endif
	TInt DoGotoL(TContactItemId aContactId);
	TInt NextExistingL(TInt aIndex);
	TInt PreviousExistingL(TInt aIndex);
	inline void __DbgDbmsResourceMark();
	inline void __DbgDbmsResourceCheck();
	void static GetFieldText(const CContactItemField& aField, CContactDatabase::TTextFieldMinimal &aText);
	void static FieldText(const CContactItemFieldSet& aFieldSet,TFieldType aFieldType, CContactDatabase::TTextFieldMinimal &aText);
	void static NonZeroFieldText(const CContactItemFieldSet& aFieldSet,TFieldType aFieldType, CContactDatabase::TTextFieldMinimal &aText);
	void doGetTextFieldInfoL(TFieldType aFieldType, CContactDatabase::TTextFieldMinimal &aText);
	void GetTextFieldInfoL(TFieldType aFieldType, CContactDatabase::TTextFieldMinimal &aText);
	CContactIdArray* doSortL(const CArrayFix<TSortPref>* aSortOrder, const CContactIdArray* aIdArray);
	void ReSortL(CArrayFix<TSortPref>* aSortOrder);
	void SortWithoutOrderL(CContactIdArray* aArray);
	void SortDuplicatesL(const CArrayFix<TSortPref>& aSortOrder,CSortArray& aList,TInt aPos);
	void SortDuplicatesL(const CArrayFix<TSortPref>& aSortOrder,CSortArray& aList,
								TInt aIndex,TInt aStartPos,TInt aEndPos);
	void InsertInSortArray(const CContactItem& aContact);
	void MoveInSortArray(const CContactItem& aContact);
	void RemoveFromSortArray(TContactItemId aContactId);
	void InsertInSortArrayL(const CContactItem& aContact);
	void MoveInSortArrayL(const CContactItem& aContact);
	TInt NewSortIndexL(const CContactItemFieldSet& aFieldSet,TInt aStartPos,TInt aEndPos);
	TInt CompareSortFieldsL(const CContactItemFieldSet& aFieldSet);
	TInt ContactPosL(TContactItemId aContactId);
	CArrayPtr<CContactItem>* ImportVCardsL(RReadStream& aReadStream,TBool& aImportSuccessful,TInt aOption,TBool aImportSingleContact);
	void ExportSelectedContactsAsVCardL(const CContactIdArray& aSelectedContactIds,RWriteStream& aWriteStream,TInt aOption);
	void SendEventToAllObservers(TContactDbObserverEventType aEventType);
	void SendEventToAllObservers(const TContactDbObserverEvent &aEvent);
	HBufC* GuidLC(const CContactItem& aContact,TBool& aCompressed);
// MContactDbPrivObserver
	void HandleDatabaseEventL(RDbNotifier::TEvent aEvent);
#if defined(_DEBUG)
	static void WriteLogToFileL();
	static void GetLogFileLC(RFs& aFs,RFile& aFile);
#endif
private:
	RDbNamedDatabase iDatabase;
	RDbs iDbsSession;
	CContactSrvSession *iContactSrvSession;
	CPrivateChangeNotifier* iChangeNotifier;
	CPrivateChangeEventNotifier *iChangeEventNotifier;
	TContactItemId iLastLockedContact;
	TContactItemId iTemplateId;
	CPrivItemTableColSet* iItemTable;
#ifdef CNTDB_GROUPS
	RDbTable iGroupTable;
#endif
	RDbTable iPrefTable;
	HBufC *iDateFormatText;
	CArrayFix<TSortPref>* iSortOrder;
	CArrayPtrFlat<MContactDbObserver> *iObservers;
	CContactTextDef* iTextDef;
	CContactIdArray* iSortedItems;
	CContactViewDef* iView;
	CContactItemViewDef* iAllFieldsView;
	TBuf<40> iUidString;
	CIdle *iIdleFinder;
	TBool iTablesOpen;
	CContactItem* iSystemTemplate;
	TInt iFileLayoutVersion;
	CCnaConverterList* iConvList;
	CPrivFindViewColSet* iFindView;
	TInt64 iMachineUniqueId;
	};

class CContactChangeNotifier : public CBase
	{
public:
	IMPORT_C ~CContactChangeNotifier();
	IMPORT_C static CContactChangeNotifier* NewL(CContactDatabase& aDatabase, MContactDbObserver *aObserver);
private:													
	CContactChangeNotifier(CContactDatabase& aDatabase, MContactDbObserver *aObserver);
	void ConstructL();
private:
	CContactDatabase &iDatabase;		
	MContactDbObserver* iObserver;
	};

inline TUid CContactItemViewDef::operator[](TInt aIndex) const
    { return iFieldTypes[aIndex]; }
inline TInt CContactItemViewDef::Count() const
    { return iFieldTypes.Count(); }
inline void CContactItemViewDef::Reset()
    { iFieldTypes.Reset(); }
inline CContactItemViewDef::TUse CContactItemViewDef::Use() const
	{ return iUse; }
inline void CContactItemViewDef::SetUse(CContactItemViewDef::TUse aUse)
	{ iUse=aUse; }
inline CContactItemViewDef::TMode CContactItemViewDef::Mode() const
	{ return iMode; }
inline void CContactItemViewDef::SetMode(CContactItemViewDef::TMode aMode)
	{ iMode=aMode; }

inline CContactDatabase::TSortPref::TSortPref()
	: iOrder(EAsc), iFieldType(KNullUid)
	{}
inline CContactDatabase::TSortPref::TSortPref(TFieldType aFieldType,TOrder aOrder)
	: iOrder(aOrder), iFieldType(aFieldType)
	{}

TInt CContactDatabase::CSortArray::Count() const
	{return(iArray.Count());}

#endif