diff -r 000000000000 -r 2e3d3ce01487 tzservices/tzserver/Server/Include/tzdbentities.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/tzservices/tzserver/Server/Include/tzdbentities.h Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,349 @@ +// 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: +// + +#ifndef __TZDBENTITIES_H__ +#define __TZDBENTITIES_H__ + +#include +#include + +#include "tzpersisted.h" + +class CReadOnlyTzDb; +class CTzDbRegion; +class CTzDbZone; +class CTzDbStdTimeAlignment; +class CTzDbRuleSet; +class CTzRules; +class CVTzActualisedRules; +class TVTzActualisedRule; + +/******************************************************************************************/ + +/** CTzDbStringsTable +Encapsulates and provides access to the strings table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbStringsTable : public CBase + { +public: + static CTzDbStringsTable* NewL(const TTzStringsTable& aStringsTable); + TPtrC8 GetStringL(TUint aReference); + +private: + CTzDbStringsTable(const TTzStringsTable& aStringsTable); + +private: + const TTzStringsTable& iPersistedEntity; + }; + +/** CTzDbRegionsTable +Encapsulates and provides access to the regions table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbRegionsTable : public CBase + { +public: + static CTzDbRegionsTable* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionsTable& aRegionsTable); + + CTzDbRegion* FindRegionL(const TDesC8& aRegionName); + +private: + CTzDbRegionsTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionsTable& aRegionsTable); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzRegionsTable& iPersistedEntity; + }; + +/** CTzDbRegionalZonesTable +Encapsulates and provides access to the regional zones table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbRegionalZonesTable : public CBase + { +public: + static CTzDbRegionalZonesTable* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegionalZonesTable& aRegionalZonesTable); + + const TTzRegionalZoneIndex& GetTRegionalZoneIndex(TUint aReference); + +private: + CTzDbRegionalZonesTable(CReadOnlyTzDb& aReadOnlyTzDbr, const TTzRegionalZonesTable& aRegionalZonesTable); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzRegionalZonesTable& iPersistedEntity; + }; + +/** CTzDbZonesTable +Encapsulates and provides access to the zones table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbZonesTable : public CBase + { +public: + static CTzDbZonesTable* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZonesTable& aZonesTable, TInt aZonesDataBaseAddress); + + CTzDbZone* GetZoneL(TUint aReference); + TTzZone& GetTZone(TUint aReference); + CTzDbZone* GetZoneByIdL(TUint aLocationId); + +private: + CTzDbZonesTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZonesTable& aZonesTable, TInt aZonesDataBaseAddress); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzZonesTable& iPersistedEntity; + TInt iZonesDataBaseAddress; + }; + +/** CTzDbLinksTable +Encapsulates and provides access to the links table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbLinksTable : public CBase + { +public: + static CTzDbLinksTable* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzLinksTable& aLinksTable); + + CTzDbZone* FindZoneL(const TDesC8& aLinkName); + +private: + CTzDbLinksTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzLinksTable& aLinksTable); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzLinksTable& iPersistedEntity; + }; + +/** CTzDbStdTimeAlignmentsTable +Encapsulates and provides access to the std time alignments table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbStdTimeAlignmentsTable : public CBase + { +public: + static CTzDbStdTimeAlignmentsTable* NewL(const TTzStdTimeAlignmentsTable& aStdTimeAlignmentsTable); + TTzStdTimeAlignment& GetTStdTimeAlignment(TUint aReference); + +private: + CTzDbStdTimeAlignmentsTable(const TTzStdTimeAlignmentsTable& aStdTimeAlignmentsTable); + +private: + const TTzStdTimeAlignmentsTable& iPersistedEntity; + }; + +/** CTzDbRuleSetsTable +Encapsulates and provides access to the rulesets table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbRuleSetsTable : public CBase + { +public: + static CTzDbRuleSetsTable* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSetsTable& aRuleSetsTable); + CTzDbRuleSet* GetRuleSetL(TUint aReference); + +private: + CTzDbRuleSetsTable(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSetsTable& aRuleSetsTable); + TTzRuleSet& GetTRuleSet(TUint aReference); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzRuleSetsTable& iPersistedEntity; + }; + +/** CTzDbRuleUsesTable +Encapsulates and provides access to the rule uses table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbRuleUsesTable : public CBase + { +public: + static CTzDbRuleUsesTable* NewL(const TTzRuleUsesTable& aRuleUsesTable); + TTzRuleUse& GetTRuleUse(TUint aReference); + +private: + CTzDbRuleUsesTable(const TTzRuleUsesTable& aRuleUsesTable); + +private: + const TTzRuleUsesTable& iPersistedEntity; + }; + +/** CTzDbRuleDefinitionsTable +Encapsulates and provides access to the rule definitions table contained in the database. + +@internalComponent +@since 9.1 +*/ +class CTzDbRuleDefinitionsTable : public CBase + { +public: + static CTzDbRuleDefinitionsTable* NewL(const TTzRuleDefinitionsTable& aRuleDefinitionsTable); + const TTzRuleDefinition& GetRuleDefinition(TUint aReference); + +private: + CTzDbRuleDefinitionsTable(const TTzRuleDefinitionsTable& aRuleDefinitionsTable); + +private: + const TTzRuleDefinitionsTable& iPersistedEntity; + }; + + +/** CTzDbRegion +Encapsulates and provides access to the information that the database holds about a region + +@internalComponent +@since 9.1 +*/ +class CTzDbRegion : public CBase + { +public: + static CTzDbRegion* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegion& aRegion); + CTzDbZone* FindZoneL(const TDesC8& aCityName); + CTzDbZone* FindZoneL(TUint aCityNameReference); + +private: + CTzDbRegion(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRegion& aRegion); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzRegion& iPersistedEntity; + }; + +/** CTzDbZone +Encapsulates and provides access to the information that the database holds about a zone + +@internalComponent +@since 9.1 +*/ +class CTzDbZone : public CBase + { +public: + static CTzDbZone* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZone& aZone); + void GetRulesL(CTzRules& aRules); + CTzDbStdTimeAlignment* FindStdTimeAlignmentL(TInt aYear, TInt aMonth, TInt aDay, TInt aHour, TInt aMinute, TTzTimeReference aTimeRef); + inline TUint LocationId() const; + HBufC8* GetFullZoneNameLC(); + +private: + CTzDbZone(CReadOnlyTzDb& aReadOnlyTzDb, const TTzZone& aZone); + TBool IsTimeInStdTimeAlignment(const TTzStdTimeAlignment& aStdTa, TInt aYear, TInt aMonth, TInt aDay, TInt aHour, TInt aMinute, TTzTimeReference aTimeRef); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzZone& iPersistedEntity; + }; + + +/** CTzDbStdTimeAlignment +Encapsulates and provides access to the information that the database holds about a std time alignment + +@internalComponent +@since 9.1 +*/ +class CTzDbStdTimeAlignment : public CBase + { +public: + static CTzDbStdTimeAlignment* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzStdTimeAlignment& aTimeAlignment, + TTzStdTimeAlignment* aPrevTimeAlignment); + + ~CTzDbStdTimeAlignment(); + void GetRulesL(CTzRules& aRules, const TDateTime& aStartDateTime, TDateTime& aEndDateTime); + + TInt UtcOffset(); + TUint RuleSetReference(); + TInt UntilYear(); + TInt UntilMonth(); + TInt UntilDay(); + TInt UntilTimeInMinutes(); + TInt UntilTimeReference(); + +private: + CTzDbStdTimeAlignment(CReadOnlyTzDb& aReadOnlyTzDb, const TTzStdTimeAlignment& aTimeAlignment, + TTzStdTimeAlignment* aPrevTimeAlignment); + + void AddRulesToCollectionL(CTzRules& aRuleCollection, CTzRules& aNewRules); + + void CalculateEndTime(TTime& aEndTime); + void CalculateStartTime(TTime& aStartTime); + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + TTzStdTimeAlignment iPersistedEntity; + TTzStdTimeAlignment* iPrevTimeAlignment; + }; + + + +/** CTzDbRuleSet +Encapsulates and provides access to the information that the database holds about a rule set + +@internalComponent +@since 9.1 +*/ +class CTzDbRuleSet : public CBase + { +public: + static CTzDbRuleSet* NewL(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSet& aRuleSet); + void GetRulesL(CTzRules& aTzRules, TInt aUtcOffset, const TDateTime& aStartDateTime, const TDateTime& aEndDateTime) const; + void FetchRuleDefinitionsL(RArray& aTzRuleDefinitions, RArray& aTzRuleUses, TInt aStartYear, TInt aEndYear) const; + void ActualiseRuleDefinitionsL(CVTzActualisedRules& aActualisedRules, const RArray& aTzRuleDefinitions, const RArray& aTzRuleUses, TInt aUtcOffset, const TDateTime& aStartDateTime, const TDateTime& aEndDateTime, const TVTzActualisedRule& aDefaultRule) const; + +private: + CTzDbRuleSet(CReadOnlyTzDb& aReadOnlyTzDb, const TTzRuleSet& aRuleSet); + void CompleteRulesAndAddToCollectionL(CTzRules& aTzRules, + const RArray& aRuleDefs, const RArray& aRuleUses, + TInt aUtcOffset, TInt aInitialLocalTimeOffset, + TDateTime aStartYear, TDateTime aEndYear) const; + + TInt GetLocalTimeOffsetAtEndOfYearL(TInt aYear, TInt aUtcOffset) const; + +private: + CReadOnlyTzDb& iReadOnlyTzDb; + const TTzRuleSet& iPersistedEntity; + }; + +class CTzHelpers + { +public: + static TInt Validate(const TTzRuleDefinition& aRuleDefinition); + }; + +inline TUint CTzDbZone::LocationId() const + { + return iPersistedEntity.iLocationId; + } + + +#endif // __TZDBENTITIES_H__ + + +