/*
* Copyright (c) 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 "transition.h"
#include <openmax/il/khronos/v1_x/OMX_Component.h>

void CloseSupplierRelations(TAny* aPtr)
	{
	RSupplierRelations& links = *reinterpret_cast<RSupplierRelations*>(aPtr);
	for(TInt i = 0, count = links.Count(); i < count; i++)
		{
		links[i].Close();
		}
	links.Close();
	}

/**
 * Finds a transition order in which no component is transitioned until all components it suppliers to have been transitioned.
 * If no such order exists (this happens if and only if a cyclic buffer supply chain exists in the graph), this method leaves
 * with KErrNotFound.
 *
 * The result of this algorithm is appropriate for transitioning components from the Loaded state to the Idle state without incurring
 * errors calling OMX_UseBuffer. For transitions Executing->Idle and Executing->Paused, the reverse order can be used.
 *
 * @leave KErrNoMemory
 * @leave KErrNotFound iff a transition order for the graph does not exist
 * @leave KErrArgument if aOrder passed in is not empty
 */
void FindTransitionOrderL(const RSupplierRelations& aSupplierRelations, RArray<TInt>& aOrder)
	{
	if(aOrder.Count() > 0)
		{
		User::Leave(KErrArgument);
		}
	
	TInt numComponents = aSupplierRelations.Count();
	TInt numPendingComponents = numComponents;
	RArray<TBool> pendingComponents;
	CleanupClosePushL(pendingComponents);
	for(TInt i = 0; i < numComponents; i++)
		{
		pendingComponents.AppendL(ETrue);
		}

	while(numPendingComponents > 0)
		{
		TInt nextComponent = KErrNotFound;
		for(TInt i = 0; i < numComponents && nextComponent == KErrNotFound; i++)
			{
			// try each component not yet transitioned
			if(pendingComponents[i])
				{
				// have all this component's non-supplier peers been transitioned?
				nextComponent = i;
				for(TInt j = 0, numSupplied = aSupplierRelations[i].Count(); j < numSupplied && nextComponent != KErrNotFound; j++)
					{
					if(pendingComponents[aSupplierRelations[i][j]])
						{
						// no, this component can't transition yet
						nextComponent = KErrNotFound;
						}
					}
				}
			}
		// couldn't find a component to transition? so no solution
		if(nextComponent == KErrNotFound)
			{
			aOrder.Reset();
			User::Leave(KErrNotFound);
			}

		// this component can transition
		aOrder.AppendL(nextComponent);
		pendingComponents[nextComponent] = EFalse;
		numPendingComponents--;
		}

	CleanupStack::PopAndDestroy(&pendingComponents);
	}