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

//

/**

 @file

 @internalTechnology 

*/

#include "ConnPref.h"

#include <es_connpref.h>

#include <comms-infras/metadata.h>

#include <comms-infras/metatype.h>

using namespace Meta;

EXPORT_C TConnPref::TConnPref()

: TBuf8<KMaxConnPrefSize>()

/**

Default Constructor 

Setting length to 0x40 and Extension ID to 0x00

*/

	{

	SetLength(KMaxConnPrefSize);

	SetExtensionId(TConnPref::EConnPrefUnknown);

	}

EXPORT_C TConnPref::TConnPref(TInt aExtensionId)

: TBuf8<KMaxConnPrefSize>()

/**

Constructor 

Setting length to 0x40 and Extension ID to aExtensionId

@param aExtensionId

*/

	{

	SetLength(KMaxConnPrefSize);

	SetExtensionId(aExtensionId);

	}

EXPORT_C void TConnPref::SetExtensionId(TInt aExtensionId)

/**

Set the extension (derrived class) id

@param aExtensionId

*/

	{

	BasePtr()->iExtensionId = aExtensionId;

	}

EXPORT_C TInt TConnPref::ExtensionId() const

/**

Get the extension (derrived class) id 

@return Extension ID.

*/

	{

	return BasePtr()->iExtensionId;

	}

EXPORT_C void TConnPref::SetUserLen(TInt aLen)

/**

Set descriptor length to actual length of subclass

@param aLen,length of subclass.

*/

	{

	SetLength(aLen+Align4(sizeof(SConnPref)));

	}

EXPORT_C TInt TConnPref::GetUserLen()

/**

Get the length of the subclass 

@return length of the subclass 

*/

	{

	return Length()-Align4(sizeof(SConnPref));

	}

struct SCommApPref

/**

@internalTechnology

@released since v9.1

*/

	{

	TUint32 iAp;

	};

EXPORT_C TConnSnapPref::TConnSnapPref() :

	TConnPref(EConnPrefSnap)

	{

	SetSnap( 0 );

	}

EXPORT_C TConnSnapPref::TConnSnapPref(TUint32 aSnap) :

	TConnPref(EConnPrefSnap)

	{

	SetSnap( aSnap );

	}

EXPORT_C void TConnSnapPref::SetSnap(TUint32 aSnap)

/**

Sets SNAP

@publishedAll

@param aSnap - new SNAP value

@released since v9.1

*/

	{

	SCommApPref* prefPtr = reinterpret_cast<SCommApPref*>(UserPtr());

	prefPtr->iAp = aSnap;

	}

EXPORT_C TUint32 TConnSnapPref::Snap() const

/**

@publishedPartner

@return stored SNAP value

@released since v9.1

*/

	{

	return reinterpret_cast<SCommApPref*>(UserPtr())->iAp;

	}

EXPORT_C TConnIdList::TConnIdList() :

	TConnPref(EConnPrefIdList)

	{

	CountRef() = 0;

	}

EXPORT_C TInt TConnIdList::MaxCount()

/**

@publishedPartner

@return max number of APs to store

@released since v9.1

*/

	{

	return (KMaxConnPrefSize - sizeof(TInt))/sizeof(TInt);

	}

EXPORT_C TInt& TConnIdList::operator[](TInt aIndex)

/**

operator to access the list based on index

@publishedPartner

@param aIndex - index

@released since v9.1

*/

	{

	if (! (aIndex >= 0 && aIndex < Count()))

		{

	  	User::Panic (KNullDesC, KErrOverflow);

     	}

	return *(IdList() + aIndex);

	}

EXPORT_C void TConnIdList::Append(TInt aId)

/**

Appends new Id

@publishedPartner

@param aAp - Id to add

@released since v9.1

*/

	{

	TUint16& count = CountRef();

	if (count >= MaxCount())

		{

		User::Panic (KNullDesC, KErrOverflow);

		}

	(*this)[count++] = aId;

	}

EXPORT_C TInt TConnIdList::Get(TInt aIndex) const

/**

Allows read only access to Id based on index

@publishedPartner

@released since v9.1

*/

	{

	//cast the const away to reuse the op[] tha's not changing anything

	return (*(const_cast<TConnIdList*>(this)))[aIndex];

	}

EXPORT_C TInt TConnIdList::Count() const

/**

@publishedPartner

@return number of Ids in the list

@released since v9.1

*/

	{

	//cast the const away to reuse the CountRef() fn that's not changing anything

	return (const_cast<TConnIdList*>(this))->CountRef();

	}

EXPORT_C TConnPrefList::TConnPrefList()

/**

Constructor for TConnPrefList

@publishedAll

*/

	{

	SetExtensionId(TConnPref::EConnPrefEComList);

	}

EXPORT_C TConnPrefList::~TConnPrefList()

/**

Destrcutor - closes iPrefs deleting the pointers but not the objects they point

at. These should be deleted explicitly.

@publishedAll

*/

	{

	iPrefs.Close();

	}

EXPORT_C TConnPrefList* TConnPrefList::NewL()

	{

	TConnPrefList* self = new (ELeave) TConnPrefList();

	return self;	

	}

EXPORT_C TConnPrefList* TConnPrefList::LoadL(TDesC8& aDes)

/**

This function loads an instance of TConnPrefList from the given descriptor and

returns a pointer to that oject in memory is possible, otherwise leaves

@publishedAll

@param aDes - a descriptor containing a serialized form of TConnPrefList

@return TConnPrefList* to the instance of the object in memory

*/

	{

	TConnPrefList* obj = TConnPrefList::NewL();

	CleanupStack::PushL(obj);

	User::LeaveIfError(obj->Load(aDes));

	CleanupStack::Pop(obj);

	return obj;

	}

EXPORT_C TInt TConnPrefList::Length()

/**

Returns the size of the desciptor needed to store the object using the store

function

@publishedAll

@return Integer representing the length of descriptor need to store the object

*/

	{

	return KMaxConnPrefSize + iPrefs.Length();

	}

EXPORT_C TInt TConnPrefList::Load(TDesC8& aDes)

/**

This function loads an instance of TConnPrefList from the given descriptor into 

the object its called on. It returns an integer error on failiure

@publishedAll

@param - a descriptor containing a serialized instance of TConnPrefList

@return - KErrNone if successful otherwise KErrArgument

*/

	{	

	TPtrC8 aBuffer(aDes);

	Mem::Copy(&iBuf, aBuffer.Ptr() ,sizeof(iBuf));

	aBuffer.Set(aBuffer.Ptr() + sizeof( iBuf), aBuffer.Length() - sizeof(iBuf));

	if(ExtensionId() == TConnPref::EConnPrefUnknown || ExtensionId() == TConnPref::EConnPrefCommDb || 

			ExtensionId() == TConnPref::EConnPrefCommDbMulti || ExtensionId() == TConnPref::EConnPrefSnap ||

			ExtensionId() == TConnPref::EConnPrefIdList || ExtensionId() == TConnPref::EConnPrefSip ||

			ExtensionId() == TConnPref::EConnPrefProviderInfo)

		{

			return KErrNone;

		}

	else if(ExtensionId() != TConnPref::EConnPrefEComList)

		{

			return KErrArgument;

		}

	TInt ret = iPrefs.GetTypeId().Check(aBuffer);

	if(ret != KErrNone)

		{

		return ret;

		}

	return ret = iPrefs.Load(aBuffer);

	}

EXPORT_C TInt TConnPrefList::Store(TDes8& aDes)

/**

This puts a serilized form of the object that the function is called on into the

descriptor supplied

@publishedAll

@param - a descriptor that is sufficiently long enough to contain the serialized

version of the object

@return - KErrNone if successful

 		- KErrOverflow if the descriptor is too short

 		- otherwise one of the standard error codes

*/

	{

	TUint length = Length();

	aDes.Append((TUint8*)&iBuf,sizeof(iBuf));

	if(aDes.MaxLength() < length)

		{

		return KErrOverflow;

		}

	TInt ret = iPrefs.Store(aDes);

	if(ret != KErrNone)

		{

		return ret;

		}

	return KErrNone;

	}

EXPORT_C void TConnPrefList::AppendL(SMetaDataECom* aFamily)

/**

This adds the pointer supplied to the list. Also see TConnAPPref

Only one instance of TConnAPPref can be appended to the list

and passed to RConnection::Start. More than one will force

RConnection::Start to return KErrArgument

@publishedAll

@param - a pointer to an SMetaDataECom object

*/

	{

	if(aFamily == NULL)

		{

		User::Leave(KErrArgument);

		}

	iPrefs.AppendL(aFamily);

	}

EXPORT_C SMetaData* TConnPrefList::operator[](TInt aIndex)

/**

This retrieves a pointer to the object at the given index

@publishedAll

@param - aIndex - the position of the object in the list

@return a pointer to the object in memory

*/

	{

	if(iPrefs.Count() > aIndex)

		{

		return iPrefs[aIndex];

		}

	User::Leave(KErrArgument);

	return NULL;

	}

EXPORT_C void TConnPrefList::Remove(TInt aIndex)

/**

This removes the objet at the given index from the list

@publishedAll

@param - aIndex - the position of the object in the list

*/

	{

	if(iPrefs.Count() > aIndex)

		{

		iPrefs.Remove(aIndex);

		}

	}

EXPORT_C TInt TConnPrefList::Count()

/**

This returns an integer value representing the number of objects in the list

@publishedAll

@return - integer representing the number of objects in the list

*/

	{

	return iPrefs.Count();

	}