// 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          : CSIPParam.cpp
// Part of       : SIP Codec
// Version       : SIP/4.0 
//



#include "CSIPParam.h"
#include "SIPSyntaxCheck.h"
#include "sipstrings.h"
#include "sipcodecerr.h"


// -----------------------------------------------------------------------------
// CSIPParam::DecodeL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::DecodeL(const TDesC8& aValue)
	{
	TPtrC8 pname;
	TPtrC8 pvalue;
	TBool hasValue = ParseL(aValue,pname,pvalue);
	if (hasValue)
		{
		return CSIPParam::NewL(pname,pvalue);
		}
	return CSIPParam::NewL(pname);
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::ParseL
// -----------------------------------------------------------------------------
//	
TBool CSIPParam::ParseL(const TDesC8& aInput, TPtrC8& aName, TPtrC8& aValue)
    {
	__ASSERT_ALWAYS (aInput.Length() > 0, User::Leave (KErrSipCodecAnyParam));
	TInt equalsPos = aInput.Locate('=');
	if (equalsPos == 0 || equalsPos == aInput.Length()-1) 
		{
		User::Leave (KErrSipCodecAnyParam);
		}
	TBool hasValue = EFalse;	
	if (equalsPos > 0 && !SIPSyntaxCheck::StartsAndEndsWithQuotes(aInput))
		{
		aName.Set(aInput.Left(equalsPos));
		aValue.Set(aInput.Mid(equalsPos+1));
		hasValue = ETrue;
		}
	else
        {
	    aName.Set(aInput);    
        }
	return hasValue;    
    }

// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName)
	{
	CSIPParam* self = CSIPParam::NewLC(aName);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->ConstructL(aName);
	return self;
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const TDesC8& aName)
	{
	CSIPParam* self = CSIPParam::NewLC(aName);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const TDesC8& aName)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->ConstructL(aName);
	return self;
	}	

// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName, RStringF aValue)
	{
	CSIPParam* self = CSIPParam::NewLC(aName,aValue);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName, RStringF aValue)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->ConstructL(aName,aValue);
	return self;
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(RStringF aName, const TDesC8& aValue)
	{
	CSIPParam* self = CSIPParam::NewLC(aName,aValue);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(RStringF aName, const TDesC8& aValue)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->ConstructL(aName,aValue);
	return self;
	}	
	
// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const TDesC8& aName, const TDesC8& aValue)
	{
	CSIPParam* self = CSIPParam::NewLC(aName,aValue);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const TDesC8& aName, const TDesC8& aValue)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->ConstructL(aName,aValue);
	return self;
	}	

// -----------------------------------------------------------------------------
// CSIPParam::NewL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewL(const CSIPParam& aSIPParam)
	{
	CSIPParam* self = CSIPParam::NewLC(aSIPParam);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::NewLC
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::NewLC(const CSIPParam& aSIPParam)
	{
	CSIPParam* self = new(ELeave)CSIPParam(aSIPParam);
	CleanupStack::PushL(self);
	self->ConstructL(aSIPParam);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::CSIPParam()
	{
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::CSIPParam(const CSIPParam& aSIPParam) : CBase()
	{
	iName = aSIPParam.Name().Copy();
	iValue = aSIPParam.Value().Copy();
	iHasValue = aSIPParam.HasValue();
	iAddQuotesWhenEncoding = aSIPParam.iAddQuotesWhenEncoding;
	}

// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName)
	{
	iDesValue = KNullDesC8().AllocL();
	SetL(iName,aName.DesC());
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(const TDesC8& aName)
	{
	iDesValue = KNullDesC8().AllocL();
	SetL(iName,aName);
	}	

// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName, RStringF aValue)
	{
	iDesValue = KNullDesC8().AllocL();
	SetL(iName,aName.DesC());
	SetL(iValue,aValue.DesC(),EFalse);
	iHasValue = ETrue;
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(RStringF aName, const TDesC8& aValue)
	{
	iDesValue = KNullDesC8().AllocL();
	SetL(iName,aName.DesC());
	SetL(iValue,aValue,EFalse);
	iHasValue = ETrue;
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//
void CSIPParam::ConstructL(const TDesC8& aName, const TDesC8& aValue)
	{
	iDesValue = KNullDesC8().AllocL();
	SetL(iName,aName);
	SetL(iValue,aValue,EFalse);
	iHasValue = ETrue;
	}

// -----------------------------------------------------------------------------
// CSIPParam::ConstructL
// -----------------------------------------------------------------------------
//	
void CSIPParam::ConstructL(const CSIPParam& aSIPParam)
    {
    iDesValue = aSIPParam.iDesValue->AllocL();
    }

// -----------------------------------------------------------------------------
// CSIPParam::~CSIPParam
// -----------------------------------------------------------------------------
//
CSIPParam::~CSIPParam()
	{
	iName.Close();
	iValue.Close();
	delete iDesValue;
	}

// -----------------------------------------------------------------------------
// CSIPParam::Name
// -----------------------------------------------------------------------------
//
RStringF CSIPParam::Name() const
	{
	return iName;
	}

// -----------------------------------------------------------------------------
// CSIPParam::HasValue
// -----------------------------------------------------------------------------
//
TBool CSIPParam::HasValue() const
	{
	return iHasValue;
	}

// -----------------------------------------------------------------------------
// CSIPParam::Value
// -----------------------------------------------------------------------------
//
RStringF CSIPParam::Value() const
	{
	return iValue;
	}

// -----------------------------------------------------------------------------
// CSIPParam::DesValue
// -----------------------------------------------------------------------------
//
const TDesC8& CSIPParam::DesValue() const
    {
    return *iDesValue;
    }

// -----------------------------------------------------------------------------
// CSIPParam::SetValueL
// -----------------------------------------------------------------------------
//	
void CSIPParam::SetValueL(const TDesC8& aValue, TBool aAddQuotesWhenEncoding)
    {
	HBufC8* tmp = aValue.AllocLC();
	if (!aAddQuotesWhenEncoding)
	    {
	    tmp->Des().Trim();
	    }
	RStringF tmpStr = SIPStrings::Pool().OpenFStringL(*tmp);
	CleanupStack::Pop(tmp);
    iValue.Close();
    iValue = tmpStr;
    iHasValue = ETrue;
    iAddQuotesWhenEncoding = aAddQuotesWhenEncoding;
    if (aAddQuotesWhenEncoding)
        {
        delete iDesValue;
        iDesValue = tmp;
        tmp = NULL;
        }
 	delete tmp;
    }

// -----------------------------------------------------------------------------
// CSIPParam::operator==
// -----------------------------------------------------------------------------
//
TBool CSIPParam::operator==(const CSIPParam& aSIPParam) const
	{
	if (aSIPParam.HasValue() != HasValue()) 
		{
		return EFalse;
		}
	if (iName != aSIPParam.Name()) 
		{
		return EFalse;
		}
	if (HasValue() && iValue != aSIPParam.Value()) 
		{
		return EFalse;
		}
	return ETrue;
	}

// -----------------------------------------------------------------------------
// CSIPParam::ToTextLC
// -----------------------------------------------------------------------------
//
HBufC8* CSIPParam::ToTextLC () const
	{
	TPtrC8 name = iName.DesC();
	TPtrC8 value = iValue.DesC();
	TUint length = name.Length();
	if (HasValue())
		{
		length += 1; // '='
		if (iAddQuotesWhenEncoding)
		    {
		    const TInt KQuotesLength = 2;
		    length += KQuotesLength;
		    length += iDesValue->Length();
		    }
		else
		    {
		    length += value.Length();
		    }
		}
	HBufC8* result = HBufC8::NewLC(length);
	TPtr8 resultPtr(result->Des());
	resultPtr.Append(name);
	if (HasValue())
		{
		resultPtr.Append('=');
		if (iAddQuotesWhenEncoding)
		    {
		    resultPtr.Append('"');
		    resultPtr.Append(*iDesValue);
		    resultPtr.Append('"');
		    }
		else
		    {
		    resultPtr.Append(value);
		    }		
		}
	return result;
	}

// -----------------------------------------------------------------------------
// CSIPParam::InternalizeL
// -----------------------------------------------------------------------------
//
CSIPParam* CSIPParam::InternalizeL (RReadStream& aReadStream)
	{
	CSIPParam* self = new(ELeave)CSIPParam;
	CleanupStack::PushL(self);
	self->DoInternalizeL(aReadStream);
	CleanupStack::Pop(self);
	return self;
	}

// -----------------------------------------------------------------------------
// CSIPParam::ExternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParam::ExternalizeL(RWriteStream& aWriteStream) const
	{
	TPtrC8 name(iName.DesC());
	aWriteStream.WriteUint32L(name.Length());
	aWriteStream.WriteL(name);
	TPtrC8 value(iValue.DesC());
	aWriteStream.WriteUint32L(value.Length());
	if (value.Length() > 0)
		{
		aWriteStream.WriteL(value);
		}
    aWriteStream.WriteUint8L(iHasValue);
    aWriteStream.WriteUint8L(iAddQuotesWhenEncoding);
    TInt desValueLength = iDesValue->Length();
    aWriteStream.WriteUint32L(desValueLength);
    if (desValueLength > 0)
        {
        aWriteStream.WriteL(*iDesValue);
        }
	}

// -----------------------------------------------------------------------------
// CSIPParam::DoInternalizeL
// -----------------------------------------------------------------------------
//
void CSIPParam::DoInternalizeL(RReadStream& aReadStream)
	{
	TUint32 nameLength = aReadStream.ReadUint32L();
	HBufC8* name = HBufC8::NewLC(nameLength);
	TPtr8 namePtr(name->Des());
	aReadStream.ReadL(namePtr, nameLength);
	iName = SIPStrings::Pool().OpenFStringL(namePtr);
	CleanupStack::PopAndDestroy(name);
	
	TUint32 valueLength = aReadStream.ReadUint32L();
	HBufC8* value = HBufC8::NewLC(valueLength);
	if (valueLength > 0)
		{
		TPtr8 valuePtr(value->Des());
		aReadStream.ReadL(valuePtr, valueLength);
		iValue = SIPStrings::Pool().OpenFStringL(valuePtr);
		}
	CleanupStack::PopAndDestroy(value);
	iHasValue = (aReadStream.ReadUint8L() != 0);
	iAddQuotesWhenEncoding = (aReadStream.ReadUint8L() != 0);
	TUint32 desValueLength = aReadStream.ReadUint32L();
	iDesValue = HBufC8::NewL(desValueLength);
	if (desValueLength > 0)
	    {
		TPtr8 desValuePtr(iDesValue->Des());
		aReadStream.ReadL(desValuePtr, desValueLength);
	    }
	}
	
// -----------------------------------------------------------------------------
// CSIPParam::SetL
// -----------------------------------------------------------------------------
//	
void CSIPParam::SetL(RStringF& aString, const TDesC8& aDes, TBool aCheckLength)
	{
	HBufC8* tmp = aDes.AllocLC();
	tmp->Des().Trim();
	if (aCheckLength && tmp->Length() == 0)
	    {
	    User::Leave(KErrSipCodecAnyParam);
	    }
	aString = SIPStrings::Pool().OpenFStringL(*tmp);
	CleanupStack::PopAndDestroy(tmp);	
	}