// Copyright (c) 2002-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 "LogChangeDefinition.h"

// User includes
#include "logclipanic.h"


/////////////////////////////////////////////////////////////////////////////////////////
// -----> CLogChangeDefinition (source)
/////////////////////////////////////////////////////////////////////////////////////////

CLogChangeDefinition::CLogChangeDefinition(TInt aGranularity)
:	iChanges(aGranularity)
	{
	}

EXPORT_C CLogChangeDefinition::~CLogChangeDefinition()
	{
	iChanges.Close();
	}

void CLogChangeDefinition::ConstructL(const CLogChangeDefinition& aCopy)
	{
	const TInt count = aCopy.Count();
	for(TInt i=0; i<count; i++)
		{
		const TLogShdChangeDetails& item = aCopy.iChanges[i];
		User::LeaveIfError(iChanges.Append(item));
		}
	}

EXPORT_C CLogChangeDefinition* CLogChangeDefinition::NewL(TInt aGranularity)
	{
	CLogChangeDefinition* self = new(ELeave) CLogChangeDefinition(aGranularity);
	return self;
	}

EXPORT_C CLogChangeDefinition* CLogChangeDefinition::NewL(const CLogChangeDefinition& aCopy)
	{
	const TInt count = Max(1, aCopy.Count());
	CLogChangeDefinition* self = new(ELeave) CLogChangeDefinition(count);
	CleanupStack::PushL(self);
	self->ConstructL(aCopy);
	CleanupStack::Pop(self);
	return self;
	}

EXPORT_C CLogChangeDefinition* CLogChangeDefinition::NewL(RReadStream& aStream)
	{
	CLogChangeDefinition* self = new(ELeave) CLogChangeDefinition(KLogChangeDefinitionDefaultGranularity);
	CleanupStack::PushL(self);
	aStream >> *self;
	CleanupStack::Pop(self);
	return self;
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C TInt CLogChangeDefinition::Count() const
	{
	return iChanges.Count();
	}

EXPORT_C TLogDatabaseChangeType CLogChangeDefinition::At(TInt aIndex) const
	{
	const TLogShdChangeDetails& entry = iChanges[aIndex];
	return entry.iType;
	}

EXPORT_C TLogDatabaseChangeType CLogChangeDefinition::At(TInt aIndex, TLogId& aId) const
	{
	const TLogShdChangeDetails& entry = iChanges[aIndex];
	aId = entry.iId;
	return entry.iType;
	}

EXPORT_C TLogDatabaseChangeType CLogChangeDefinition::At(TInt aIndex, TLogId& aId, TInt& aViewIndex) const
	{
	const TLogShdChangeDetails& entry = iChanges[aIndex];
	aId = entry.iId;
	aViewIndex = entry.iViewIndex;
	return entry.iType;
	}

EXPORT_C TInt CLogChangeDefinition::Find(TLogId aId) const
	{
	// Linear search
	const TLogShdChangeDetails entryToFind(aId);
	TIdentityRelation<TLogShdChangeDetails> relation(CompareEntryIds);
	const TInt position = iChanges.Find(entryToFind, relation);
	return position;
	}

EXPORT_C TInt CLogChangeDefinition::Find(TLogId aId, TLogDatabaseChangeType aType) const
	{
	// First try and find any log id regardless of change type
	TInt position = Find(aId);
	if	(position >= 0)
		{
		const TInt count = iChanges.Count();

		// Keep iterating through the changes until we 
		//
		// a) Reach the end of the changes OR
		// b) Reach a change corresponding to a different log id OR
		// c) Find the change we're interested in
		TInt i = position;
		position = KErrNotFound;
		//
		for(; i<count; i++)
			{
			const TLogShdChangeDetails& entry = iChanges[i];
			if	(entry.iId == aId)
				{
				// Now check the change type
				if	(entry.iType == aType)
					{
					// (c)
					position = i;
					break;
					}
				}
			else
				{
				// (b)
				break;
				}
			}
		// (a) is implicit
		}
	return position;
	}

EXPORT_C TInt CLogChangeDefinition::FindByViewIndex(TInt aViewIndex) const
	{
	// Cannot use binary search
	const TLogShdChangeDetails entryToFind(KLogNullId, ELogChangeTypeUndefined, aViewIndex);
	TIdentityRelation<TLogShdChangeDetails> relation(CompareViewIndicies);
	const TInt position = iChanges.Find(entryToFind, relation);
	return position;
	}

EXPORT_C void CLogChangeDefinition::AddL(TLogId aId, TLogDatabaseChangeType aType, TInt aViewIndex)
	{
	switch(aType)
		{
	case ELogChangeTypeEventChanged:
	case ELogChangeTypeEventChangedHidden:
	case ELogChangeTypeEventAdded:
	case ELogChangeTypeEventDeleted:
	case ELogChangeTypeLogCleared:
		AddToContainerL(aId, aType, aViewIndex);
		break;
	//
	default:
	case ELogChangeTypeUndefined:
		__ASSERT_ALWAYS(0, Panic(ELogUndefinedChangeType));
		break;
		}
	}

EXPORT_C void CLogChangeDefinition::Reset()
	{
	iChanges.Reset();
	iChanges.GranularCompress();
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

EXPORT_C void CLogChangeDefinition::InternalizeL(RReadStream& aStream)
	{
	TLogShdChangeDetails entry;
	//
	TCardinality count;
	aStream >> count;
	//
	for(TInt i=0; i<count; i++)
		{
		entry.iId = static_cast<TLogId>(aStream.ReadInt32L());
		entry.iType = static_cast<TLogDatabaseChangeType>(aStream.ReadUint8L());
		entry.iViewIndex = static_cast<TInt>(aStream.ReadInt32L());
		//
		User::LeaveIfError(iChanges.Append(entry));
		}
	}

EXPORT_C void CLogChangeDefinition::ExternalizeL(RWriteStream& aStream) const
	{
	TCardinality count = Count();
	aStream << count;
	//
	for(TInt i=0; i<count; i++)
		{
		const TLogShdChangeDetails& entry = iChanges[i];
		//
		aStream.WriteInt32L(entry.iId);
		aStream.WriteUint8L(entry.iType);
		aStream.WriteInt32L(entry.iViewIndex);
		}
	}

/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////////////

TBool CLogChangeDefinition::CompareEntryIds(const TLogShdChangeDetails& aLeft, const TLogShdChangeDetails& aRight)
	{
	return (aLeft.iId == aRight.iId);
	}

TBool CLogChangeDefinition::CompareViewIndicies(const TLogShdChangeDetails& aLeft, const TLogShdChangeDetails& aRight)
	{
	return (aLeft.iViewIndex == aRight.iViewIndex);
	}

void CLogChangeDefinition::AddToContainerL(TLogId aId, TLogDatabaseChangeType aType, TInt aViewIndex)
	{
	const TLogShdChangeDetails entry(aId, aType, aViewIndex);
	const TInt error = iChanges.Append(entry);
	User::LeaveIfError(error);
	}