/*

* Copyright (c) 2006-2007 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:  ?Description

*

*/

#include <s32strm.h>

#include "irchannelserverurl.h"

#include "irdebug.h"

// ======== LOCAL FUNCTIONS ========

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::NewL()

//Static function

//standard two phased constructor

// ---------------------------------------------------------------------------

//

EXPORT_C CIRChannelServerUrl* CIRChannelServerUrl::NewL()

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::NewL - Entering" );

	CIRChannelServerUrl* self=CIRChannelServerUrl::NewLC();

	CleanupStack::Pop(self);

	IRLOG_DEBUG( "CIRChannelServerUrl::NewL - Exiting." );

	return self;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::NewLC()

//Static function

//standard two phased constructor

// ---------------------------------------------------------------------------

//

EXPORT_C CIRChannelServerUrl* CIRChannelServerUrl::NewLC()

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::NewLC - Entering" );

	CIRChannelServerUrl* self=new(ELeave)CIRChannelServerUrl;

	CleanupStack::PushL(self);

	self->ConstructL();

	IRLOG_DEBUG( "CIRChannelServerUrl::NewLC - Exiting." );

	return self;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::SetServerName()

//sets server name 

// ---------------------------------------------------------------------------

//

EXPORT_C void CIRChannelServerUrl::SetServerName(const TDesC& aServerName)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::SetServerName - Entering" );

	iServerName=aServerName.Alloc();

	IRLOG_DEBUG( "CIRChannelServerUrl::SetServerName - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::SetServerUrl()

//sets server url 

// ---------------------------------------------------------------------------

//

EXPORT_C void CIRChannelServerUrl::SetServerUrl(const TDesC& aServerUrl)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::SetServerUrl - Entering" );

	iURL=aServerUrl.Alloc();

	IRLOG_DEBUG( "CIRChannelServerUrl::SetServerUrl - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::SetBitRate()

//sets server bitrate 

// ---------------------------------------------------------------------------

//

EXPORT_C void CIRChannelServerUrl::SetBitRate(TInt aBitrate)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::SetBitRate - Entering" );

	iBitrate=aBitrate;

	//if a negative value comes,set the bitrate to 0,so that it is accessable 

	//to all the setting combination

	if ( iBitrate < 0)

		{

		iBitrate = 0;

		}

	IRLOG_DEBUG( "CIRChannelServerUrl::SetBitRate - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::GetServerName()

//gets server name 

// ---------------------------------------------------------------------------

//

EXPORT_C const TDesC& CIRChannelServerUrl::GetServerName() const

	{

	return *iServerName;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::GetServerUrl()

//gets server url 

// ---------------------------------------------------------------------------

//

EXPORT_C const TDesC& CIRChannelServerUrl::GetServerUrl() const

	{

	return *iURL;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::GetBitRate()

//gets server bitrate

// ---------------------------------------------------------------------------

//

EXPORT_C TInt CIRChannelServerUrl::GetBitRate() const

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::GetBitRate" );

	return iBitrate;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::~CIRChannelServerUrl()

//standard C++ destructor

// ---------------------------------------------------------------------------

//

CIRChannelServerUrl::~CIRChannelServerUrl()

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::~CIRChannelServerUrl - Entering" );

	delete iServerName;

	iServerName=NULL;

	delete iURL;

	iURL=NULL;

	IRLOG_DEBUG( "CIRChannelServerUrl::~CIRChannelServerUrl - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::=()

//standard C++ copy constructor(deep copy) 

// ---------------------------------------------------------------------------

//	

EXPORT_C CIRChannelServerUrl& CIRChannelServerUrl::operator=(

	const CIRChannelServerUrl& churl)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::operator= - Entering" );

	if(&churl == this)

		{

		return *this;

		}

	if(iServerName)

		{

		delete iServerName;

		iServerName=NULL;

		}

	if(churl.iServerName)

		{

		iServerName=churl.iServerName->Alloc();

		}

	if(iURL)

		{

		delete iURL;

		iURL=NULL;

		}

	if(churl.iBitrate)

		{

		iURL=churl.iURL->Alloc();

		}

	iBitrate=churl.iBitrate;

	IRLOG_DEBUG( "CIRChannelServerUrl::operator= - Exiting." );

	return *this;

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::ExternalizeL()

//function to externalize url data

// ---------------------------------------------------------------------------

//

EXPORT_C void CIRChannelServerUrl::ExternalizeL(RWriteStream& aWriteStream)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::ExternalizeL - Entering" );

	TInt len;

	if( !iServerName )

		{

		len=0;

		aWriteStream.WriteInt32L(len);

		}

	else

		{

		len=iServerName->Length();

		aWriteStream.WriteInt32L(len);

		aWriteStream << *iServerName;

		}

	if(!iURL )

		{

		len=0;

		aWriteStream.WriteInt32L(len);

		}

	else

		{

		len=iURL->Length();

		aWriteStream.WriteInt32L(len);

		aWriteStream << *iURL;

		}

	aWriteStream.WriteInt32L(iBitrate);

    IRLOG_DEBUG( "CIRChannelServerUrl::ExternalizeL - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::InternalizeL()

//function to internalize url data

// ---------------------------------------------------------------------------

//

EXPORT_C void CIRChannelServerUrl::InternalizeL(RReadStream& aReadStream)

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::InternalizeL - Entering" );

	TInt len;

	len= aReadStream.ReadInt32L();

	if(len!=0)

		{

		iServerName=HBufC::NewL(aReadStream,len);	

		}

	len=aReadStream.ReadInt32L();

	if(len!=0)

		{

		iURL=HBufC::NewL(aReadStream,len);	

		}

	iBitrate=aReadStream.ReadInt32L();

	IRLOG_DEBUG( "CIRChannelServerUrl::InternalizeL - Exiting." );

	}

// ---------------------------------------------------------------------------

//CIRChannelServerUrl::ConstructL()

//standard second phase construction

// ---------------------------------------------------------------------------

//	

 void CIRChannelServerUrl::ConstructL() const

	{

	IRLOG_DEBUG( "CIRChannelServerUrl::ConstructL" );

	return;

	}