// Copyright (c) 2005-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          : CSIPContentTypeHeader.cpp

// Part of       : SIP Codec

// Version       : SIP/4.0 

//

#include "sipcontenttypeheader.h"

#include "CSIPContentTypeHeaderParams.h"

#include "SIPSyntaxCheck.h"

#include "sipcodecerr.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipcodecutils.h"

#include "_sipcodecdefs.h"

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

// CSIPContentTypeHeader::DecodeL

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

//

EXPORT_C CSIPContentTypeHeader* 

CSIPContentTypeHeader::DecodeL (const TDesC8& aValue)

	{

	CSIPContentTypeHeader* header = new(ELeave)CSIPContentTypeHeader;

	CleanupStack::PushL (header);

    header->ConstructL();

	header->ParseL (aValue);

	CleanupStack::Pop(header);

	return header;

	}

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

// CSIPContentTypeHeader::NewL

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

//

EXPORT_C CSIPContentTypeHeader* CSIPContentTypeHeader::NewL(

    const TDesC8& aMediaType,

    const TDesC8& aMediaSubtype)

	{

	CSIPContentTypeHeader* self = 

		CSIPContentTypeHeader::NewLC(aMediaType,aMediaSubtype);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPContentTypeHeader::NewLC

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

//

EXPORT_C CSIPContentTypeHeader* CSIPContentTypeHeader::NewLC(

    const TDesC8& aMediaType,

    const TDesC8& aMediaSubtype)

	{

	CSIPContentTypeHeader* self = new(ELeave)CSIPContentTypeHeader;

	CleanupStack::PushL(self);

	self->ConstructL(aMediaType,aMediaSubtype);

	return self;

	}

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

// CSIPContentTypeHeader::CSIPContentTypeHeader

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

//

CSIPContentTypeHeader::CSIPContentTypeHeader()

 : CSIPParameterHeaderBase(';')

	{

	}

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

// CSIPContentTypeHeader::ConstructL

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

//

void CSIPContentTypeHeader::ConstructL ()

	{

	iParams = new(ELeave)CSIPContentTypeHeaderParams;

	}

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

// CSIPContentTypeHeader::ConstructL

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

//

void CSIPContentTypeHeader::ConstructL (const TDesC8& aMediaType,

										const TDesC8& aMediaSubtype)

	{

    ConstructL ();

	SetMediaTypeL (aMediaType);

	SetMediaSubtypeL (aMediaSubtype);

	}

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

// CSIPContentTypeHeader::ConstructL

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

//

void CSIPContentTypeHeader::ConstructL (const CSIPContentTypeHeader&

										aContentTypeHeader)

	{

	SetMediaTypeL (aContentTypeHeader.MediaType());

	SetMediaSubtypeL (aContentTypeHeader.MediaSubtype());

	iParams = CSIPContentTypeHeaderParams::NewL(*(aContentTypeHeader.iParams));

	}

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

// CSIPContentTypeHeader::~CSIPContentTypeHeader

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

//

EXPORT_C CSIPContentTypeHeader::~CSIPContentTypeHeader()

	{

	delete iParams;

	delete iMediaSubtype;

	delete iMediaType;

	}

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

// CSIPContentTypeHeader::CloneL

// From CSIPHeaderBase:

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

//

EXPORT_C CSIPHeaderBase* CSIPContentTypeHeader::CloneL () const

	{

	CSIPContentTypeHeader* clone = new(ELeave)CSIPContentTypeHeader;

	CleanupStack::PushL(clone);

	clone->ConstructL(*this);

	CleanupStack::Pop(clone);

	return clone;

	}

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

// CSIPContentTypeHeader::MediaType

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

//

EXPORT_C const TDesC8& CSIPContentTypeHeader::MediaType () const

	{

	return *iMediaType;

	}

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

// CSIPContentTypeHeader::SetMediaTypeL

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

//

EXPORT_C void CSIPContentTypeHeader::SetMediaTypeL (const TDesC8& aMediaType)

	{

    SIPCodecUtils::CheckAndSetValueL(iMediaType,

                                     aMediaType,

                                     KErrSipCodecContentTypeHeader);

	}

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

// CSIPContentTypeHeader::MediaSubtype

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

//

EXPORT_C const TDesC8& CSIPContentTypeHeader::MediaSubtype () const

	{

	return *iMediaSubtype;

	}

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

// CSIPContentTypeHeader::SetMediaSubtypeL

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

//

EXPORT_C void 

CSIPContentTypeHeader::SetMediaSubtypeL (const TDesC8& aMediaSubtype)

	{

    SIPCodecUtils::CheckAndSetValueL(iMediaSubtype,

                                     aMediaSubtype,

                                     KErrSipCodecContentTypeHeader);

	}

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

// CSIPContentTypeHeader::Name

// From CSIPHeaderBase:

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

//

EXPORT_C RStringF CSIPContentTypeHeader::Name() const

	{

	return SIPStrings::StringF(SipStrConsts::EContentTypeHeader);

	}

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

// CSIPContentTypeHeader::HasCompactName

// From CSIPHeaderBase:

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

//

TBool CSIPContentTypeHeader::HasCompactName () const

	{

	return ETrue;

	}

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

// CSIPContentTypeHeader::CompactName

// From CSIPHeaderBase:

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

//

RStringF CSIPContentTypeHeader::CompactName () const

	{

	return SIPStrings::StringF(SipStrConsts::EContentTypeHeaderCompact);

	}

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

// CSIPContentTypeHeader::InternalizeValueL

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

//

EXPORT_C CSIPHeaderBase* CSIPContentTypeHeader::InternalizeValueL(

    RReadStream& aReadStream)

	{

	CSIPContentTypeHeader* self = new(ELeave)CSIPContentTypeHeader;

	CleanupStack::PushL(self);

	self->DoInternalizeValueL(aReadStream);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPContentTypeHeader::ExternalizeValueL

// From CSIPHeaderBase:

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

//

void CSIPContentTypeHeader::ExternalizeValueL(RWriteStream& aWriteStream) const

	{

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

	aWriteStream.WriteL (*iMediaType);

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

	aWriteStream.WriteL (*iMediaSubtype);

	iParams->ExternalizeL (aWriteStream);

	}

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

// CSIPContentTypeHeader::DoInternalizeValueL

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

//

void CSIPContentTypeHeader::DoInternalizeValueL(RReadStream& aReadStream)

	{

    iMediaType = SIPCodecUtils::ReadDescFromStreamL(aReadStream);

    iMediaSubtype = SIPCodecUtils::ReadDescFromStreamL(aReadStream);

	iParams = CSIPContentTypeHeaderParams::InternalizeL (aReadStream);

	}

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

// CSIPContentTypeHeader::PreferredPlaceInMessage

// From CSIPHeaderBase:

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

//

CSIPHeaderBase::TPreferredPlace

CSIPContentTypeHeader::PreferredPlaceInMessage () const

	{

	return CSIPHeaderBase::EBottom;

	}

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

// CSIPContentTypeHeader::BaseDecodeL

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

//

RPointerArray<CSIPHeaderBase> 

CSIPContentTypeHeader::BaseDecodeL (const TDesC8& aValue)

	{

	CSIPContentTypeHeader* header = DecodeL(aValue);

	CleanupStack::PushL (header);

	RPointerArray<CSIPHeaderBase> headers;

	User::LeaveIfError(headers.Append(header));

	CleanupStack::Pop(header);

	return headers;

	}	

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

// CSIPContentTypeHeader::ToTextMandatoryPartLC

// From CSIPParameterHeaderBase:

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

//

HBufC8* CSIPContentTypeHeader::ToTextMandatoryPartLC () const

    {

	TUint encodedLength = iMediaType->Length() + 1; // SLASH

	encodedLength += iMediaSubtype->Length(); 

	HBufC8* encodingResult = HBufC8::NewLC (encodedLength);

	TPtr8 encodingResultPtr = encodingResult->Des();

	encodingResultPtr.Append(*iMediaType);

	encodingResultPtr.Append('/'); // SLASH

	encodingResultPtr.Append(*iMediaSubtype);

	return encodingResult;

    }

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

// CSIPContentTypeHeader::ParseMandatoryPartL

// From CSIPParameterHeaderBase:

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

//

void CSIPContentTypeHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart)

    {

	__ASSERT_ALWAYS (aMandatoryPart.Length() > 0,

	                 User::Leave(KErrSipCodecContentTypeHeader));

	TLex8 lex(aMandatoryPart);

	lex.SkipSpace();

	TPtrC8 value(lex.Remainder());

	TInt slashPos = value.Locate('/');

	if (slashPos <= 0 || slashPos >= value.Length()-1)

		{

		User::Leave (KErrSipCodecContentTypeHeader);

		}

	SetMediaTypeL (value.Left(slashPos));

    SetMediaSubtypeL (value.Mid(slashPos+1));

    }

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

// CSIPContentTypeHeader::Params

// From CSIPParameterHeaderBase:

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

//

const CSIPParamContainerBase& CSIPContentTypeHeader::Params () const

    {

    return *iParams; 

    }

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

// CSIPContentTypeHeader::Params

// From CSIPParameterHeaderBase:

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

//

CSIPParamContainerBase& CSIPContentTypeHeader::Params ()

    {

    return *iParams; 

    }