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

// System includes

// User includes
#include "ASSrvAlarmQueue.h"

// Type definitions

// Constants
const TInt KInitialIndexValue = -1;

// Enumerations

// Classes referenced


//
// ----> RASSrvIteratorBase (source)
//

//*************************************************************************************
RASSrvIteratorBase::RASSrvIteratorBase(CASSrvAlarmQueue& aQueue)
:	iQueue(aQueue), iCurrentIndex(KInitialIndexValue), iType(EASSrvIteratorTypeSecondary), iAttachedIterator(NULL)
	{
	}


//*************************************************************************************
/**
 * Only the primary iterator should ever be opened.
 */
void RASSrvIteratorBase::Open()
	{
	iType = EASSrvIteratorTypePrimary;

	// Restore back to default state
	Reset();
	}


//
//
//


//*************************************************************************************
/**
 * Is another alarm available?
 */
TBool RASSrvIteratorBase::NextAlarmAvailable() const
	{
	RASSrvIteratorBase& self = const_cast<RASSrvIteratorBase&>(*this);
	const TInt count = AlarmCount();
	TInt index = iCurrentIndex;
	//
	while(++index < count)
		{
		const TASSrvAlarm& alarm = self.AlarmAt(index);
		if	(Matches(alarm))
			return ETrue;
		}
	return EFalse;
	}


//*************************************************************************************
/**
 * Return the next available alarm
 */
TASSrvAlarm& RASSrvIteratorBase::NextAlarm()
	{
	const TInt count = AlarmCount();
	while (++iCurrentIndex < count)
	{
		TASSrvAlarm& alarm = AlarmAt(iCurrentIndex);
		if	(Matches(alarm))
			{
			IteratorSynchronize(*this);
			return alarm;
			}
		}
	
	// Panic because there isn't another available alarm.
	Panic(EASSrvIteratorPanicNoNextAlarmForIterator);
	TASSrvAlarm* dummy = NULL;
	return *dummy;
	}


//*************************************************************************************
/**
 * Resets the iterator back to the start of the queue
 */
void RASSrvIteratorBase::Reset()
	{
	iCurrentIndex = KInitialIndexValue;
	IteratorSynchronize(*this);
	}


//*************************************************************************************
/**
 * Attaches another iterator to this one. Allows iterators to be chained
 * together so that different conditions can be satisfied without complex
 * (custom-written) individual iterator combinations.
 */
void RASSrvIteratorBase::IteratorAttach(RASSrvIteratorBase& aIterator)
	{
	__ASSERT_ALWAYS(&aIterator != this, Panic(EASSrvIteratorPanicCyclicAttach));
	iAttachedIterator = &aIterator;
	}


//*************************************************************************************
/**
 * Release a previously attached iterator
 */
void RASSrvIteratorBase::IteratorRelease()
	{
	iAttachedIterator = NULL;
	}


//
//
//


//*************************************************************************************
/**
 * Is an iterator attached?
 */
TBool RASSrvIteratorBase::IteratorAttached() const
	{
	return (iAttachedIterator != NULL);
	}


//*************************************************************************************
/**
 * Access the attached iterator
 */
RASSrvIteratorBase& RASSrvIteratorBase::Iterator()
	{
	__ASSERT_ALWAYS(IteratorAttached(), Panic(EASSrvIteratorPanicNoneAttached));
	return *iAttachedIterator;
	}


//*************************************************************************************
/**
 * Access a constant handle to the attached iterator
 */
const RASSrvIteratorBase& RASSrvIteratorBase::Iterator() const
	{
	__ASSERT_ALWAYS(IteratorAttached(), Panic(EASSrvIteratorPanicNoneAttached));
	return *iAttachedIterator;
	}


//*************************************************************************************
/**
 * Synchronise this iterator with another
 */
void RASSrvIteratorBase::IteratorSynchronize(RASSrvIteratorBase& aInterator)
	{
	iCurrentIndex = aInterator.iCurrentIndex;
	if	(IteratorAttached())
		Iterator().IteratorSynchronize(*this);
	}


//*************************************************************************************
/**
 * Does the specified alarm satisfy the criteria associated with
 * this iterator?
 */
TBool RASSrvIteratorBase::Matches(const TASSrvAlarm& aAlarm) const
	{
	// If we have an attached iterator, then we should
	// check with that too.
	TBool matches = ETrue;
	//
	if	(IteratorAttached())
		matches = Iterator().Matches(aAlarm);
	//
	return matches;
	}


//*************************************************************************************
/**
 * Return a reference to the alarm at the specified index
 */
TASSrvAlarm& RASSrvIteratorBase::AlarmAt(TInt aIndex)
	{
	__ASSERT_ALWAYS(iType == EASSrvIteratorTypePrimary, Panic(EASSrvIteratorPanicTypeMismatch));
	return iQueue.QueueAlarmAt(aIndex);
	}


//*************************************************************************************
/**
 * Return the number of alarms
 */
TInt RASSrvIteratorBase::AlarmCount() const
	{
	__ASSERT_ALWAYS(iType == EASSrvIteratorTypePrimary, Panic(EASSrvIteratorPanicTypeMismatch));
	return iQueue.QueueAlarmCount();
	}


//
//
//


//*************************************************************************************
/**
 * Panic the Alarm Server
 */
void RASSrvIteratorBase::Panic(TASSrvIteratorPanic aPanic)
	{
	_LIT(KPanicCategory, "ASSrvIterator");
	User::Panic(KPanicCategory, aPanic);
	}