// Copyright (c) 1997-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:

//

#include "agsstreamidset.h"

#include "agsentrymodel.h"

#include "agsfileconverter.h"

#include "agmpanic.h"

#include <s32stor.h>

CAgnStreamIdSet* CAgnStreamIdSet::NewL()

//

// Create a CAgnStreamIdSet

//

	{

	CAgnStreamIdSet* Self = new(ELeave) CAgnStreamIdSet;

	CleanupStack::PushL(Self);

	Self->iArray = new(ELeave) CArrayFixFlat<TStreamId>(EGranularity);

	Self->iAddRollbackArray = new(ELeave) CArrayFixFlat<TStreamId>(ERollbackGranularity);

	Self->iDeleteRollbackArray = new(ELeave) CArrayFixFlat<TStreamId>(ERollbackGranularity);

	CleanupStack::Pop();

	return (Self);

	}

CAgnStreamIdSet::~CAgnStreamIdSet()

//

// Destructor

//

	{

	delete iArray;

	delete iAddRollbackArray;

	delete iDeleteRollbackArray;

	}

TStreamId CAgnStreamIdSet::CreateL(CStreamStore& aStore)

//

// Create a new stream for the set 

//

	{

	iStreamId = aStore.ExtendL();

	return (iStreamId);

	}

void CAgnStreamIdSet::AddL(TStreamId aId)

//

// Add aId to the set

//

	{

	iArray->AppendL(aId);

	TRAPD(ret,iAddRollbackArray->AppendL(aId));

	if (ret != KErrNone)

		{

		TInt pos;

		if (Find(aId,pos)==0)

			iArray->Delete(pos);

		User::Leave(ret);

		}

	// Don't save this until Commit is called

	}

void CAgnStreamIdSet::DeleteL(TStreamId aId)

//

// Delete aId from the set

//

	{

	TInt pos;

	if (Find(aId,pos)==0) //Find returns 0 if found,+ve if not found,-ve if empty array

		{

		iDeleteRollbackArray->AppendL(aId);

		iArray->Delete(pos);

		}

	// Don't save this until Commit is called

	}

void CAgnStreamIdSet::SaveL(CStreamStore& aStore) const

//

// Save the set

//

	{

	RStoreWriteStream stream;

	stream.ReplaceLC(aStore,iStreamId);

	stream << *iArray;

	stream.CommitL();

	CleanupStack::PopAndDestroy();

	}

void CAgnStreamIdSet::LoadL(CStreamStore& aStore,TStreamId aStreamId)

//

// Restore the token set identified by aStreamId from within aStore

//

	{

	iStreamId = aStreamId;

	iArray->Reset();

	RStoreReadStream in;

	in.OpenLC(aStore,iStreamId);

	in >> *iArray;

	CleanupStack::PopAndDestroy();

	}

void CAgnStreamIdSet::CommitL(CStreamStore& aStore)

//

// Commit changes to the in memory array and the file

//

	{

	iAddRollbackArray->Reset();

	iDeleteRollbackArray->Reset();

	iArray->Compress();

	SaveL(aStore);

	}

void CAgnStreamIdSet::RollbackL()

//

// Rollback changes made:- delete all added entries and reinstate all deleted entries

//

	{

	// remove all newly added entry stream ids

	for (TInt ii = iAddRollbackArray->Count()-1;ii >= 0;--ii)

		{

		TInt pos;

		TInt found = Find((*iAddRollbackArray)[ii],pos);		

		if (found==0) //Find returns 0 if found,+ve if not found,-ve if empty array	

			iArray->Delete(pos);

		__ASSERT_DEBUG(found==0,Panic(EAgmErrCouldNotFindNewEntryId));

		}

	iAddRollbackArray->Reset();	

	// re-add all deleted entries

	for (TInt jj = iDeleteRollbackArray->Count()-1;jj >= 0;--jj)

		iArray->AppendL((*iDeleteRollbackArray)[jj]);

	iDeleteRollbackArray->Reset();

	}

void CAgnStreamIdSet::ResetIteratorToStart()

/**

If there are items in the set then the iterator postion is set to the first item and

ETrue is returned otherwise EFalse is returned

@internalAll

*/

	{

	if (iArray->Count())

		{

		iPos=0;

		}

	}

TBool CAgnStreamIdSet::Next()

/**

If there is a next item in the set then the iterator is positioned to it and ETrue is

returned otherwise EFalse is returned.

@internalAll

*/

	{

	if (iPos + 1 < iArray->Count())

		{

		++iPos;

		return (ETrue);

		}

	return (EFalse);

	}

TBool CAgnStreamIdSet::At(TStreamId& aItem)	const

/**

If there are items in the set then the item at the current position of the iterator is

placed in aItem and ETrue is returned otherwise EFalse is returned.

@internalAll

*/

	{

	if (iArray->Count())

		{

		if (iPos < iArray->Count())

			{

			aItem = (*iArray)[iPos];

			return (ETrue);

			}

		}

	return (EFalse);

	}

TInt CAgnStreamIdSet::Find(TStreamId aItem,TInt& aPos) const

//

// Returns 0 is aItem is found and sets aPos to its position, otherwise returns +ve if not

// found and -ve if the set is empty

//

	{

	TKeyArrayFix key(0,ECmpNormal8,sizeof(TStreamId));

	return (iArray->Find(aItem,key,aPos)); 	

	}

void CAgnStreamIdSet::Reset()

//

// Clear out all data

//

	{

	iArray->Reset();

	iAddRollbackArray->Reset();

	iDeleteRollbackArray->Reset();

	}

//

//                   CAgnModelStreamIdSet       

//

CAgnModelStreamIdSet* CAgnModelStreamIdSet::NewL()

//

// Create a CAgnModelStreamIdSet object

//

	{

	CAgnModelStreamIdSet* Self=new(ELeave) CAgnModelStreamIdSet;

	CleanupStack::PushL(Self);

	Self->ConstructL();

	CleanupStack::Pop();

	return (Self);

	}

void CAgnModelStreamIdSet::ConstructL()

//

// Constructs a CAgnModelStreamIdSet

//

	{

	iEntryStreamIdSet = CAgnStreamIdSet::NewL(); 

	}

CAgnModelStreamIdSet::~CAgnModelStreamIdSet()

//

// Destructor

//

	{

	delete iEntryStreamIdSet;

	}

TStreamId CAgnModelStreamIdSet::CreateL(CStreamStore& aStore,const TAgnVersion& aVersion) 

//

// Creates a network of streams in aStore, their stream id's being saved in a head

// stream and the id of this stream is returned. aVersion is the version of the model that is being used

// to create the file.

//

	{

	iVersion = aVersion;

	// create a	stream for the entry stream id set

	iEntrySetStreamId = iEntryStreamIdSet->CreateL(aStore);

	iEntryStreamIdSet->SaveL(aStore);

	// create  a stream for the unique identifier value

	iNextLocalUidValueStreamId = aStore.ExtendL();

	// create a stream to hold the entry store object's data

	iEntryManagerStreamId = aStore.ExtendL();

	// create a stream to hold information about the file (file id)

	iFileInformationStreamId = aStore.ExtendL();

	// Save the id's of the streams created to a head stream and return its stream id

	RStoreWriteStream stream;

	TStreamId headStreamId = stream.CreateLC(aStore);

	stream << *this;

	stream.CommitL();

	CleanupStack::PopAndDestroy();

	return (headStreamId);

	}

void CAgnModelStreamIdSet::InternalizeL(RReadStream& aStream)

	{

	aStream >> iVersion;

	aStream >> iEntrySetStreamId;

	aStream >> iNextLocalUidValueStreamId;

	aStream >> iEntryManagerStreamId;

	aStream >> iFileInformationStreamId;

	}

void CAgnModelStreamIdSet::ExternalizeL(RWriteStream& aStream) const

	{

	TStreamId dcStreams(0);

	aStream << iVersion;

	aStream << iEntrySetStreamId;

	aStream << iNextLocalUidValueStreamId;

	aStream << iEntryManagerStreamId;

	aStream << iFileInformationStreamId;

	}

void CAgnModelStreamIdSet::LoadL(CStreamStore& aStore, TStreamId aStreamId)

	{

	RStoreReadStream in;

	in.OpenLC(aStore,aStreamId);

	in >> *this;

	CleanupStack::PopAndDestroy();

	iEntryStreamIdSet->LoadL(aStore,iEntrySetStreamId);

	}

void CAgnModelStreamIdSet::LoadL(CStreamStore& aStore, TStreamId aStreamId, CAgnCalendarConverter& aCalendarConverter)

	{

	RStoreReadStream in;

	in.OpenLC(aStore,aStreamId);

	// If a calendar converter was supplied, use it 

	// for internalizing this:

	aCalendarConverter.InternalizeModelStreamIdSetL(in, *this);

	CleanupStack::PopAndDestroy();

	iEntryStreamIdSet->LoadL(aStore,iEntrySetStreamId);

	}

void CAgnModelStreamIdSet::RollbackL()

	{

	iEntryStreamIdSet->RollbackL();

	}

void CAgnModelStreamIdSet::CommitL(CStreamStore& aStore)

	{

	iEntryStreamIdSet->CommitL(aStore);

	}

void CAgnModelStreamIdSet::Reset()

//

// Clear out all data

//

	{

	EntryStreamIdSet().Reset();

	iEntrySetStreamId = KNullStreamId;

	iNextLocalUidValueStreamId = KNullStreamId;

	iFileInformationStreamId = KNullStreamId;

	}

void CAgnModelStreamIdSet::ChangeFileVersionL(CStreamStore& aStore,TStreamId aStreamId, TAgnVersion& aNewVersion)

//

// Change the file version.

//

	{

	iVersion = aNewVersion;

	RStoreWriteStream out;

	out.OpenLC(aStore,aStreamId);

	out << *this;

	out.CommitL();

	CleanupStack::PopAndDestroy();

	}