// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
// DST TZ Database Compiler 
// 
//

#ifndef __TZTABLES_H_
#define __TZTABLES_H_

#include "PersistedEntityWrapper.h"
#include "..\..\tz\server\include\tzpersisted.h"
#include "TzNode.h"
#include "TzEntities.h"
#include <vector>
#include <string>
#include <fstream>
//============================================================================
// Forward Declarations
//============================================================================
class CTZDocument;
class CTzCpStdTimeAlignment;
class CTzCpLink;
class CTzCpString;
class CTzCpZone;
class CTzCpRegion;
class CTzCpRuleUse;
class CTzCpRuleSet;
class CTzCpRuleDefinition;

using namespace std;
//============================================================================
// Enumerations
//============================================================================
//Location of rule fields in olsen files
enum TzRuleFormat
	{
	ERuleFormatRule = 0,
	ERuleFormatName,
	ERuleFormatFrom,
	ERuleFormatTo,
	ERuleFormatType,
	ERuleFormatIn,
	ERuleFormatOn,
	ERuleFormatAt,
	ERuleFormatSave,
	ERuleFormatLetter
	};
//Location of zone fields in olsen files
enum TzZoneFormat
	{
	EZoneFormatZone = 0,
	EZoneFormatName,
	EZoneFormatGMTOffset,
	EZoneFormatRules,
	EZoneFormatFormat,
	EZoneFormatUntilYear,
	EZoneFormatUntilMonth,
	EZoneFormatUntilDay,
	EZoneFormatUntilMinutes
	};
//Location of link fields in olsen files
enum TzLinkFormat
	{
	ELinkFormatLink = 0,
	ELinkFormatToZone,
	ELinkFormatFromZone
	};

enum TzMonths
	{
	EJan = 0,
	EFeb,
	EMar,
	EApr,
	EMay,
	EJun,
	EJul,
	EAug,
	ESep,
	EOct,
	ENov,
	EDec
	};

enum TzDays
	{
	EMon = 0,
	ETue,
	EWed,
	EThu,
	EFri,
	ESat,	
	ESun
	};

//============================================================================
// CTzCpStdTimeAlignmentsTable Class Definition
// Responsible for managing, creating and externalising the collection of 
// STDTimeAlignments.
//============================================================================
class CTzCpStdTimeAlignmentsTable : public CPersistedEntityWrapper
	{
public:
	CTzCpStdTimeAlignmentsTable(CTZDocument& aDocument);
	void ExternaliseL(ofstream& aFilestream);
	CTzCpStdTimeAlignment& AddTimeAlignment(CTzCpString& aTimeZoneFormatName);

	std::vector<CTzCpStdTimeAlignment*>& TimeAlignments() { return iVector; } 
	void RemoveUnreferencedEntities();

private:
	//member data
	std::vector<CTzCpStdTimeAlignment*> iVector;
	};
//============================================================================
// CTzCpLinksTable Class Definition
//============================================================================
class CTzCpLinksTable : public CPersistedEntityWrapper
	{
public:
	CTzCpLinksTable(CTZDocument& aDocument);
	//From CPersistedEntityWrapper
	CTzCpLink& AssembleL(CTZNode& aNode);
	void ExternaliseL(ofstream& aFilestream);
	CTzCpZone* FindZone(std::string& aLinkName);
	std::vector<CTzCpLink*>& Links() { return iVector; } 

private:
	//member data
	TTzLinksTable iPersistedEntity;
	std::vector<CTzCpLink*> iVector;
	};
//============================================================================
// CTzCpStringTable Class Definition
// Responsible for managing, creating and externalising the collection of
// Time Zone Strings.  Strings must not be duplicated to conserve space.  This 
// is enforced by this class by returning an existing TZ String object when 
// required to create one for a value already in use.
//============================================================================
class CTzCpStringTable : public CPersistedEntityWrapper
	{
public:
	CTzCpStringTable(CTZDocument& aDocument);
	//From CPersistedEntityWrapper
	void ExternaliseL(ofstream& aFilestream);

	CTzCpString& AddString(std::string aString);
	std::vector<CTzCpString*>& Strings() { return iVector; }
	void RemoveUnreferencedEntities();

private:
	//member data
	std::vector<CTzCpString*> iVector;
	};
//============================================================================
// CTzCpRuleSetsTable Class Definition
// Responsible for managing, creating and externalising the collection of
// RuleSets. 
//============================================================================
class CTzCpRuleSetsTable : public CPersistedEntityWrapper
	{
public:
	CTzCpRuleSetsTable(CTZDocument& aDocument);
	//From CPersistedEntityWrapper
	CTzCpRuleSet&  AssembleL(CTZNode& aNode);
	void ExternaliseL(ofstream& aFilestream);
	
	CTzCpRuleSet* GetRuleSet(std::string aRuleSetName);
	int GetRuleSetIndex(std::string aRuleSetName);
	std::vector<CTzCpRuleSet*>& RuleSets() { return iVector; }
	void RemoveUnreferencedEntities();

private:
	//member data
	std::vector<CTzCpRuleSet*> iVector;
	};
//============================================================================
// CTzCpRuleUsesTable Class Definition
// Stores a list of ruleuses
//============================================================================
class CTzCpRuleUsesTable : public CPersistedEntityWrapper
	{
public:
	CTzCpRuleUsesTable(CTZDocument& aDocument);
	//From CPersistedEntityWrapper
	CTzCpRuleUse& AssembleL(CTZNode& aNode);
	void ExternaliseL(ofstream& aFilestream);

	CTzCpRuleUse& AddRuleUse(CTzCpRuleUse* aRuleUse);
	std::vector<CTzCpRuleUse*>& RuleUses() { return iVector; }
	void RemoveUnreferencedEntities();

private:
	//member data
	std::vector<CTzCpRuleUse*> iVector;
	};
//============================================================================
// CTzCpRuleDefinitionsTable Class Definition
// Responsible for managing, creating and externalising the collection of
// Rule Definitions. Rule Definitions must not be duplicated to conserve space
// This is enforced by this class returning an existing definition object
// when required to create one for a value already defined.
//============================================================================
class CTzCpRuleDefinitionsTable : public CPersistedEntityWrapper
	{
public:
	CTzCpRuleDefinitionsTable(CTZDocument& aDocument);
	//From CPersistedEntityWrapper
	CTzCpRuleDefinition& AssembleL(CTZNode& aNode);
	void ExternaliseL(ofstream& aFilestream);
	CTzCpRuleDefinition& AddRuleDefinition(CTzCpRuleDefinition* aRuleDefinition);
	std::vector<CTzCpRuleDefinition*>& RuleDefinitions() { return iVector; }
	void RemoveUnreferencedEntities();

private:
	//member data
	std::vector<CTzCpRuleDefinition*> iVector;
	};
//============================================================================
// CTzCpRegionsTable Class Definition
// Responsible for managing, creating and externalising the collection of
// Regions.  Each Region must have a unique name.  This is enforced by this 
// class returning an existing region when required to create a region for a 
// name already taken.
//============================================================================
class CTzCpRegionsTable : public CPersistedEntityWrapper
	{
public:
	CTzCpRegionsTable(CTZDocument& aDocument);
	void ExternaliseL(ofstream& aFilestream);
	
	CTzCpRegion& GetRegion(CTzCpString& aRegionRef);
	TTzRegionsTable iPersistedEntity;
	void RemoveUnreferencedEntities();
	std::vector<CTzCpRegion*>& Regions() { return iVector; }	

private:
	//member data
	std::vector<CTzCpRegion*> iVector;
	};
//============================================================================
// CTZCpZonesTable Class Definition
// Responsible for managing, creating and externalising the collection of
// Zones.  This is enforced by this class returning an existing Zone when 
// required to create a Zone for a name already taken.
//============================================================================
class CTzCpZonesTable : public CPersistedEntityWrapper
	{
public:
	CTzCpZonesTable(CTZDocument& aDocument);
	CTzCpZone* GetZone(CTzCpString& aZoneRef, CTzCpString& aRegionRef,bool addNew);
	CTzCpZone* CTzCpZonesTable::GetZone(std::string& aZoneName);
	void ExternaliseL(ofstream& aFilestream); // //From CPersistedEntityWrapper
	std::vector<CTzCpZone*>& Zones() { return iVector; }
	void RemoveUnreferencedEntities();

private:
	std::vector<CTzCpZone*> iVector;
	TTzZonesTable iPersistedEntity;
	int iNumberOfZones;
	};
#endif //__TZTABLES_H
//============================================================================
// End of file
//============================================================================