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

#if !defined(__AGMXTAB_H__)
#define __AGMXTAB_H__

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

#if !defined(__AGMIDS_H__)
#include <agmids.h>
#endif
#if !defined(__AGMDATE_H__)
#include <agmdate.h>
#endif

#if !defined(__AGMXIDX_H__)
#include <AGMXIDX.h>
#endif
#if !defined(__AGMBASIC_H__)
#include <AGMBASIC.H>
#endif

#if !defined(__AGMXKEY_H__)
#include <AGMXKEY.H>
#endif

#if !defined(__AGMENTRY_H__)
#include <agmentry.h>
#endif


// -------------------------------- Local classes ------------------------------

class CAgnNonRpt1dayIndex;
class CAgnApptNonRptNdayIndex;
class CAgnRptIndex;
class CAgnTodoNonRptIndex;
class CAgnEventIndex;
class CAgnSortEntryTable;

// -------------------------------- Referenced classes--------------------------

class CAgnSortEntry;
class CAgnSortAppt;
class CAgnSortEvent;
class CAgnSortTodo;
class CAgnSortAnniv;
class TAgnKeyApptDate;
class TAgnKeyAlarm;
class TAgnKeyEntryInfo;
class CAgnEntry;
class CAgnAppt;
class CAgnTodo;
class CAgnAnniv;
class CAgnEvent;
class CAgnSortEntryAllocator;

// Index ids
#define KAgnEventIndexNum 0
#define KAgnApptNonRpt1DayIndexNum 1
#define KAgnApptNonRptNDayIndexNum 2
#define KAgnApptRptIndexNum 3
#define KAgnTodoNonRptIndexNum 4
#define KAgnAnnivRptIndexNum 5
#define KAgnTodoRptIndexNum 6



//-------------------------------- CAgnNonRpt1dayIndex -------------------------
//
//
class CAgnNonRpt1dayIndex : public CAgnSortEntryIndex 
	{
public:
	static CAgnNonRpt1dayIndex* NewL();
protected:
	CAgnNonRpt1dayIndex();
	virtual TBool IsValid(const CAgnSortEntry* aApptEntry) const;
	};

//-------------------------------- CAgnNdayIndex<Key> --------------------------
class CAgnNdayIndex : public CAgnSortEntryIndex
	{
public:
	virtual TBool First(TAgnDate& aKeyValue, TInt& aPos);
	virtual TBool Next(TAgnDate& aKeyValue, TInt& aPos) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	CAgnNdayIndex(TAgnKeyBase<CAgnSortEntry,TAgnDate>* aKey);
	TBool FirstValid(TAgnDate& aKeyValue, TInt& aPos) const;
	virtual TInt SetToStart(TAgnDate aKeyValue);
	};

//-------------------------------- CAgnApptNonRpt1dayIndex ---------------------
class CAgnApptNonRpt1dayIndex : public CAgnNonRpt1dayIndex
	{
public:
	CAgnApptNonRpt1dayIndex();
	static CAgnApptNonRpt1dayIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	};

//-------------------------------- CAgnApptNonRptNdayIndex ---------------------
//
class CAgnApptNonRptNdayIndex : public CAgnNdayIndex 
	{
public:
	CAgnApptNonRptNdayIndex();
	static CAgnApptNonRptNdayIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	virtual TInt SetToStart(TAgnDate aKeyValue);
	};

//-------------------------------- CAgnApptRptIndex ----------------------------
//
class CAgnApptRptIndex : public CAgnNdayIndex
	{
public:
	CAgnApptRptIndex();
	static CAgnApptRptIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	};

//-------------------------------- CAgnRptIndex --------------------------------
class CAgnRptIndex : public CAgnNdayIndex
	{
public:
	CAgnRptIndex();
	static CAgnRptIndex* NewL();
	virtual TBool IsValid(const CAgnSortEntry* aApptEntry) const;
protected:
	};


//-------------------------------- CAgnAnnivRptIndex ---------------------------
//
class CAgnAnnivRptIndex : public CAgnRptIndex
	{
public:
	CAgnAnnivRptIndex();
	static CAgnAnnivRptIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	};

//-------------------------------- CAgnEventIndex ------------------------------
//
class CAgnEventIndex : public CAgnNdayIndex
	{
public:
	CAgnEventIndex();
	static CAgnEventIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
	};


//-------------------------------- CAgnTodoNonRptIndex -------------------------
class CAgnTodoNonRptIndex : public CAgnSortEntryIndex
	{
public:
	static CAgnTodoNonRptIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	CAgnTodoNonRptIndex();
	};


//-------------------------------- CAgnTodoRptIndex-----------------------------
//
class CAgnTodoRptIndex : public CAgnRptIndex
	{
public:
	CAgnTodoRptIndex();
	static CAgnTodoRptIndex* NewL();
	virtual TBool Compare(const CAgnSortEntry* aInfo, const CAgnEntry* aEntry) const;
	virtual TBool IsValid(const CAgnSortEntry* aEntry) const;
protected:
	};

//-------------------------------- CAgnSortEntryTable --------------------------
class CAgnSortEntryTable : public CBase
	{
public:
	static CAgnSortEntryTable* NewL();
	~CAgnSortEntryTable();
	// called when entry is added/deleted/changed in entry store
	CAgnSortEntry* CreateSortEntryL(const CAgnEntry* aEntry);
	void EntryChangedL(const CAgnEntry* aEntry);
	void EntryChangedL(CAgnSortEntry* aSortEntry);
	void EntryDeletedL(TAgnEntryId aEntryId);
	CAgnSortEntry* EntryAddedL(const CAgnEntry* aEntry);
	//
	CAgnSortEntry* AddEntryL(const CAgnEntry* aEntry);				
	TBool DeleteEntryL(TAgnEntryId aId); 
	void Commit();
	void RollbackL();
	//
	void Reset();		// clear all entries from indices
	//
	IMPORT_C void FindMatchingEntriesL(const CAgnEntry* aEntry, CArrayFixFlat<TAgnEntryId>* aArray);
	//
	TBool HasChanged(const CAgnEntry* aEntry); // has entry changed w.r.t to index
	TInt EntryCount() const;

	TInt IndexCount(TInt aIndexNumber);

	CAgnSortEntry* GetEntry(TAgnEntryId aId);	// should be private ?
	TBool DeleteEntry(CAgnSortEntry* aSortEntry,TBool aRollback = EFalse);
	CAgnSortEntryAllocator* SortEntryAllocator();

protected:
	// constructor
	CAgnSortEntryTable();
	void ConstructL();

	void AddEntryL(CAgnSortEntry* aSortEntry);
	// Delete entry
	void DeleteEntryFromIndexes(const CAgnSortEntry* aEntry);
private:
//
	TBool Find(const TAgnEntryId& aId, TInt& aPos);
	TInt FindWithEntry(CAgnSortEntry* const aEntry);
//

	CArrayFixSeg<CAgnSortEntry*>* Array() { return iArray; } 
	CAgnIndex* Index(TInt aIndex) const;
	CAgnIndex* ApptNonRpt1dayIndex() const;
	CAgnIndex* ApptNonRptNdayIndex() const;
	CAgnIndex* ApptRptIndex() const;
	CAgnIndex* EventIndex() const;
	CAgnIndex* AnnivRptIndex() const;
	CAgnIndex* TodoNonRptIndex() const;
	CAgnIndex* TodoRptIndex() const;
	// friend classes for iterating through entries
	friend class TAgnApptRptIterator;
	friend class TAgnRptIterator;
	friend class TAgnEventIterator;
	friend class TAgnApptNonRpt1dayIterator;
	friend class TAgnApptNonRptNdayIterator;
	friend class TAgnTodoNonRptIterator;
	friend class TAgnTodoRptIterator;
	friend class TAgnAnnivNonRptIterator;
	friend class TAgnAnnivRptIterator;
	CArrayFixFlat<CAgnIndex*>* iIndexes;
	CArrayFixSeg<CAgnSortEntry*>* iArray; 
	CAgnSortEntry* iFindEntry;
	CAgnSortEntryAllocator* iSortEntryAllocator;
	CArrayPtrFlat<CAgnSortEntry>* iAddRollbackArray; 
	CArrayPtrFlat<CAgnSortEntry>* iDeleteRollbackArray; 
	};

#endif
// -------------------------------- EOF ----------------------------------------