// 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          : CSIPAcceptHeader.cpp

// Part of       : SIP Codec

// Version       : SIP/4.0 

//

#include "sipacceptheader.h"

#include "CSIPAcceptHeaderParams.h"

#include "SIPSyntaxCheck.h"

#include "CSIPTokenizer.h"

#include "sipcodecerr.h"

#include "sipstrings.h"

#include "sipstrconsts.h"

#include "sipcodecutils.h"

#include "_sipcodecdefs.h"

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

// CSIPAcceptHeader::DecodeL

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

//

EXPORT_C RPointerArray<CSIPAcceptHeader> 

CSIPAcceptHeader::DecodeL (const TDesC8& aValue)

	{

    RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);

    CSIPHeaderBase::PushLC(&baseheaders);

    RPointerArray<CSIPAcceptHeader> acceptHeaders;

    CleanupClosePushL(acceptHeaders);

    TInt count = baseheaders.Count();

    for (TInt i=0; i < count; i++)

		{

		CSIPAcceptHeader* header = 

            static_cast<CSIPAcceptHeader*>(baseheaders[i]);

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

		}

    CleanupStack::Pop(2); //acceptHeaders, baseheaders

    baseheaders.Close();

    return acceptHeaders;

	}

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

// CSIPAcceptHeader::NewL

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

//

EXPORT_C CSIPAcceptHeader* CSIPAcceptHeader::NewL (

    const TDesC8& aMediaType,

    const TDesC8& aMediaSubtype)

	{

	CSIPAcceptHeader* self = 

	    CSIPAcceptHeader::NewLC (aMediaType,aMediaSubtype);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPAcceptHeader::NewLC

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

//

EXPORT_C CSIPAcceptHeader* CSIPAcceptHeader::NewLC (

    const TDesC8& aMediaType,

    const TDesC8& aMediaSubtype)

	{

	CSIPAcceptHeader* self = new(ELeave)CSIPAcceptHeader;

	CleanupStack::PushL(self);

	self->ConstructL(aMediaType,aMediaSubtype);

	return self;

	}

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

// CSIPAcceptHeader::CSIPAcceptHeader

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

//

CSIPAcceptHeader::CSIPAcceptHeader(TBool aEmpty)

 : CSIPParameterHeaderBase( ';' ), iEmpty(aEmpty)

	{

	}

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

// CSIPAcceptHeader::ConstructL

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

//

void CSIPAcceptHeader::ConstructL ()

	{

	iParams = new(ELeave)CSIPAcceptHeaderParams;

    iMediaType = KNullDesC8().AllocL();

	iMediaSubtype = KNullDesC8().AllocL();

	}

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

// CSIPAcceptHeader::ConstructL

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

//

void CSIPAcceptHeader::ConstructL (const TDesC8& aMediaType,

                                   const TDesC8& aMediaSubtype)

	{

	iParams = new(ELeave)CSIPAcceptHeaderParams;

	SetMediaTypeL (aMediaType);

	SetMediaSubtypeL (aMediaSubtype);

	}

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

// CSIPAcceptHeader::ConstructL

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

//

void CSIPAcceptHeader::ConstructL (const CSIPAcceptHeader& aAcceptHeader)

	{

    if (iEmpty)

        {

        ConstructL ();

        }

    else

        {

	    SetMediaTypeL (aAcceptHeader.MediaType());

	    SetMediaSubtypeL (aAcceptHeader.MediaSubtype());

	    iParams = CSIPAcceptHeaderParams::NewL(*(aAcceptHeader.iParams));

        }

	}

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

// CSIPAcceptHeader::~CSIPAcceptHeader

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

//

EXPORT_C CSIPAcceptHeader::~CSIPAcceptHeader()

	{

	delete iParams;

	delete iMediaSubtype;

	delete iMediaType;

	}

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

// CSIPAcceptHeader::CloneL

// From CSIPHeaderBase:

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

//

EXPORT_C CSIPHeaderBase* CSIPAcceptHeader::CloneL () const

	{

    CSIPAcceptHeader* clone = new (ELeave) CSIPAcceptHeader(iEmpty);

    CleanupStack::PushL(clone);

    clone->ConstructL(*this);

    CleanupStack::Pop(clone);

    return clone;

	}

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

// CSIPAcceptHeader::Name

// From CSIPHeaderBase:

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

//

EXPORT_C RStringF CSIPAcceptHeader::Name () const

	{

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

	}

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

// CSIPAcceptHeader::IsEmpty

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

//

EXPORT_C TBool CSIPAcceptHeader::IsEmpty () const

    {

    return iEmpty;

    }

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

// CSIPAcceptHeader::MediaType

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

//

EXPORT_C const TDesC8& CSIPAcceptHeader::MediaType () const

	{

	return *iMediaType;

	}

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

// CSIPAcceptHeader::SetMediaTypeL

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

//

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

	{

    __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument));

    SIPCodecUtils::CheckAndSetValueL(iMediaType,

                                     aMediaType,

                                     KErrSipCodecAcceptHeader);

	}

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

// CSIPAcceptHeader::MediaSubtype

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

//

EXPORT_C const TDesC8& CSIPAcceptHeader::MediaSubtype () const

	{

	return *iMediaSubtype;

	}

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

// CSIPAcceptHeader::SetMediaSubtypeL

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

//

EXPORT_C void 

CSIPAcceptHeader::SetMediaSubtypeL (const TDesC8& aMediaSubtype)

	{

    __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument));

	HBufC8* tmp = aMediaSubtype.AllocLC();

	tmp->Des().Trim();

	if (!SIPSyntaxCheck::Token(*tmp)) 

		{

		User::Leave(KErrSipCodecAcceptHeader);

		}

	CleanupStack::Pop(tmp);

	delete iMediaSubtype;

	iMediaSubtype = tmp;

	}

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

// CSIPAcceptHeader::QParameter

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

//

EXPORT_C TReal CSIPAcceptHeader::QParameter () const

	{

    return iParams->RealParamValue(SIPStrings::StringF(SipStrConsts::EQ));

	}

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

// CSIPAcceptHeader::SetQParameterL

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

//

EXPORT_C void CSIPAcceptHeader::SetQParameterL (TReal aQValue)

	{

    __ASSERT_ALWAYS (!iEmpty, User::Leave(KErrArgument));

	iParams->SetParamL(SIPStrings::StringF(SipStrConsts::EQ), aQValue);

	}

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

// CSIPAcceptHeader::MoreThanOneAllowed

// From CSIPHeaderBase:

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

//

TBool CSIPAcceptHeader::MoreThanOneAllowed () const

	{

	return ETrue;

	}

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

// CSIPAcceptHeader::InternalizeValueL

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

//

EXPORT_C CSIPHeaderBase* CSIPAcceptHeader::InternalizeValueL (

    RReadStream& aReadStream)

	{

	CSIPAcceptHeader* self = new(ELeave)CSIPAcceptHeader;

	CleanupStack::PushL(self);

	self->DoInternalizeValueL(aReadStream);

	CleanupStack::Pop(self);

	return self;

	}

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

// CSIPAcceptHeader::ExternalizeValueL

// From CSIPHeaderBase:

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

//

void CSIPAcceptHeader::ExternalizeValueL(RWriteStream& aWriteStream) const

	{

    if (!iEmpty)

        {

        aWriteStream.WriteUint8L(1);

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

	    aWriteStream.WriteL (*iMediaType);

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

	    aWriteStream.WriteL (*iMediaSubtype);

	    iParams->ExternalizeL (aWriteStream);

        }

    else

        {

        aWriteStream.WriteUint8L(0);

        }

	}

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

// CSIPAcceptHeader::DoInternalizeValueL

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

//

void CSIPAcceptHeader::DoInternalizeValueL(RReadStream& aReadStream)

	{

    if (aReadStream.ReadUint8L()) // not empty

        {

        iMediaType = SIPCodecUtils::ReadDescFromStreamL(aReadStream);

        iMediaSubtype = SIPCodecUtils::ReadDescFromStreamL(aReadStream);

	    iParams = CSIPAcceptHeaderParams::InternalizeL(aReadStream);

        }

    else

        {

        iEmpty = ETrue;

        ConstructL();

        }

	}

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

// CSIPAcceptHeader::PreferredPlaceInMessage

// From CSIPHeaderBase:

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

//

CSIPHeaderBase::TPreferredPlace

CSIPAcceptHeader::PreferredPlaceInMessage () const

	{

	return CSIPHeaderBase::EBottom;

	}

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

// CSIPAcceptHeader::BaseDecodeL

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

//

RPointerArray<CSIPHeaderBase> 

CSIPAcceptHeader::BaseDecodeL(const TDesC8& aValue)

    {

	RPointerArray<CSIPHeaderBase> headers;

    CSIPHeaderBase::PushLC(&headers);

	TLex8 lex(aValue);

	lex.SkipSpace();

	TPtrC8 remainder(lex.Remainder());

	if (remainder.Length() == 0) 

		{

		CSIPAcceptHeader* header = new(ELeave)CSIPAcceptHeader(ETrue);

		CleanupStack::PushL(header);

		header->ConstructL();

		headers.AppendL(header);

		CleanupStack::Pop(header);

		}

    else

        {

	    CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(remainder, ',');

	    for (TInt i=0; i < tokenizer->Tokens().Count(); i++)

		    {

		    CSIPAcceptHeader* header = new(ELeave)CSIPAcceptHeader;

		    CleanupStack::PushL (header);

		    header->ConstructL();

		    header->ParseL(tokenizer->Tokens()[i]);

		    headers.AppendL(header);

		    CleanupStack::Pop(header);

		    }

        CleanupStack::PopAndDestroy(tokenizer);

        }

    CleanupStack::Pop(); // headers 

	return headers;

    }

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

// CSIPAcceptHeader::ToTextMandatoryPartLC

// From CSIPParameterHeaderBase:

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

//

HBufC8* CSIPAcceptHeader::ToTextMandatoryPartLC () const

	{

    HBufC8* encodingResult = 0;

    if (!iEmpty)

        {

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

	    encodedLength += iMediaSubtype->Length(); 

	    encodingResult = HBufC8::NewLC (encodedLength);

	    TPtr8 encodingResultPtr = encodingResult->Des();

	    encodingResultPtr.Append(*iMediaType);

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

	    encodingResultPtr.Append(*iMediaSubtype);

        }

    else

        {

        encodingResult = KNullDesC8().AllocLC();

        }

	return encodingResult;

	}

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

// CSIPAcceptHeader::ParseMandatoryPartL

// From CSIPParameterHeaderBase:

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

//

void CSIPAcceptHeader::ParseMandatoryPartL (const TDesC8& aMandatoryPart)

	{

	__ASSERT_ALWAYS (aMandatoryPart.Length() > 0, 

		User::Leave(KErrSipCodecAcceptHeader));

	TLex8 lex(aMandatoryPart);

	lex.SkipSpace();

	TPtrC8 remainder(lex.Remainder());

    const TInt KMaxSlashPos = remainder.Length()-2;

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

	if (slashPos <= 0 || slashPos > KMaxSlashPos)

		{

		User::Leave (KErrSipCodecAcceptHeader);

		}

	SetMediaTypeL (remainder.Left(slashPos));

	remainder.Set(remainder.Mid(slashPos+1));

	SetMediaSubtypeL (remainder);

	}

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

// CSIPAcceptHeader::Params

// From CSIPParameterHeaderBase:

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

//

const CSIPParamContainerBase& CSIPAcceptHeader::Params () const

    {

    return *iParams; 

    }

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

// CSIPAcceptHeader::Params

// From CSIPParameterHeaderBase:

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

//

CSIPParamContainerBase& CSIPAcceptHeader::Params () 

    {

    return *iParams; 

    }