--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/networkprotocolmodules/networkprotocolmodule/LbsProtocolModule/src/cconfigmanager.cpp	Tue Feb 02 01:50:39 2010 +0200
@@ -0,0 +1,215 @@
+// Copyright (c) 2006-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:
+// This file provides the implementation of the class that manages
+// configuration of Test Protocol Module operation.
+// 
+//
+
+#include <centralrepository.h>
+#include "cconfigmanager.h"
+
+/** Static constructor.
+@return A new instance of the CConfigManager class
+*/  
+CConfigManager* CConfigManager::NewL()
+	{
+	CConfigManager* self = new (ELeave) CConfigManager();
+	CleanupStack::PushL(self);
+	self->ConstructL();
+	CleanupStack::Pop(self);
+	return self;
+	}
+
+
+/** Standard constructor.
+*/  
+CConfigManager::CConfigManager()
+	{
+	}
+
+
+/** Standard destructor.
+*/  
+CConfigManager::~CConfigManager()
+	{
+	iDecisionTable.Close();
+	}
+	
+	
+/** Private second-stage constructor.
+*/  
+void CConfigManager::ConstructL()
+	{
+	LoadDecisionDataL();
+	}
+	
+	
+/** Load external decision table data.
+This retrieves decision table entries from the external data source which
+has been installed as part of the system configuration.
+
+This data is stored in the internal decision table in rows and columns
+that represent the current and new operations, respectively.
+*/  
+void CConfigManager::LoadDecisionDataL()
+	{
+	// Pre-allocate table space
+	iDecisionTable.ReserveL(KMaxOperationTypes * KMaxOperationTypes);
+
+	// Open central repository
+	CRepository* repository = CRepository::NewLC(TUid::Uid(KMyRepositoryUid));
+
+	// For each row - current operation
+	for (TInt row = 0; row < KMaxOperationTypes; row++)
+		{
+		// For each column - new operation
+		for (TInt col = 0; col < KMaxOperationTypes; col++)
+			{
+			// Retrieve an item from central repository using a UID
+			// which is derived from the row and column numbers
+			TInt dataValue = -1;
+			TUint32 uid = (row * KMaxOperationTypes) + col + 1;
+			TConflictResult value = KDefaultDecision; // initialise to default
+			if (KErrNone == repository->Get(uid, dataValue))
+				{
+				// Convert entry value to decision value
+				switch (dataValue)
+					{
+				case 0:
+					value = EConflictRejectNew;
+					break;
+				case 1:
+#ifdef PM_HACK_FOR_INC103104				
+					value = EConflictRejectNew;
+#else
+					value = EConflictQueueNew;
+#endif //PM_HACK_FOR_INC103104
+					break;
+				case 2:
+					value = EConflictCancelCurrent;
+					break;
+				case 3:
+					value = EConflictQueueCurrent;
+					break;
+				default:
+					value = EConflictNone;
+					break;
+					};
+				}
+
+			iDecisionTable.Append(value);
+			}
+		}
+
+	// Close central repository
+	CleanupStack::PopAndDestroy(repository);
+	}
+	
+	
+/** Get conflict decision.
+Generates a conflict decision based on the nature of a current operation,
+and the nature of a new operation.
+
+@param aCurrentOp The current operation
+@param aNewOp The new operation for which a decision is required
+@return TConflictDecision The conflict decision:
+	EConflictNone			- This implies there is no current operation
+							  and the new operation is simply started
+	EConflictRejectNew		- The new operation is rejected and any
+							  current operation proceeds unaffected
+	EConflictQueueNew		- The new operation is queued awaiting
+							  completion of any current operation
+	EConflictCancelCurrent	- The current operation is cancelled and
+							  the new operation is started
+	EConflictQueueCurrent	- The current operation is queued an awaits
+							  the completion of the new operation
+*/  
+CConfigManager::TConflictResult CConfigManager::ConflictDecision(const TConflictOperation& aCurrentOp, const TConflictOperation& aNewOp) const
+	{
+	TConflictResult result = KDefaultDecision; // initialise to default decision
+	TInt currentOpIndex;
+	TInt newOpIndex;
+
+	// Get table row index - current operation
+	currentOpIndex = DecisionTableIndex(aCurrentOp);
+	if (0 <= currentOpIndex)
+		{
+		// Get table column index - new operation
+		newOpIndex = DecisionTableIndex(aNewOp);
+		if (0 <= newOpIndex)
+			{
+			// Retrieve entry using row and column index values
+			result = iDecisionTable[(currentOpIndex*KMaxOperationTypes) + newOpIndex];
+			}
+		}
+
+	return result;
+	}
+
+
+/** Get an index for the specified operation.
+*/
+TInt CConfigManager::DecisionTableIndex(const TConflictOperation& aOperation) const
+	{
+	TInt index = -1; // initialised to an invalid index
+
+	// What type of operation is specified?
+	switch (aOperation.iOperation)
+		{
+
+	case EOpMoLr:
+	case EOpNbLr:
+		index = KMoLr;
+		break;
+
+	case EOpMtLr:
+	case EOpNiLr:
+		if (EPriorityEmergency == aOperation.iPriority)
+			{
+			index = KEmergency;
+			}
+		else
+			{
+			index = KMtLr;
+			}
+		break;
+
+	case EOpX3p:
+		// What priority of X3P is specified?
+		switch (aOperation.iPriority)
+			{
+		case EPriorityLow:
+			index = KX3pLow;
+			break;
+
+		case EPriorityMedium:
+			index = KX3pMid;
+			break;
+
+		case EPriorityHigh:
+			index = KX3pHi;
+			break;
+
+		default:
+			break;
+			};
+		break;
+
+	default:
+		break;
+		};
+
+	return index;
+	}
+