// 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 : CSIPAcceptLanguageHeader.cpp
// Part of : SIP Codec
// Version : SIP/4.0
//
#include "sipacceptlanguageheader.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"
_LIT8(KAsterisk, "*");
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::DecodeL
// ----------------------------------------------------------------------------
//
EXPORT_C RPointerArray<CSIPAcceptLanguageHeader>
CSIPAcceptLanguageHeader::DecodeL(const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> baseheaders = BaseDecodeL(aValue);
CSIPHeaderBase::PushLC(&baseheaders);
RPointerArray<CSIPAcceptLanguageHeader> acceptHeaders;
CleanupClosePushL(acceptHeaders);
TInt count = baseheaders.Count();
for (TInt i=0; i < count; i++)
{
CSIPAcceptLanguageHeader* header =
static_cast<CSIPAcceptLanguageHeader*>(baseheaders[i]);
User::LeaveIfError (acceptHeaders.Append(header));
}
CleanupStack::Pop(2); //acceptHeaders, baseheaders
baseheaders.Close();
return acceptHeaders;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::NewL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPAcceptLanguageHeader* CSIPAcceptLanguageHeader::NewL(
const TDesC8& aLanguageRange)
{
CSIPAcceptLanguageHeader* self =
CSIPAcceptLanguageHeader::NewLC(aLanguageRange);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::NewLC
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPAcceptLanguageHeader* CSIPAcceptLanguageHeader::NewLC(
const TDesC8& aLanguageRange)
{
CSIPAcceptLanguageHeader* self = new(ELeave)CSIPAcceptLanguageHeader;
CleanupStack::PushL(self);
self->ConstructL(aLanguageRange);
return self;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::CSIPAcceptLanguageHeader
// ----------------------------------------------------------------------------
//
CSIPAcceptLanguageHeader::CSIPAcceptLanguageHeader()
: CSIPParameterHeaderBase( ';' )
{
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::ConstructL()
{
iParams = new(ELeave)CSIPAcceptHeaderParams;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::ConstructL(const TDesC8& aLanguageRange)
{
SetLanguageRangeL(aLanguageRange);
ConstructL ();
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ConstructL
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::ConstructL(
const CSIPAcceptLanguageHeader& aAcceptLanguageHeader)
{
SetLanguageRangeL (aAcceptLanguageHeader.LanguageRange());
iParams = CSIPAcceptHeaderParams::NewL(*(aAcceptLanguageHeader.iParams));
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::~CSIPAcceptLanguageHeader
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPAcceptLanguageHeader::~CSIPAcceptLanguageHeader()
{
delete iParams;
delete iLanguageRange;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::CloneL
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPHeaderBase* CSIPAcceptLanguageHeader::CloneL() const
{
CSIPAcceptLanguageHeader* clone = new(ELeave)CSIPAcceptLanguageHeader;
CleanupStack::PushL(clone);
clone->ConstructL(*this);
CleanupStack::Pop(clone);
return clone;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::Name
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
EXPORT_C RStringF CSIPAcceptLanguageHeader::Name () const
{
return SIPStrings::StringF(SipStrConsts::EAcceptLanguageHeader);
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::MoreThanOneAllowed
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
TBool CSIPAcceptLanguageHeader::MoreThanOneAllowed() const
{
return ETrue;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::LanguageRange
// ----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CSIPAcceptLanguageHeader::LanguageRange() const
{
return *iLanguageRange;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::SetLanguageRangeL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPAcceptLanguageHeader::SetLanguageRangeL(
const TDesC8& aLanguageRange)
{
CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aLanguageRange,'-');
TLex8 lex(tokenizer->Tokens()[0]);
lex.SkipSpace();
TPtrC8 remainder(lex.Remainder());
if (remainder.Length() > 0)
{
if (!SIPSyntaxCheck::AlphaMaxSize8(remainder))
{
if (tokenizer->Tokens().Count() == 1)
{
if (remainder.CompareF(KAsterisk) != 0)
{
User::Leave(KErrSipCodecAcceptLanguageHeader);
}
}
else
{
User::Leave(KErrSipCodecAcceptLanguageHeader);
}
}
for (TInt i=1; i < tokenizer->Tokens().Count(); i++)
{
if(!SIPSyntaxCheck::AlphaMaxSize8(tokenizer->Tokens()[i]))
{
User::Leave(KErrSipCodecAcceptLanguageHeader);
}
}
}
CleanupStack::PopAndDestroy(tokenizer);
HBufC8* tmp = aLanguageRange.AllocL();
tmp->Des().Trim();
delete iLanguageRange;
iLanguageRange = tmp;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::QParameter
// ----------------------------------------------------------------------------
//
EXPORT_C TReal CSIPAcceptLanguageHeader::QParameter() const
{
return iParams->RealParamValue(SIPStrings::StringF(SipStrConsts::EQ));
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::SetQParameterL
// ----------------------------------------------------------------------------
//
EXPORT_C void CSIPAcceptLanguageHeader::SetQParameterL(TReal aQValue)
{
iParams->SetParamL(SIPStrings::StringF(SipStrConsts::EQ), aQValue);
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::InternalizeValueL
// ----------------------------------------------------------------------------
//
EXPORT_C CSIPHeaderBase* CSIPAcceptLanguageHeader::InternalizeValueL(
RReadStream& aReadStream)
{
CSIPAcceptLanguageHeader* self = new(ELeave)CSIPAcceptLanguageHeader;
CleanupStack::PushL(self);
self->DoInternalizeValueL(aReadStream);
CleanupStack::Pop(self);
return self;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ExternalizeValueL
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::ExternalizeValueL(
RWriteStream& aWriteStream) const
{
aWriteStream.WriteUint32L(iLanguageRange->Length());
aWriteStream.WriteL(*iLanguageRange);
iParams->ExternalizeL(aWriteStream);
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::DoInternalizeValueL
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::DoInternalizeValueL(RReadStream& aReadStream)
{
iLanguageRange = SIPCodecUtils::ReadDescFromStreamL(aReadStream);
iParams = CSIPAcceptHeaderParams::InternalizeL (aReadStream);
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::PreferredPlaceInMessage
// From CSIPHeaderBase:
// ----------------------------------------------------------------------------
//
CSIPHeaderBase::TPreferredPlace
CSIPAcceptLanguageHeader::PreferredPlaceInMessage() const
{
return CSIPHeaderBase::EBottom;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::BaseDecodeL
// ----------------------------------------------------------------------------
//
RPointerArray<CSIPHeaderBase> CSIPAcceptLanguageHeader::BaseDecodeL(
const TDesC8& aValue)
{
RPointerArray<CSIPHeaderBase> headers;
CSIPHeaderBase::PushLC(&headers);
CSIPTokenizer* tokenizer = CSIPTokenizer::NewLC(aValue, ',');
for (TInt i=0; i < tokenizer->Tokens().Count(); i++)
{
CSIPAcceptLanguageHeader* header = new(ELeave)CSIPAcceptLanguageHeader;
CleanupStack::PushL (header);
header->ConstructL();
header->ParseL(tokenizer->Tokens()[i]);
if (header->LanguageRange().Length() == 0 &&
header->ParamCount() > 0)
{
User::Leave(KErrSipCodecAcceptEncodingHeader);
}
headers.AppendL(header);
CleanupStack::Pop(header);
}
CleanupStack::PopAndDestroy(tokenizer);
CleanupStack::Pop(); // headers
return headers;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ToTextMandatoryPartLC
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
HBufC8* CSIPAcceptLanguageHeader::ToTextMandatoryPartLC() const
{
return iLanguageRange->AllocLC();
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::ParseMandatoryPartL
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
void CSIPAcceptLanguageHeader::ParseMandatoryPartL(
const TDesC8& aMandatoryPart)
{
SetLanguageRangeL(aMandatoryPart);
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::Params
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
const CSIPParamContainerBase& CSIPAcceptLanguageHeader::Params() const
{
return *iParams;
}
// ----------------------------------------------------------------------------
// CSIPAcceptLanguageHeader::Params
// From CSIPParameterHeaderBase:
// ----------------------------------------------------------------------------
//
CSIPParamContainerBase& CSIPAcceptLanguageHeader::Params()
{
return *iParams;
}