// Copyright (c) 2004-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:

// Name          : CSIPExtensionHeader.cpp

// Part of       : SIP Codec

// Version       : SIP/4.0 

//

#include "sipextensionheader.h"

#include "sipcodecerr.h"

#include "SIPSyntaxCheck.h"

#include "sipstrings.h"

#include "sipcodecutils.h"

#include "_sipcodecdefs.h"

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

// CSIPExtensionHeader::NewL

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

//

EXPORT_C CSIPExtensionHeader* CSIPExtensionHeader::NewL(

    const TDesC8& aName,

    const TDesC8& aValue)

	{

	CSIPExtensionHeader* self = CSIPExtensionHeader::NewLC(aName, aValue);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPExtensionHeader::NewLC

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

//

EXPORT_C CSIPExtensionHeader* CSIPExtensionHeader::NewLC(

    const TDesC8& aName,

    const TDesC8& aValue)

	{

	CSIPExtensionHeader* self = new(ELeave)CSIPExtensionHeader;

	CleanupStack::PushL (self);

	self->ConstructL(aName, aValue);

	return self;

	}

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

// CSIPExtensionHeader::CSIPExtensionHeader

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

//

CSIPExtensionHeader::CSIPExtensionHeader()

	{

	}

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

// CSIPExtensionHeader::ConstructL

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

//

void CSIPExtensionHeader::ConstructL(const TDesC8& aName, const TDesC8& aValue)

	{

	SetNameL(aName);

	SetValueL(aValue);

	}

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

// CSIPExtensionHeader::ConstructL

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

//

void CSIPExtensionHeader::ConstructL(

    const CSIPExtensionHeader& aExtensionHeader)

	{

	iName = aExtensionHeader.Name().Copy();

	iValue = aExtensionHeader.iValue->AllocL ();

	}

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

// CSIPExtensionHeader::~CSIPExtensionHeader

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

//

EXPORT_C CSIPExtensionHeader::~CSIPExtensionHeader()

	{

	delete iValue;

	iName.Close();

	}

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

// CSIPExtensionHeader::CloneL

// From CSIPHeaderBase:

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

//

EXPORT_C CSIPHeaderBase* CSIPExtensionHeader::CloneL() const

	{

	CSIPExtensionHeader* clone = new(ELeave)CSIPExtensionHeader;

	CleanupStack::PushL(clone);

	clone->ConstructL(*this);

	CleanupStack::Pop(clone);

	return clone;	

	}

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

// CSIPExtensionHeader::SetValueL

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

//

EXPORT_C void CSIPExtensionHeader::SetValueL(const TDesC8& aValue)

	{

	HBufC8* tmp = aValue.AllocLC();

	tmp->Des().Trim();

	if (!CheckValue(*tmp)) 

		{

		User::Leave(KErrSipCodecHeaderValue);

		}

	CleanupStack::Pop(tmp);

	delete iValue;

	iValue = tmp;

	}

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

// CSIPExtensionHeader::Value

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

//

EXPORT_C const TDesC8& CSIPExtensionHeader::Value() const

	{

	return *iValue;

	}

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

// CSIPExtensionHeader::Name

// From CSIPHeaderBase:

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

//

EXPORT_C RStringF CSIPExtensionHeader::Name() const

	{

	return iName;

	}

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

// CSIPExtensionHeader::HasCompactName

// From CSIPHeaderBase:

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

//

TBool CSIPExtensionHeader::HasCompactName() const

	{

	return ETrue;

	}

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

// CSIPExtensionHeader::CompactName

// From CSIPHeaderBase:

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

//

RStringF CSIPExtensionHeader::CompactName() const

	{

	return iName;

	}

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

// CSIPExtensionHeader::EncodeMultipleToOneLine

// From CSIPHeaderBase:

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

//

TBool CSIPExtensionHeader::EncodeMultipleToOneLine() const

	{

	return EFalse;

	}

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

// CSIPExtensionHeader::MoreThanOneAllowed

// From CSIPHeaderBase:

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

//

TBool CSIPExtensionHeader::MoreThanOneAllowed() const

	{

	return ETrue;

	}

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

// CSIPExtensionHeader::IsExtensionHeader

// From CSIPHeaderBase:

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

//

TBool CSIPExtensionHeader::IsExtensionHeader() const

	{

	return ETrue;

	}

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

// CSIPExtensionHeader::ExternalizeSupported

// From CSIPHeaderBase:

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

//

EXPORT_C TBool CSIPExtensionHeader::ExternalizeSupported() const

	{

	return ETrue;

	}

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

// CSIPExtensionHeader::InternalizeValueL

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

//

EXPORT_C CSIPExtensionHeader* CSIPExtensionHeader::InternalizeValueL(

    RReadStream& aReadStream)

	{

	CSIPExtensionHeader* self = new(ELeave)CSIPExtensionHeader;

	CleanupStack::PushL(self);

	self->DoInternalizeValueL(aReadStream);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPExtensionHeader::ExternalizeValueL

// From CSIPHeaderBase:

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

//

void CSIPExtensionHeader::ExternalizeValueL(RWriteStream& aWriteStream) const

	{

	aWriteStream.WriteUint32L (iValue->Length());

	aWriteStream.WriteL (*iValue);

	}

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

// CSIPExtensionHeader::DoInternalizeValueL

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

//

void CSIPExtensionHeader::DoInternalizeValueL(RReadStream& aReadStream)

	{

    iValue = SIPCodecUtils::ReadDescFromStreamL(aReadStream);

	}

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

// CSIPExtensionHeader::ToTextValueL

// From CSIPHeaderBase:

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

//

EXPORT_C HBufC8* CSIPExtensionHeader::ToTextValueL() const

	{

	return iValue->AllocL();

	}

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

// CSIPExtensionHeader::PreferredPlaceInMessage

// From CSIPHeaderBase:

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

//

CSIPHeaderBase::TPreferredPlace 

CSIPExtensionHeader::PreferredPlaceInMessage() const

	{

	return CSIPHeaderBase::EMiddleBottom;

	}

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

// CSIPExtensionHeader::CheckValue

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

//

TBool CSIPExtensionHeader::CheckValue(const TDesC8& aValue)

	{

	return SIPSyntaxCheck::ExtensionHeaderValue(aValue);

	}

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

// CSIPExtensionHeader::SetNameL

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

//

void CSIPExtensionHeader::SetNameL(const TDesC8& aName)

	{

    RStringF tmp = 

        SIPCodecUtils::CheckAndCreateTokenL(aName, KErrSipCodecHeaderName);

	iName.Close();

    iName = tmp;

	}