diff -r 000000000000 -r dfb7c4ff071f datacommsserver/esockserver/csock/ConnPref.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/datacommsserver/esockserver/csock/ConnPref.cpp	Thu Dec 17 09:22:25 2009 +0200
@@ -0,0 +1,385 @@
+// 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();
+	}
+
+