// 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:

// utility fucntions, and odds and sods for various bits of the location server

// 

//

#include <lbs/lbsextendedsatellite.h>

#include "utilfunctions.h"

#include "LbsInternalInterface.h"

/**

Deap copy of position info data by type

@param aTo the destination position info object reference

@param aFrom the source position info object reference

@internalComponent

@released

*/

TInt CopyPositionTypes(TPositionInfoBase& aTo, const TPositionInfoBase& aFrom)	

	{

	const TUint32 toClassType = aTo.PositionClassType();

	const TUint toClassSize = aTo.PositionClassSize();

	const TUint32 fromClassType = aFrom.PositionClassType();

	const TUint fromClassSize = aFrom.PositionClassSize();

	// check for self assignment

	if(&aTo == &aFrom)

		{

		return KErrNone; // copy is implicit and already done :)

		}	

	// check the assignment is even possible the source type must be at

	// at least as BIG as the dest, or  you leave unitialized data in the destination

	if(fromClassSize < toClassSize)

		return KErrArgument;

	return CopyPositionTypes2(aTo,aFrom);

	}

	/**

Deap copy of position info data by type - same as CopyPositionTypes2 but

allows for  source posituin to be smaller than destination position

@param aTo the destination position info object reference

@param aFrom the source position info object reference

@internalComponent

@released

*/

TInt CopyPositionTypes2(TPositionInfoBase& aTo, const TPositionInfoBase& aFrom)	

	{

	const TUint32 toClassType = aTo.PositionClassType();

	const TUint toClassSize = aTo.PositionClassSize();

	const TUint32 fromClassType = aFrom.PositionClassType();

	const TUint fromClassSize = aFrom.PositionClassSize();

	// check for self assignment

	if(&aTo == &aFrom)

		{

		return KErrNone; // copy is implicit and already done :)

		}	

	// check the assignment is even possible the source type must be at

	// at least as BIG as the dest, or  you leave unitialized data in the destination

//	if(fromClassSize < toClassSize)

//		return KErrArgument;

	// check we are not assigning base types

	if(toClassSize == sizeof(TPositionInfoBase)

			|| fromClassSize == sizeof(TPositionInfoBase)

			|| toClassType == EPositionInfoUnknownClass // this the type of a TPositionInfoBase

			|| fromClassType == EPositionInfoUnknownClass)

		{

		return KErrArgument; // bad types - trying to copy between base types

		}

	// check the aTo type

	TInt typeError = SupportedType(toClassType, toClassSize);

	if(typeError != KErrNone)

		return typeError; // i.e. KErrNotSupported

	// check the aFromType

	typeError = SupportedType(fromClassType, fromClassSize);

	if(typeError != KErrNone)

		return typeError; // i.e. KErrNotSupported

	// Ok now we know we can copy these things from one to the other

	// so here goes - the catch is we cannot overwrite the type and size

	// of the destination, so we need a bit of pointer math.

	// NB this relies on the being a class inheritance such that all of the

	// types are derived from TPositionInfoBase first. Or the math goes

	// haywire. This also implies a whole slew of assumptions about the ram

	// layout of these classes....

	TUint8* baseToAddr = reinterpret_cast<TUint8*>(&aTo)+sizeof(TPositionClassTypeBase);			

	const TUint8* const baseFromAddr = reinterpret_cast<const TUint8*>(&aFrom)+sizeof(TPositionClassTypeBase);

	TUint32 dataLength = toClassSize-sizeof(TPositionClassTypeBase); // we copy only this many bytes form the source

	TUint8* endAddr = Mem::Copy(baseToAddr, baseFromAddr, dataLength);

	// Sanity check the Mem::Copy() - just in case...

	if(endAddr != baseToAddr+dataLength)

		return KErrGeneral; // Or KErrNoMemory?

	else

		return KErrNone;

	}

/**

Check the size for supported position info type

@param aType the position info type

@param aSize the size of specified type

@return Symbian standard error code

@internalComponent

@released

*/

TInt SupportedType(const TUint32& aType, const TInt& aSize)

	{

	if(aType==EPositionInfoClass)

		{

		if(aSize!=sizeof(TPositionInfo))

			return KErrNotSupported; // something weird. Type ok but the size is wrong			

		}

	else if(aType==(EPositionInfoClass|EPositionCourseInfoClass))

		{

		if(aSize!=sizeof(TPositionCourseInfo))

			return KErrNotSupported; // something weird. Type ok but the size is wrong			

		}

	else if(aType==(EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass))

		{

		if(aSize!=sizeof(TPositionSatelliteInfo))

			return KErrNotSupported; // something weird. Type ok but the size is wrong			

		}

	else if(aType==(EPositionInfoClass|EPositionCourseInfoClass|EPositionSatelliteInfoClass|EPositionExtendedSatelliteInfoClass))

	        {

	        if(aSize!=sizeof(TPositionExtendedSatelliteInfo))

	            return KErrNotSupported; // something weird. Type ok but the size is wrong          

	        }

	// othwerwise the size and type are what we expected

	return KErrNone;

	}

/**

Loop over the module list and return the index of module with module ID aModuelId

@internalComponent

@released

*/

TInt GetIndexFromModuleIdL(const TUid& aModuleId)

	{

	TUint numOfModules;

	TPositionModuleInfo modInfo;

	User::LeaveIfError(LbsModuleInfo::GetNumModules(numOfModules));

	for(TInt i=0; i< numOfModules; ++i)

		{

		User::LeaveIfError(LbsModuleInfo::GetModuleInfoByIndex(i,&modInfo, sizeof(TPositionModuleInfo)));

		if(modInfo.ModuleId() == aModuleId)

			{

			return i;

			}

		}

	return KErrNotFound;

	}