// Copyright (c) 2007-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 "suplmessagecommon.h"

#include "supldevloggermacros.h" 

/**

 * Supl IPAddress container

 */

EXPORT_C CSuplIpAddress* CSuplIpAddress::NewL()

	{

	SUPLLOG(ELogP1, "CSuplIpAddress::NewL() Begin\n");

	CSuplIpAddress* self = CSuplIpAddress::NewLC();

	SUPLLOG(ELogP1, "CSuplIpAddress::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplIpAddress* CSuplIpAddress::NewLC()

	{

	SUPLLOG(ELogP1, "CSuplIpAddress::NewLC() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplIpAddress::NewLC() End\n");

	return self;

	}

EXPORT_C CSuplIpAddress::~CSuplIpAddress()

	{

	SUPLLOG(ELogP1, "CSuplIpAddress::~CSuplIpAddress() Begin\n");

	SUPLLOG(ELogP1, "CSuplIpAddress::~CSuplIpAddress() End\n");

	}

EXPORT_C TBool CSuplIpAddress::operator==(const CSuplIpAddress& other) const

	{

	return (iIpAddressType==other.iIpAddressType && 

				iIpAddress==other.iIpAddress);

	}

CSuplIpAddress::CSuplIpAddress()

	{

	}

void CSuplIpAddress::ConstructL()

	{

	}

/**

 * Supl FQDN container

 */

EXPORT_C CSuplFqdn* CSuplFqdn::NewL()

	{

	SUPLLOG(ELogP1, "CSuplFqdn::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplFqdn::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplFqdn::~CSuplFqdn()

	{

	SUPLLOG(ELogP1, "CSuplFqdn::~CSuplFqdn() Begin\n");

	SUPLLOG(ELogP1, "CSuplFqdn::~CSuplFqdn() End\n");

	}

EXPORT_C TBool CSuplFqdn::operator==(const CSuplFqdn& other) const

	{

	return (iFqdn==other.iFqdn);

	}

CSuplFqdn::CSuplFqdn()

	{

	}

void CSuplFqdn::ConstructL()

	{

	}

/**

 * Supl SLP Address container

 */

EXPORT_C CSuplSlpAddress* CSuplSlpAddress::NewL()

	{

	SUPLLOG(ELogP1, "CSuplSlpAddress::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplSlpAddress::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplSlpAddress::~CSuplSlpAddress()

	{

	SUPLLOG(ELogP1, "CSuplSlpAddress::~CSuplSlpAddress() Begin\n");

	delete iIpAddress;

	delete iFqdn;

	SUPLLOG(ELogP1, "CSuplSlpAddress::~CSuplSlpAddress() End\n");

	}

EXPORT_C TBool CSuplSlpAddress::operator==(const CSuplSlpAddress& other) const

	{

	return (iSlpAddressType==other.iSlpAddressType &&

			*iIpAddress==*other.iIpAddress &&

			*iFqdn==*other.iFqdn);

	}

CSuplSlpAddress::CSuplSlpAddress()

	{

	}

void CSuplSlpAddress::ConstructL()

	{

	iIpAddress = CSuplIpAddress::NewL();

	iFqdn = CSuplFqdn::NewL();

	}

/**

 * Supl SLP Session ID container

 */

EXPORT_C CSuplSlpSessionId* CSuplSlpSessionId::NewL()

	{

	SUPLLOG(ELogP1, "CSuplSlpSessionId::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	SUPLLOG(ELogP1, "CSuplSlpSessionId::NewL() End\n");

	return self;

	}

EXPORT_C CSuplSlpSessionId::~CSuplSlpSessionId()

	{

	SUPLLOG(ELogP1, "CSuplSlpSessionId::~CSuplSlpSessionId() Begin\n");

	delete iSlpAddress;

	SUPLLOG(ELogP1, "CSuplSlpSessionId::~CSuplSlpSessionId() End\n");

	}

EXPORT_C TBool CSuplSlpSessionId::operator==(const CSuplSlpSessionId& other) const

	{

	return (iSessionId==other.iSessionId && 

	        *iSlpAddress==*other.iSlpAddress);

	}

void CSuplSlpSessionId::ConstructL()

	{

	iSlpAddress = CSuplSlpAddress::NewL();

	}

/**

 * Supl SET ID container

 */

EXPORT_C CSuplSetId* CSuplSetId::NewL()

	{

	SUPLLOG(ELogP1, "CSuplSetId::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplSetId::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplSetId::~CSuplSetId()

	{

	SUPLLOG(ELogP1, "CSuplSetId::~CSuplSetId() Begin\n");

	delete iIpAddress;

	SUPLLOG(ELogP1, "CSuplSetId::~CSuplSetId() End\n");

	}

EXPORT_C TBool CSuplSetId::operator==(const CSuplSetId& other) const

	{

	return (iSetIdType==other.iSetIdType && 

	        *iIpAddress==*other.iIpAddress &&

	        iSetId == other.iSetId);

	}

CSuplSetId::CSuplSetId()

	{

	}

void CSuplSetId::ConstructL()

	{

	iIpAddress = CSuplIpAddress::NewL();

	}

/**

 * Supl SET Session ID container

 */	

EXPORT_C CSuplSetSessionId* CSuplSetSessionId::NewL()

	{

	SUPLLOG(ELogP1, "CSuplSetSessionId::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplSetSessionId::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplSetSessionId::~CSuplSetSessionId()

	{

	SUPLLOG(ELogP1, "CSuplSetSessionId::~CSuplSetSessionId() Begin\n");

	delete iSetId;

	SUPLLOG(ELogP1, "CSuplSetSessionId::~CSuplSetSessionId() End\n");

	}

EXPORT_C TBool CSuplSetSessionId::operator==(const CSuplSetSessionId& other) const

	{

	return (iSessionId==other.iSessionId &&

	 		*iSetId==*other.iSetId);

	}

CSuplSetSessionId::CSuplSetSessionId()

	{

	}

void CSuplSetSessionId::ConstructL()

	{

	iSetId = CSuplSetId::NewL();

	}

/**

 * Supl Session ID container

 */

EXPORT_C CSuplSessionId* CSuplSessionId::NewL()

	{

	SUPLLOG(ELogP1, "CSuplSessionId::NewL() \n");

	CSuplSessionId* self = CSuplSessionId::NewLC();

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplSessionId* CSuplSessionId::NewLC()

	{

	SUPLLOG(ELogP1, "CSuplSessionId::NewLC() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplSessionId::NewLC() End\n");

	return self;

	}

EXPORT_C CSuplSessionId::~CSuplSessionId()

	{

	SUPLLOG(ELogP1, "CSuplSessionId::~CSuplSessionId() Begin\n");

	delete iSetSessionId;

	delete iSlpSessionId;

	SUPLLOG(ELogP1, "CSuplSessionId::~CSuplSessionId() End\n");

	}

EXPORT_C TBool CSuplSessionId::operator==(const CSuplSessionId& other) const

	{

	return (iSetSessionIdPresent==other.iSetSessionIdPresent && 

			iSlpSessionIdPresent==other.iSlpSessionIdPresent &&

			*iSetSessionId==*other.iSetSessionId && 

			*iSlpSessionId==*other.iSlpSessionId);

	}

CSuplSessionId::CSuplSessionId()

	{

	}

void CSuplSessionId::ConstructL()

	{

	iSetSessionId = CSuplSetSessionId::NewL();

	iSlpSessionId = CSuplSlpSessionId::NewL();

	}

/**

 * Supl Version container

 */

EXPORT_C CSuplVersion* CSuplVersion::NewL()

	{

	SUPLLOG(ELogP1, "CSuplVersion::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplVersion::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

CSuplVersion::CSuplVersion()

	{

	}

EXPORT_C CSuplVersion::~CSuplVersion()

	{

	SUPLLOG(ELogP1, "CSuplVersion::~CSuplVersion() Begin\n");

	SUPLLOG(ELogP1, "CSuplVersion::~CSuplVersion() End\n");

	}

EXPORT_C TBool CSuplVersion::operator==(const CSuplVersion& other) const

	{

	return (iMaj==other.iMaj &&

			iMin==other.iMin &&

			iServind==other.iServind);

	}

void CSuplVersion::ConstructL()

	{

	}

/**

 * Supl GSM Cell Info container

 */

EXPORT_C CSuplGsmCellInfo* CSuplGsmCellInfo::NewL()

	{

	SUPLLOG(ELogP1, "CSuplGsmCellInfo::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplGsmCellInfo::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplGsmCellInfo::~CSuplGsmCellInfo()

	{

	SUPLLOG(ELogP1, "CSuplGsmCellInfo::~CSuplGsmCellInfo() Begin\n");

	SUPLLOG(ELogP1, "CSuplGsmCellInfo::~CSuplGsmCellInfo() End\n");

	}

CSuplGsmCellInfo::CSuplGsmCellInfo()

	{

	}

void CSuplGsmCellInfo::ConstructL()

	{

	}

/**

 * Supl CDMA Cell Info container

 */

EXPORT_C CSuplCdmaCellInfo* CSuplCdmaCellInfo::NewL()

	{

	SUPLLOG(ELogP1, "CSuplCdmaCellInfo::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplCdmaCellInfo::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplCdmaCellInfo::~CSuplCdmaCellInfo()

	{

	SUPLLOG(ELogP1, "CSuplCdmaCellInfo::~CSuplCdmaCellInfo() Begin\n");

	SUPLLOG(ELogP1, "CSuplCdmaCellInfo::~CSuplCdmaCellInfo() End\n");

	}

CSuplCdmaCellInfo::CSuplCdmaCellInfo()

	{

	}

void CSuplCdmaCellInfo::ConstructL()

	{

	}

/**

 * Supl WCDMA Cell Info container

 */

EXPORT_C CSuplWcdmaCellInfo* CSuplWcdmaCellInfo::NewL()

	{

	SUPLLOG(ELogP1, "CSuplWcdmaCellInfo::NewL() Begin\n");

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

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplWcdmaCellInfo::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplWcdmaCellInfo::~CSuplWcdmaCellInfo()

	{

	SUPLLOG(ELogP1, "CSuplWcdmaCellInfo::~CSuplWcdmaCellInfo() Begin\n");

	SUPLLOG(ELogP1, "CSuplWcdmaCellInfo::~CSuplWcdmaCellInfo() End\n");

	}

CSuplWcdmaCellInfo::CSuplWcdmaCellInfo()

	{

	}

void CSuplWcdmaCellInfo::ConstructL()

	{

	}

/**

 * Supl Location ID container

 */

EXPORT_C CSuplLocationId* CSuplLocationId::NewL(TSuplLocationType aType)

	{

	SUPLLOG(ELogP1, "CSuplLocationId::NewL() Begin\n");

	CSuplLocationId* self = new (ELeave) CSuplLocationId(aType);

	CleanupStack::PushL(self);

	self->ConstructL();

	SUPLLOG(ELogP1, "CSuplLocationId::NewL() End\n");

	CleanupStack::Pop(self);

	return self;

	}

EXPORT_C CSuplLocationId::~CSuplLocationId()

	{

	SUPLLOG(ELogP1, "CSuplLocationId::~CSuplLocationId() Begin\n");

	delete iGsmCellInfo;

	delete iCdmaCellInfo;

	delete iWcdmaCellInfo;

	SUPLLOG(ELogP1, "CSuplLocationId::~CSuplLocationId() End\n");

	}

CSuplLocationId::CSuplLocationId(TSuplLocationType aType)

 : iType(aType)

	{

	}

void CSuplLocationId::ConstructL()

	{

	switch (iType)

		{

		case ESuplLocationTypeGsm:

			iGsmCellInfo = CSuplGsmCellInfo::NewL();

			break;

		case ESuplLocationTypeCdma:

			iCdmaCellInfo = CSuplCdmaCellInfo::NewL();

			break;

		case ESuplLocationTypeWcdma:

			iWcdmaCellInfo = CSuplWcdmaCellInfo::NewL();

			break;

		default:

			User::Leave(KErrNotSupported);

			break;

		}

	}