// Copyright (c) 1999-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:
// This file implements the different PDU elements
// 
//

/**
 @file
*/

#include <gsmuelem.h>
#include <gsmumsg.h>
#include "Gsmumain.h"
#include <gsmusar.h>
#include "gsmupriv.h"
#include <s32strm.h>
#include <etelmm.h>
#include <gsmuetel.h>
#include <exterror.h>
#include <emsinformationelement.h>
#include <emsformatie.h>
#include <charconv.h>

/**
 *  Question Mark character.
 */
const TInt  KReplacementCharacter = 0x003f;


/**
 *  Constructs the object with a descriptor. The extraction mark and next character members are initialised to point to the start of the string.
 *  
 *  @param aSource Descriptor to be assigned by reference
 */
TGsmuLex8::TGsmuLex8(const TDesC8& aSource): TLex8(aSource)
	{
	//NOP
	} // TGsmuLex8::TGsmuLex8


/**
 *  Gets the next character in the string and increments the next character position.
 *  
 *  @return The next character in the string
 *  @leave Leaves with KErrGsmuDecoding if at end of string
 */
TUint8 TGsmuLex8::GetL()
	{
	if (Eos())
		LeaveL();

	return static_cast<TUint8>(Get());
	} // TGsmuLex8::GetL


/**
 *  Increments the next character position by aNumber
 *  
 *  @param aNumber The number of characters to increment the next character position by.
 *  @leave If the increment puts the next character position before the start or beyond the end of the string, the function leaves with KErrGsmuDecoding.
 */
void TGsmuLex8::IncL(TInt aNumber)
	{
	if (aNumber != 0)
		{
		if (aNumber < 0 || Eos() || Remainder().Length() < aNumber)
			LeaveL();
		else
			Inc(aNumber);
		}
	} // TGsmuLex8::IncL


/**
 *  Checks there are enough remaining characters, then returns a TPtrC containing the next aLength characters. Does not increment the current position.
 *  
 *  @param aLength Number of characters to return
 *  @return Remainder().Left(aLength)
 *  @leave Leaves with KErrGsmuDecoding if there are insufficient characters remaining
 */
TPtrC8 TGsmuLex8::NextWithNoIncL(TInt aLength) const
	{
	return NextWithNoIncL(aLength, EFalse);
	}

/**
 * Checks there are enough remaining characters, then returns a TPtrC containing the next aLength characters. Does not increment the current position.
 *
 * @param aLength Number of characters to return
 * @param aAcceptTruncation ETrue if a mismatch between length indicator and actual length is acceptable. EFalse otherwise.
 * @return Remainder().Left(aLength) if aAcceptTruncation is EFalse. Remainder() otherwise.
 * @leave Leaves with KErrGsmuDecoding if there are insufficient characters remaining, unless aAcceptTruncation is ETrue.
 */
TPtrC8 TGsmuLex8::NextWithNoIncL(TInt aLength, TBool aAcceptTruncation) const
	{
	const TPtrC8 remainder(Remainder());

	if ( (aLength < 0) || (remainder.Length()< aLength && !aAcceptTruncation) )
		{
		LeaveL();
		}
	
  if (!aAcceptTruncation)
		{
		return Remainder().Left(aLength);
		}
	// aAcceptTruncation is ETrue
	else if (remainder.Length() < aLength)
		{
		return Remainder();
		}
	// otherwise, no need for truncation:
  
	return Remainder().Left(aLength);
	}


/**
 *  Calls TGsmuLeax8::NextWithNoIncL then increments the next character position by aLength
 *  
 *  @param aLength Number of characters to return and increment the next character position
 *  @return Remainder().Left(aLength)
 *  @leave If the increment puts the next character position before the start or beyond the end of the string, the function leaves with KErrGsmuDecoding.
 */
TPtrC8 TGsmuLex8::NextAndIncL(TInt aLength)
	{
	const TPtrC8 next(NextWithNoIncL(aLength));
	IncL(aLength);
	return next;
	} // TGsmuLeax8::NextWithNoIncL


const TSmsOctet& TSmsOctet::operator = (TInt aValue)
	{
	iValue = static_cast<TUint8>(aValue);
	return *this;
	} // TSmsOctet::operator


TUint8* TSmsOctet::EncodeL(TUint8* aPtr) const
	{
	*aPtr=iValue;
	return aPtr+1;
	} // TSmsOctet::EncodeL


TSmsFirstOctet::TSmsFirstOctet(TInt aValue):
	TSmsOctet(aValue)
	{
	} // TSmsFirstOctet::TSmsFirstOctet


const TSmsFirstOctet& TSmsFirstOctet::operator = (TInt aValue)
	{
	TSmsOctet::operator = (aValue);
	return *this;
	} // TSmsFirstOctet::operator


TSmsFailureCause::TSmsFailureCause():
	TSmsOctet(ESmsErrorUnspecified)
	{
	} // TSmsFailureCause::TSmsFailureCause


TSmsStatus::TSmsStatus():
	TSmsOctet(ESmsShortMessageReceivedBySME)
	{
	} // TSmsStatus::TSmsStatus


CSmsCommandData* CSmsCommandData::NewL(TSmsFirstOctet& aFirstOctet)
	{
	LOGGSMU1("CSmsCommandData::NewL()");

	CSmsCommandData* commanddata=new(ELeave) CSmsCommandData(aFirstOctet);
	CleanupStack::PushL(commanddata);
	TPtrC8 ptr;
	commanddata->SetDataL(ptr);
	CleanupStack::Pop();
	return commanddata;
	} // CSmsCommandData::NewL


CSmsCommandData::~CSmsCommandData()
	{
	iInformationElementArray.ResetAndDestroy();
	delete iBuffer;
	} // CSmsCommandData::NewL


/**
 *  Duplicates this CSmsCommandData object.
 * 
 *  @return  Pointer to the newly created CSmsCommandData object.
 */
CSmsCommandData* CSmsCommandData::DuplicateL() const
	{
	LOGGSMU1("CSmsCommandData::DuplicateL()");

	CSmsCommandData*  smsCommandData = CSmsCommandData::NewL(iFirstOctet);
	CleanupStack::PushL(smsCommandData);

	smsCommandData->SetDataL(Data());

	for (TInt ie = 0;  ie < iInformationElementArray.Count();  ie++)
		{
		smsCommandData->AddInformationElementL(iInformationElementArray[ie]->Identifier(),
											   iInformationElementArray[ie]->Data());
		}

	CleanupStack::Pop(smsCommandData);

	return smsCommandData;
	} // CSmsCommandData::DuplicateL


CSmsInformationElement& CSmsCommandData::InformationElement(TInt aIndex) const
	{
	LOGGSMU1("CSmsCommandData::InformationElement()");

	CSmsInformationElement* ie=iInformationElementArray[aIndex];
	return *ie;
	} // CSmsCommandData::InformationElement


CSmsInformationElement*& CSmsCommandData::InformationElementPtr(TInt aIndex)
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    LOGGSMU1("CSmsCommandData::InformationElementPtr()");
    return iInformationElementArray[aIndex];
    BULLSEYE_RESTORE
    }

TBool CSmsCommandData::InformationElementIndex(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier,
		TInt& aIndex) const
	{
	LOGGSMU1("CSmsCommandData::InformationElementIndex()");

	TBool found=EFalse;
	TInt count=NumInformationElements();
	for (TInt i=0; (!found) && (i<count); i++)
		if (InformationElement(i).Identifier()==aIdentifier)
			{
			found=ETrue;
			aIndex=i;
			}
	return found;
	} // CSmsCommandData::InformationElementIndex


void CSmsCommandData::AddInformationElementL(const TSmsId aIdentifier,const TDesC8& aData)
	{
	LOGGSMU1("CSmsCommandData::AddInformationElementL()");

	//
	// Currently there is no restriction on how many instances of an information element can be
	// placed in the collection.
	// No restriction will be placed on the number of Special SMS Message Indications that can be
	// added in order to maintain FC.
	// (cf CSmsUserData::AddInformationElementL(const TSmsId aIdentifier,const TDesC8& aData);
	//
	CSmsInformationElement* informationelement=CSmsInformationElement::NewL(aIdentifier,aData);
	CleanupStack::PushL(informationelement);
	iInformationElementArray.AppendL(informationelement);
	CleanupStack::Pop();
	if (NumInformationElements()>=1)
		SetHeaderPresent(ETrue);
	} // CSmsCommandData::AddInformationElementL


void CSmsCommandData::RemoveInformationElement(TInt aIndex)
	{
	LOGGSMU1("CSmsCommandData::RemoveInformationElement()");
	// Since iInformationElementArray[aIndex] is removed from iInformationElementArray, no double free issue.
	// coverity[double_free]
	delete iInformationElementArray[aIndex];
	iInformationElementArray[aIndex] = NULL;
	iInformationElementArray.Delete(aIndex);

	if (NumInformationElements()==0)
		{
		SetHeaderPresent(EFalse);
		}
	} // CSmsCommandData::RemoveInformationElement


TPtrC8 CSmsCommandData::Data() const
	{
	LOGGSMU1("CSmsCommandData::Data()");

	TPtrC8 ptr;
	ptr.Set(iBuffer->Des());
	return ptr;
	} // CSmsCommandData::Data


void CSmsCommandData::SetDataL(const TDesC8& aData)
	{
	LOGGSMU1("CSmsCommandData::SetDataL()");

	TInt length=aData.Length();
	__ASSERT_DEBUG(length<=KSmsMaxDataSize,Panic(KGsmuPanicCommandDataLengthTooLong));
	HBufC8* buffer=HBufC8::NewL(length);
	delete iBuffer;
	iBuffer=buffer;
	iBuffer->Des().SetLength(length);
	iBuffer->Des().Copy(aData);
	} // CSmsCommandData::SetDataL


TUint8* CSmsCommandData::EncodeL(TUint8* aPtr) const
	{
	LOGGSMU1("CSmsCommandData::EncodeL()");

	__ASSERT_DEBUG(iBuffer->Length()<=MaxDataLength(),Panic(KGsmuPanicCommandDataBufferTooLong));
	TSmsOctet datalength=iBuffer->Length()+TSmsOctet(TotalHeaderLengthInUDLUnits());
	aPtr=datalength.EncodeL(aPtr);
	TPtr8 ptr((TUint8*) aPtr,datalength);

    if (HeaderPresent())
        {
		TSmsOctet headerLength(HeaderLength());
		aPtr=headerLength.EncodeL(aPtr);
		for (TInt i=0; i<NumInformationElements(); i++)
		    {
			aPtr=iInformationElementArray[i]->EncodeL(aPtr);
		    }
        }

	ptr.Copy(iBuffer->Des());
	aPtr+=TInt(iBuffer->Length());
	return aPtr;
	} // CSmsCommandData::EncodeL


void CSmsCommandData::DecodeL(TGsmuLex8& aPdu)
	{
	LOGGSMU1("CSmsCommandData::DecodeL()");

	iInformationElementArray.ResetAndDestroy();
	const TBool headerPresent=HeaderPresent();
	TSmsOctet dataLength;
	dataLength.DecodeL(aPdu);

	if (headerPresent)
		{
		TSmsOctet headerLength;
		headerLength.DecodeL(aPdu);
		if ((1+headerLength)>KSmsMaxDataSize)
			User::Leave(KErrGsmSMSTpduNotSupported);
		while (HeaderLength()<headerLength)
			{
			CSmsInformationElement* informationElement=CSmsInformationElement::NewL();
			CleanupStack::PushL(informationElement);
			informationElement->DecodeL(aPdu);
			iInformationElementArray.AppendL(informationElement);
			CleanupStack::Pop(informationElement);
			}
		if (HeaderLength()!=headerLength)
			User::Leave(KErrGsmSMSTpduNotSupported);
		}
	const TInt totalHeaderLength=TotalHeaderLengthInUDLUnits();
	const TInt totalDataLength=dataLength-totalHeaderLength;
	const TPtrC8 next(aPdu.NextAndIncL(totalDataLength));
	SetDataL(next);
	} // CSmsCommandData::DecodeL


void CSmsCommandData::InternalizeL(RReadStream& aStream)
	{
	iInformationElementArray.ResetAndDestroy();
	TInt numInformationElements=aStream.ReadInt32L();
	for (TInt i=0; i<numInformationElements; i++)
		{
		CSmsInformationElement* informationElement=CSmsInformationElement::NewL();
		CleanupStack::PushL(informationElement);
		aStream >> *informationElement;
		iInformationElementArray.AppendL(informationElement);
		CleanupStack::Pop();
		}
	HBufC8* buffer=HBufC8::NewL(aStream,KSmsMaxDataSize);
	delete iBuffer;
	iBuffer=buffer;
	} // CSmsCommandData::InternalizeL


void CSmsCommandData::ExternalizeL(RWriteStream& aStream) const
	{
	TInt numInformationElements=iInformationElementArray.Count();
	aStream.WriteInt32L(numInformationElements);
	for (TInt i=0; i<numInformationElements; i++)
		aStream << *iInformationElementArray[i];
	aStream << *iBuffer;
	} // CSmsCommandData::ExternalizeL


CSmsCommandData::CSmsCommandData(TSmsFirstOctet& aFirstOctet):
	iFirstOctet(aFirstOctet),
	iInformationElementArray(8)
	{
	} // CSmsCommandData::CSmsCommandData


TInt CSmsCommandData::HeaderLength() const
	{
	LOGGSMU1("CSmsCommandData::HeaderLength()");

	TInt headerLength=0;
	for (TInt i=0; i<NumInformationElements(); i++)
		headerLength+=iInformationElementArray[i]->Length();
	return headerLength;
	} // CSmsCommandData::HeaderLength


TInt CSmsCommandData::TotalHeaderLengthInUDLUnits() const
	{
	LOGGSMU1("CSmsCommandData::TotalHeaderLengthInUDLUnits()");

	if (iInformationElementArray.Count()==0)
		return 0;
	else
		return (HeaderLength()+1);   // +1 stands for  UDHL
	} // CSmsCommandData::TotalHeaderLengthInUDLUnits


TBool CSmsCommandData::HeaderPresent() const
	{
	LOGGSMU1("CSmsCommandData::HeaderPresent()");

	return (iFirstOctet&TSmsFirstOctet::ESmsUDHIMask)==TSmsFirstOctet::ESmsUDHIHeaderPresent;
	} // CSmsCommandData::HeaderPresent


void CSmsCommandData::SetHeaderPresent(TBool aHeaderPresent)
	{
	LOGGSMU1("CSmsCommandData::SetHeaderPresent()");

	iFirstOctet=aHeaderPresent? (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderPresent: (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderNotPresent;
	} // CSmsCommandData::SetHeaderPresent


TSmsParameterIndicator::TSmsParameterIndicator():
	TSmsOctet(ESmsPIDProtocolIdentifierPresent|ESmsPIDUserDataPresent|ESmsPIDDataCodingSchemePresent)
	{
	} // TSmsParameterIndicator::TSmsParameterIndicator


TSmsCommandType::TSmsCommandType():
	TSmsOctet(ESmsCommandTypeEnquiry)
	{
	} // TSmsCommandType::TSmsCommandType


TSmsProtocolIdentifier::TSmsProtocolIdentifier():
	TSmsOctet((TInt)ESmsPIDTelematicInterworking|(TInt)ESmsNoTelematicDevice)
	{
	} // TSmsProtocolIdentifier::TSmsProtocolIdentifier


TSmsProtocolIdentifier::TSmsTelematicDeviceIndicator TSmsProtocolIdentifier::TelematicDeviceIndicator() const
	{
	__ASSERT_DEBUG(PIDType()==ESmsPIDTelematicInterworking,Panic(KGsmuPanicNoTelematicInterworking));
	return (TSmsTelematicDeviceIndicator) (iValue&EPIDTelematicDeviceIndicatorMask);
	} // TSmsProtocolIdentifier::TSmsTelematicDeviceIndicator


void TSmsProtocolIdentifier::SetTelematicDeviceIndicator(TSmsTelematicDeviceIndicator aIndicator)
	{
	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceIndicator()");

	__ASSERT_DEBUG(PIDType()==ESmsPIDTelematicInterworking,Panic(KGsmuPanicNoTelematicInterworking));

	//iValue=(TUint8) ((iValue&ESmsPIDTypeMask)|aIndicator);
	iValue=(TUint8) ((iValue&(~EPIDTelematicDeviceIndicatorMask))|aIndicator);
	} // TSmsProtocolIdentifier::SetTelematicDeviceIndicator


TSmsProtocolIdentifier::TSmsTelematicDeviceType TSmsProtocolIdentifier::TelematicDeviceType() const
	{
	__ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));
	return (TSmsTelematicDeviceType) (iValue&ESmsTelematicDeviceTypeMask);
	} // TSmsProtocolIdentifier::TSmsTelematicDeviceType


void TSmsProtocolIdentifier::SetTelematicDeviceType(TSmsTelematicDeviceType aDeviceType)
	{
	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceType()");

	__ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));
	iValue=(TUint8) ((iValue&(~ESmsTelematicDeviceTypeMask))|aDeviceType);
	} // TSmsProtocolIdentifier::SetTelematicDeviceType


TInt TSmsProtocolIdentifier::ShortMessageALProtocol() const
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    LOGGSMU1("TSmsProtocolIdentifier::ShortMessageALProtocol()");
    
    __ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsNoTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));
    return (TSmsShortMessageALProtocol) (iValue&ESmsShortMessageALProtocolMask);
    BULLSEYE_RESTORE
    }

void TSmsProtocolIdentifier::SetShortMessageALProtocol(TSmsShortMessageALProtocol aProtocol)
    {
    // Ignore in code coverage - not used in SMS stack and not exported
    // but cannot be removed as impacts public header.
    BULLSEYE_OFF    
    LOGGSMU1("TSmsProtocolIdentifier::SetShortMessageALProtocol()");
    
    __ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsNoTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));
    iValue=(TUint8) ((iValue&(~ESmsShortMessageALProtocolMask))|aProtocol);
    BULLSEYE_RESTORE
    }

TInt TSmsProtocolIdentifier::ShortMessageType() const
	{
	LOGGSMU1("TSmsProtocolIdentifier::ShortMessageType()");

	__ASSERT_DEBUG(PIDType()==ESmsPIDShortMessageType,Panic(KGsmuPanicNoShortMessageType));
	return (TSmsShortMessageType) (iValue&ESmsShortMessageTypeMask);
	} // TSmsProtocolIdentifier::ShortMessageType


void TSmsProtocolIdentifier::SetShortMessageType(TSmsShortMessageType aShortMessageType)
	{
	LOGGSMU1("TSmsProtocolIdentifier::SetShortMessageType()");

	__ASSERT_DEBUG(PIDType()==ESmsPIDShortMessageType,Panic(KGsmuPanicNoShortMessageType));
	//iValue=(TUint8) ((iValue&(~ESmsPIDTypeMask))|aShortMessageType);
	iValue=(TUint8) ((iValue&(~ESmsShortMessageTypeMask))|aShortMessageType);
	} // TSmsProtocolIdentifier::SetShortMessageType


TSmsDataCodingScheme::TSmsDataCodingScheme():
	TSmsOctet((TInt)ESmsDCSTextUncompressedWithNoClassInfo|(TInt)ESmsAlphabet7Bit|(TInt)ESmsClass0)
	// Constructor is expected to set the octet = 0, This is needed by
	// CSmsDeliverReport::DecodeL, CSmsSubmitReport::DecodeL and CSmsStatusReport::DecodeL, per
	// 23.040 v6.5.0 section 9.2.3.27.
	{
	} // CSmsDeliverReport::DecodeL


TBool TSmsDataCodingScheme::TextCompressed() const
	{
	LOGGSMU1("TSmsDataCodingScheme::TextCompressed()");

	TInt bits7to4=Bits7To4();
	return (bits7to4==ESmsDCSTextCompressedWithNoClassInfo)    || (bits7to4==ESmsDCSTextCompressedWithClassInfo)      ||
           (bits7to4==ESmsDCSAutoDelNoClassInfoCompressedText) || (bits7to4==ESmsDCSAutoDelClassInfoTextCompressedText);
	} // TSmsDataCodingScheme::TextCompressed


void TSmsDataCodingScheme::SetTextCompressed(TBool aCompressed)
	{
	LOGGSMU1("TSmsDataCodingScheme::SetTextCompressed()");

	TInt bits7to4=Bits7To4();
	if (aCompressed)
		{
		switch (bits7to4)
			{
			case (ESmsDCSTextUncompressedWithNoClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextCompressedWithNoClassInfo|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSAutoDelNoClassInfoUncompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelNoClassInfoCompressedText|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSAutoDelClassInfoUncompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelClassInfoTextCompressedText|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSTextUncompressedWithClassInfo):
			case (ESmsDCSTextUncompressed7BitOr8Bit):
				{
				iValue=(TUint8) (ESmsDCSTextCompressedWithClassInfo|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSTextCompressedWithNoClassInfo):
			case (ESmsDCSTextCompressedWithClassInfo):
			case (ESmsDCSAutoDelNoClassInfoCompressedText):
			case (ESmsDCSAutoDelClassInfoTextCompressedText):
				break;
			default:
                break;
                // has to be tested, what happens in this default case
				//Panic(KGsmuPanicNotSupportedWithDCSBits7To4);
			}
		}
	else
		{
		switch (bits7to4)
			{
			case (ESmsDCSTextCompressedWithNoClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextUncompressedWithNoClassInfo|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSTextCompressedWithClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextUncompressedWithClassInfo|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSAutoDelNoClassInfoCompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelNoClassInfoUncompressedText|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSAutoDelClassInfoTextCompressedText):
				{
				iValue=(TUint8) ( ESmsDCSAutoDelClassInfoUncompressedText|(iValue&(~ESmsDCSBits7To4Mask)));
				break;
				}
			case (ESmsDCSTextUncompressedWithNoClassInfo):
			case (ESmsDCSTextUncompressedWithClassInfo):
            case (ESmsDCSAutoDelClassInfoUncompressedText):
            case (ESmsDCSAutoDelNoClassInfoUncompressedText):
			case (ESmsDCSTextUncompressed7BitOr8Bit):
			default:
				{
				}
			}
		}
	} // TSmsDataCodingScheme::SetTextCompressed


TSmsDataCodingScheme::TSmsAlphabet TSmsDataCodingScheme::Alphabet() const
	{
	LOGGSMU1("TSmsDataCodingScheme::TSmsAlphabet()");

	TInt bits7to4=Bits7To4();
	TInt alphabet=ESmsAlphabet7Bit;
	switch (bits7to4)
		{
		case (ESmsDCSTextUncompressedWithNoClassInfo):
		case (ESmsDCSTextUncompressedWithClassInfo):
		case (ESmsDCSTextCompressedWithNoClassInfo):  //  Alphabet not used in these cases
		case (ESmsDCSTextCompressedWithClassInfo):
		case (ESmsDCSAutoDelNoClassInfoUncompressedText):
		case (ESmsDCSAutoDelClassInfoUncompressedText):
		case (ESmsDCSAutoDelNoClassInfoCompressedText):
		case (ESmsDCSAutoDelClassInfoTextCompressedText):
			{
			alphabet=iValue&ESmsAlphabetMask;
			break;
			}
		case (ESmsDCSTextUncompressed7BitOr8Bit):
			{
			alphabet=iValue&ESmsAlphabet8Bit;  //  N.B. only one bit used to code alphabet
			break;
			}
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
		case (ESmsDCSMessageWaitingIndication7Bit):
			{
			alphabet=ESmsAlphabet7Bit;
			break;
			}
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
			alphabet=ESmsAlphabetUCS2;
			break;
			}
		default:
		    LOGGSMU1("TSmsDataCodingScheme::Alphabet() WARNING! default case has been reached");
            break;
 		}
	return (TSmsAlphabet) alphabet;
	} // TSmsDataCodingScheme::TSmsAlphabet

void TSmsDataCodingScheme::SetAlphabet(TSmsAlphabet aAlphabet)
	{
	LOGGSMU1("TSmsDataCodingScheme::SetAlphabet()");

	TInt bits7to4=Bits7To4();
	switch (bits7to4)
		{
		case (ESmsDCSTextUncompressedWithNoClassInfo):
		case (ESmsDCSTextUncompressedWithClassInfo):
		case (ESmsDCSTextCompressedWithNoClassInfo):  //  Alphabet not used in these cases
		case (ESmsDCSTextCompressedWithClassInfo):
		case (ESmsDCSAutoDelNoClassInfoUncompressedText):
		case (ESmsDCSAutoDelClassInfoUncompressedText):
		case (ESmsDCSAutoDelNoClassInfoCompressedText):
		case (ESmsDCSAutoDelClassInfoTextCompressedText):
			{
			iValue=(TUint8) ((iValue&(~ESmsAlphabetMask))|aAlphabet);
			break;
			}
		case (ESmsDCSTextUncompressed7BitOr8Bit):
			{
			if ((aAlphabet==ESmsAlphabet7Bit) || (aAlphabet==ESmsAlphabet8Bit))
				{
				iValue=(TUint8) ((iValue&(~ESmsAlphabet8Bit))|aAlphabet);  //  N.B. only one bit used to code alphabet
				}
			break;
			}
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
			{
            if (aAlphabet!=ESmsAlphabet7Bit)
                {
                LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
                }
			break;
			}
		case (ESmsDCSMessageWaitingIndication7Bit):
			{
 			if (aAlphabet==ESmsAlphabetUCS2)
 			    {
				iValue=(TUint8) (ESmsDCSMessageWaitingIndicationUCS2|(iValue&(~ESmsDCSBits7To4Mask)));
 			    }
 			else 
                {
        		LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
			    }	     
			break;
			}
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
  			if (aAlphabet==ESmsAlphabet7Bit)
			    {
				iValue=(TUint8) (ESmsDCSMessageWaitingIndication7Bit|(iValue&(~ESmsDCSBits7To4Mask)));
			    }
			else 
			    {
				LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
			    }
			break;
			}
		default:
		    LOGGSMU1("TSmsDataCodingScheme::SetAlphabet() WARNING! default case has been reached");
            break;
      		}
	} // TSmsDataCodingScheme::SetAlphabet


TBool TSmsDataCodingScheme::Class(TSmsClass& aClass) const
	{
	LOGGSMU1("TSmsDataCodingScheme::Class()");

	switch (Bits7To4())
		{
		case (ESmsDCSTextUncompressedWithClassInfo):
		case (ESmsDCSTextCompressedWithClassInfo):
		case (ESmsDCSAutoDelClassInfoUncompressedText):
		case (ESmsDCSAutoDelClassInfoTextCompressedText):
		case (ESmsDCSTextUncompressed7BitOr8Bit):
			aClass=(TSmsClass) (iValue&ESmsClassMask);
			return ETrue;
		default:
			return EFalse;
		}
	} // TSmsDataCodingScheme::Class


void TSmsDataCodingScheme::SetClass(TBool aClassDefined,TSmsDataCodingScheme::TSmsClass aClass)
	{
	LOGGSMU1("TSmsDataCodingScheme::SetClass()");

	TInt bits7to4=Bits7To4();
	if (aClassDefined)
		{
		switch (bits7to4)
			{
			case (ESmsDCSTextUncompressedWithNoClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextUncompressedWithClassInfo|(iValue&ESmsAlphabetMask|aClass));
				break;
				}
			case (ESmsDCSTextCompressedWithNoClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextCompressedWithClassInfo|(iValue&ESmsAlphabetMask|aClass));
				break;
				}
			case (ESmsDCSAutoDelNoClassInfoUncompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelClassInfoUncompressedText|(iValue&ESmsAlphabetMask|aClass));
				break;
				}
			case (ESmsDCSAutoDelNoClassInfoCompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelClassInfoTextCompressedText|(iValue&ESmsAlphabetMask|aClass));
				break;
				}
			case (ESmsDCSTextUncompressedWithClassInfo):
			case (ESmsDCSTextCompressedWithClassInfo):
			case (ESmsDCSAutoDelClassInfoUncompressedText):
			case (ESmsDCSAutoDelClassInfoTextCompressedText):
			case (ESmsDCSTextUncompressed7BitOr8Bit):

				{
				iValue=(TUint8) (iValue&(~ESmsClassMask)|aClass);
				break;
				}
			default:
		        LOGGSMU1("WARNING! default case has been reached");
                break;
			}
		}
	else
		{
		switch (bits7to4)
			{
			case (ESmsDCSTextUncompressedWithClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextUncompressedWithNoClassInfo|(iValue&ESmsAlphabetMask)|aClass);
				break;
				}
			case (ESmsDCSTextCompressedWithClassInfo):
				{
				iValue=(TUint8) (ESmsDCSTextCompressedWithNoClassInfo|(iValue&ESmsAlphabetMask)|aClass);
				break;
				}
			case (ESmsDCSAutoDelClassInfoUncompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelNoClassInfoUncompressedText|(iValue&ESmsAlphabetMask)|aClass);
				break;
				}
			case (ESmsDCSAutoDelClassInfoTextCompressedText):
				{
				iValue=(TUint8) (ESmsDCSAutoDelNoClassInfoCompressedText|(iValue&ESmsAlphabetMask)|aClass);
				break;
				}
			case (ESmsDCSTextUncompressed7BitOr8Bit):
				{
				iValue=(TUint8) (ESmsDCSTextUncompressedWithNoClassInfo|(iValue&ESmsAlphabetMask)|aClass);
				break;
				}
			case (ESmsDCSTextUncompressedWithNoClassInfo):
			case (ESmsDCSTextCompressedWithNoClassInfo):
			case (ESmsDCSAutoDelNoClassInfoUncompressedText):
			case (ESmsDCSAutoDelNoClassInfoCompressedText):
			case (ESmsDCSMessageWaitingIndicationDiscardMessage):
			case (ESmsDCSMessageWaitingIndication7Bit):
			case (ESmsDCSMessageWaitingIndicationUCS2):
			default:
				{
				}
			}
		}
	} // TSmsDataCodingScheme::SetClass


TSmsDataCodingScheme::TSmsIndicationState TSmsDataCodingScheme::IndicationState() const
	{
	LOGGSMU1("TSmsDataCodingScheme::IndicationState()");

	TInt bits7to4=Bits7To4();
	TSmsIndicationState state=ESmsIndicationInactive;
	switch (bits7to4)
		{
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
		case (ESmsDCSMessageWaitingIndication7Bit):
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
			state=(TSmsIndicationState) (iValue&ESmsIndicationStateMask);
			break;
			}
		default:
		    LOGGSMU1("WARNING! default case has been reached");
            break;
  		}
	return state;
	} // TSmsDataCodingScheme::TSmsIndicationState


void TSmsDataCodingScheme::SetIndicationState(TSmsIndicationState aState)
	{
	LOGGSMU1("TSmsDataCodingScheme::SetIndicationState()");

	TInt bits7to4=Bits7To4();
	switch (bits7to4)
		{
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
		case (ESmsDCSMessageWaitingIndication7Bit):
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
			iValue=(TUint8) (aState | (iValue&(~ESmsIndicationStateMask)));
			break;
			}
		default:
		    LOGGSMU1("TSmsDataCodingScheme::SetIndicationState() WARNING! default case has been reached");
            break;
  		}
	} // TSmsDataCodingScheme::SetIndicationState


TSmsDataCodingScheme::TSmsIndicationType TSmsDataCodingScheme::IndicationType() const
	{
	LOGGSMU1("TSmsDataCodingScheme::IndicationType()");

	TInt bits7to4=Bits7To4();
	TSmsIndicationType type=ESmsVoicemailMessageWaiting;
	switch (bits7to4)
		{
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
		case (ESmsDCSMessageWaitingIndication7Bit):
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
			type=(TSmsIndicationType) (iValue&ESmsIndicationTypeMask);
			break;
			}
		default:
		    LOGGSMU1("TSmsDataCodingScheme::IndicationType() WARNING default case has been reached");
            break;
		}
	return type;
	} // TSmsDataCodingScheme::TSmsIndicationType


void TSmsDataCodingScheme::SetIndicationType(TSmsIndicationType aType)
	{
	LOGGSMU1("TSmsDataCodingScheme::SetIndicationType()");

	TInt bits7to4=Bits7To4();
	switch (bits7to4)
		{
		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
		case (ESmsDCSMessageWaitingIndication7Bit):
		case (ESmsDCSMessageWaitingIndicationUCS2):
			{
			iValue=(TUint8) (aType | (iValue&(~ESmsIndicationTypeMask)));
			break;
			}
		default:
		    LOGGSMU1("TSmsDataCodingScheme::SetIndicationType() WARNING! default case has been reached");
            break;
 		}
	} // TSmsDataCodingScheme::SetIndicationType


/**
 *  Allocates and creates a CSmsAlphabetConverter object, specifying an Alphabet
 *  Coding scheme and a Binary flag.
 *  
 *  @param aCharacterSetConverter Pre-initialised character set converter
 *  @param aFs File system handle
 *  @param aSmsAlphabet Data coding scheme alphabet
 *  @param aIsBinary Set to true for WAP or compressed data
 *  @return New CSmsAlphabetConverter object
 *  @capability None
 */
EXPORT_C CSmsAlphabetConverter* CSmsAlphabetConverter::NewLC(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsDataCodingScheme::TSmsAlphabet aSmsAlphabet,TBool aIsBinary)
	{
	LOGGSMU1("CSmsAlphabetConverter::NewLC()");

	CSmsAlphabetConverter* converter=new (ELeave)CSmsAlphabetConverter(aCharacterSetConverter,aFs,aSmsAlphabet,aIsBinary);
	CleanupStack::PushL(converter);
	converter->ConstructL();
	return converter;
	} // CSmsAlphabetConverter::NewLC


/**
 *  Destructor.
 *  @capability None
 */
EXPORT_C CSmsAlphabetConverter::~CSmsAlphabetConverter()
    {
    delete iConvertedNativeCharacters;
    delete iConvertedUDElements;
    delete iUnconvertedNativeCharacters;
    delete iUnconvertedUDElements;
    } // CSmsAlphabetConverter::NewLC


//
// C'tor - standard stuff
//
CSmsAlphabetConverter::CSmsAlphabetConverter(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsDataCodingScheme::TSmsAlphabet aSmsAlphabet,TBool aIsBinary)
    : iCharacterSetConverter(aCharacterSetConverter),
    iFs(aFs),
    iSmsAlphabet(aSmsAlphabet),
    iIsBinary(aIsBinary),
    iUnconvertedNativeCharactersPtr(NULL,0),
    iUnconvertedUDElementsPtr(NULL,0)
    {
    } // CSmsAlphabetConverter::CSmsAlphabetConverter


//
// Ensures this is a supported character set if not binary conversion
//
void CSmsAlphabetConverter::ConstructL()
	{
	LOGGSMU1("CSmsAlphabetConverter::ConstructL()");


	if (!iIsBinary)
		{
		switch (iSmsAlphabet)
			{
			case TSmsDataCodingScheme::ESmsAlphabet7Bit:
			case TSmsDataCodingScheme::ESmsAlphabet8Bit:
			case TSmsDataCodingScheme::ESmsAlphabetUCS2:
				{
				// Supported
				break;
				}
			default:
				{
				// Not supported
				User::Leave(KErrGsmSMSDataCodingSchemeNotSupported);
				break;
				}
			}
		}
	} // CSmsAlphabetConverter::ConstructL


//
// Returns whether the character set converter is invoked.  Provided to allow
// clients to provided efficient converted length calculation where no
// conversion is required.
//
void CSmsAlphabetConverter::ConversionPropertiesL(TSmsAlphabetConversionProperties& aConversionProperties) const
	{
	LOGGSMU1("CSmsAlphabetConverter::ConversionPropertiesL()");


	// Set defaults
	aConversionProperties.iWidthConversion=ESmsAlphabetWidthConversionFixed;
	aConversionProperties.iUDElementsPerNativeCharacter=1;
	// Modify if different
	if (iIsBinary)
		return;
	switch (iSmsAlphabet)
		{
		case TSmsDataCodingScheme::ESmsAlphabet7Bit:
		case TSmsDataCodingScheme::ESmsAlphabet8Bit:
			{
			aConversionProperties.iWidthConversion=ESmsAlphabetWidthConversionVariable;
			break;
			}
		case TSmsDataCodingScheme::ESmsAlphabetUCS2:
			{
			aConversionProperties.iUDElementsPerNativeCharacter=sizeof(TText);
			break;
			}
		default:
			{
			User::Leave(KErrGsmSMSDataCodingSchemeNotSupported);
			}
		}
	} // CSmsAlphabetConverter::ConversionPropertiesL


/**
 *  Converts from the native character set to unpacked user data elements of the
 *  desired character set.
 *  
 *  The function stores the converted data internally.
 *  
 *  @param aNativeCharacters The native character set data (Unicode only)
 *  @return Converted characters
 *  @capability None
 */
EXPORT_C TPtrC8 CSmsAlphabetConverter::ConvertFromNativeL(const TDesC& aNativeCharacters)
	{
	LOGGSMU1("CSmsAlphabetConverter::ConvertFromNativeL()");

	TInt  numberOfUnconvertibleCharacters, numberOfDowngradedCharacters;

	return ConvertFromNativeL(aNativeCharacters, ESmsEncodingNone,
			                  numberOfUnconvertibleCharacters,
			                  numberOfDowngradedCharacters);
	} // CSmsAlphabetConverter::ConvertFromNativeL


/**
 *  Converts from the native character set to unpacked user data elements of the
 *  desired character set.
 *  
 *  The function stores the converted data internally.
 *  
 *  @param aNativeCharacters                 The native character set data (Unicode only)
 *  @param aNumberOfUnconvertibleCharacters  Number of characters unconverted
 *  @param aNumberOfDowngradedCharacters     Number of characters downgraded
 *  @param aEncoding                         Alternative 7bit encoding to used (if needed)
 * 
 *  @return Converted characters
 * 
 *  @capability None
 */
EXPORT_C TPtrC8 CSmsAlphabetConverter::ConvertFromNativeL(const TDesC& aNativeCharacters,
                                                          TSmsEncoding aEncoding,
                                                          TInt& aNumberOfUnconvertibleCharacters,
			                                              TInt& aNumberOfDowngradedCharacters)
	{
	LOGGSMU2("CSmsAlphabetConverter::ConvertFromNativeL(): aEncoding=%d", aEncoding);
	
	aNumberOfUnconvertibleCharacters = 0;
	aNumberOfDowngradedCharacters    = 0;

	// Check for some shortcuts
	if (iIsBinary ||  iSmsAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit)
		{
		// Binary data stored as padded unicode
		TPtr8 outputPtr=CheckAllocBufferL(&iConvertedUDElements,aNativeCharacters.Length(),0);
		outputPtr.Copy(aNativeCharacters);
		iUnconvertedNativeCharactersPtr.Zero();
		return outputPtr;
		}
	else if (iSmsAlphabet==TSmsDataCodingScheme::ESmsAlphabetUCS2)
		{
		TInt nativeCharactersLength = aNativeCharacters.Length();
		// 16-bit copy with possible endianess correction
		TInt elementCount=nativeCharactersLength*2;
		TPtr8 outputPtr(CheckAllocBufferL(&iConvertedUDElements,elementCount,elementCount));
	    for (TInt i=0;i<nativeCharactersLength;i++)
		    {
		    outputPtr[2*i]=(TUint8)(aNativeCharacters[i]>>8);
		    outputPtr[2*i+1]=(TUint8)aNativeCharacters[i];
		    }
		iUnconvertedNativeCharactersPtr.Zero();
		return outputPtr;
		}
	else // No shortcuts, do proper conversion
		{
		PrepareForConversionFromNativeL(aEncoding);
		
		// Create input buffer
		TInt newInputLength=iUnconvertedNativeCharactersPtr.Length()+aNativeCharacters.Length();
		iUnconvertedNativeCharactersPtr.Set(CheckAllocBufferL(&iUnconvertedNativeCharacters,newInputLength,iUnconvertedNativeCharactersPtr.Length()));
		iUnconvertedNativeCharactersPtr.Append(aNativeCharacters);

		// Ensure buffer is at least the length of the input buffer
		TPtr8 outputPtr=CheckAllocBufferL(&iConvertedUDElements,iUnconvertedNativeCharactersPtr.Length(),0);

		TInt retryCount=0;
		TInt unconvertedCount=iUnconvertedNativeCharactersPtr.Length();
		while (unconvertedCount)
			{
			TInt  tempNumberOfUnconvertibleCharacters = 0;
			TInt  tempNumberOfDowngradedCharacters    = 0;
			
			// Get a pointer to unfilled area of output buffer
			TPtr8 fillPtr((TUint8*)outputPtr.Ptr()+outputPtr.Length(),0,outputPtr.MaxLength()-outputPtr.Length());
			// Try the conversion & get number of unconverted characters
			TInt newUnconvertedCount=iCharacterSetConverter.ConvertFromUnicode(fillPtr,iUnconvertedNativeCharactersPtr);
			if (newUnconvertedCount<0)
				break;

			// Compare what is converted with the original, to get downgrade count
			TPtr  tempBufPtr((TUint16*)iUnconvertedNativeCharactersPtr.Ptr(), 0, fillPtr.Length());
			TInt  offset      = aNativeCharacters.Length() - unconvertedCount;
			TInt  state       = CCnvCharacterSetConverter::KStateDefault;
			TInt  notRestored = iCharacterSetConverter.ConvertToUnicode(tempBufPtr, fillPtr, state);
			
			if (notRestored > 0)
				{
				tempNumberOfUnconvertibleCharacters += notRestored;
				}
			
			for (TInt pos = 0;  pos < tempBufPtr.Length();  pos++)
				{
				if (tempBufPtr[pos] != aNativeCharacters[offset + pos])
					{
					if (tempBufPtr[pos] != KReplacementCharacter)
						{
						tempNumberOfDowngradedCharacters++;
						}
					else
						{
						tempNumberOfUnconvertibleCharacters++;
						}
					}
				}

			//
			// If characters were downgraded or unconverted then replace them
			// with downgrades from the PREQ2090 converter.
			//
			if (tempNumberOfUnconvertibleCharacters > 0  &&
				aEncoding != ESmsEncodingNone)
				{
				HBufC8*  downgradesBuf = HBufC8::NewLC(iUnconvertedNativeCharactersPtr.Length());
				HBufC*  nativeBuf = HBufC::NewLC(iUnconvertedNativeCharactersPtr.Length());
				TPtr8  downgradesPtr = downgradesBuf->Des();
				TPtr  nativePtr = nativeBuf->Des();

				PrepareForConversionFromNativeL(ESmsEncodingNone);

				// Attempt to convert the text
	 			TInt ret = iCharacterSetConverter.ConvertFromUnicode(downgradesPtr, iUnconvertedNativeCharactersPtr);
		 		if (ret >= 0)
		 			{
					// Compare what is converted with the original...
					state       = CCnvCharacterSetConverter::KStateDefault;
					notRestored = iCharacterSetConverter.ConvertToUnicode(nativePtr, downgradesPtr, state);
						
					if (notRestored >= 0)
						{
						// Merge in the downgrades
						TInt  pos;
						
						for (pos = 0;  pos < tempBufPtr.Length();  pos++)
							{
							if (tempBufPtr[pos] != aNativeCharacters[offset + pos])
								{
								if (tempBufPtr[pos] != KReplacementCharacter)
									{
									tempBufPtr[pos] = nativePtr[pos];
									}
								}
							}

						// Reconvert...
						PrepareForConversionFromNativeL(aEncoding);

						newUnconvertedCount=iCharacterSetConverter.ConvertFromUnicode(fillPtr,iUnconvertedNativeCharactersPtr);
						if (newUnconvertedCount<0)
							break;

						// Recount the changed characters...
						tempNumberOfUnconvertibleCharacters = 0;
						tempNumberOfDowngradedCharacters    = 0;

						for (pos = 0;  pos < tempBufPtr.Length();  pos++)
							{
							if (tempBufPtr[pos] != aNativeCharacters[offset + pos])
								{
								if (tempBufPtr[pos] != KReplacementCharacter)
									{
									tempNumberOfDowngradedCharacters++;
									}
								else
									{
									tempNumberOfUnconvertibleCharacters++;
									}
								}
							}
		 				}
					}
				
				CleanupStack::PopAndDestroy(2, downgradesBuf);
				}

			//
			// Store these downgraded/unconvertible character counts...
			//
			aNumberOfDowngradedCharacters    += tempNumberOfDowngradedCharacters;
			aNumberOfUnconvertibleCharacters += tempNumberOfUnconvertibleCharacters;
			
			// Update original buffer length, check retry count and realloc if req'd
			outputPtr.SetLength(outputPtr.Length()+fillPtr.Length());
			if (newUnconvertedCount==unconvertedCount)
				{
				if (++retryCount>KMaxSmsAlphabetConversionRetries)
					{
					__ASSERT_DEBUG(EFalse,Panic(KGsmuPanicConversionRetriedOut));
					break;
					}
				}
			else
				{
				iUnconvertedNativeCharactersPtr.Delete(0,unconvertedCount-newUnconvertedCount);
				retryCount=0;
				}
			unconvertedCount=newUnconvertedCount;
			// Check for realloc
			if (unconvertedCount)
				outputPtr.Set(CheckAllocBufferL(&iConvertedUDElements,iConvertedUDElements->Length()+Max(unconvertedCount,KMinSmsAlphabetConversionAllocIncrement),outputPtr.Length()));
			}

		return outputPtr;
		}
	} // CSmsAlphabetConverter::ConvertFromNativeL


/**
 *  Converts the user data elements of the specified character set to the native
 *  character set.
 *  
 *  @param aUDElements The converted character set data
 * 
 *  @return Native character set data (Unicode only)
 * 
 *  @capability None
 */
EXPORT_C TPtrC CSmsAlphabetConverter::ConvertToNativeL(const TDesC8& aUDElements)
	{
	LOGGSMU1("CSmsAlphabetConverter::ConvertToNativeL()");

	return ConvertToNativeL(aUDElements, ESmsEncodingNone);
	} // CSmsAlphabetConverter::ConvertToNativeL


/**
 *  Converts the user data elements of the specified character set to the native
 *  character set.
 *  
 *  @param aUDElements The converted character set data
 *  @param aEncoding   Alternative 7bit encoding to used (if needed)
 * 
 *  @return Native character set data (Unicode only)
 * 
 *  @capability None
 */
EXPORT_C TPtrC CSmsAlphabetConverter::ConvertToNativeL(const TDesC8& aUDElements,
													   TSmsEncoding aEncoding)
	{
	LOGGSMU2("CSmsAlphabetConverter::ConvertToNativeL(): aEncoding=%d", aEncoding);

	// Check for some shortcuts
	if (iIsBinary ||  iSmsAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit)
		{
		// Binary data stored as padded unicode
		TPtr16 outputPtr=CheckAllocBufferL(&iConvertedNativeCharacters,aUDElements.Length(),0);
		outputPtr.Copy(aUDElements);
		iUnconvertedUDElementsPtr.Zero();
		return outputPtr;
		}
	else if (iSmsAlphabet==TSmsDataCodingScheme::ESmsAlphabetUCS2)
		{
		// 16-bit copy with possible endianess correction
		TInt charCount=aUDElements.Length()/2;
		TPtr16 outputPtr=CheckAllocBufferL(&iConvertedNativeCharacters,charCount,charCount);
	    for (TInt i=0; i<charCount; i++)
		    {
		    outputPtr[i]=(TText)(aUDElements[2*i]<<8);
		    outputPtr[i]=(TText)(outputPtr[i]+(aUDElements[2*i+1]));
		    }
		iUnconvertedUDElementsPtr.Zero();
		return outputPtr;
		}
	else
		{
		PrepareForConversionToNativeL(aEncoding);

		// Create input buffer with unconverted characters prepended
		TInt newInputLength=iUnconvertedUDElementsPtr.Length()+aUDElements.Length();
		iUnconvertedUDElementsPtr.Set(CheckAllocBufferL(&iUnconvertedUDElements,newInputLength,iUnconvertedUDElementsPtr.Length()));
		iUnconvertedUDElementsPtr.Append(aUDElements);

		// Ensure buffer is at least the length of the input buffer
		TPtr outputPtr=CheckAllocBufferL(&iConvertedNativeCharacters,iUnconvertedUDElementsPtr.Length(),0);

		TInt retryCount=0;
		TInt unconvertedCount=iUnconvertedUDElementsPtr.Length();
		TInt state=CCnvCharacterSetConverter::KStateDefault;
		while (unconvertedCount)
			{
			// Get a pointer to unfilled area of output buffer
			TPtr16 fillPtr((TUint16*)outputPtr.Ptr()+outputPtr.Length(),0,outputPtr.MaxLength()-outputPtr.Length());
			// Try the conversion & get number of unconverted characters
			TInt newUnconvertedCount=iCharacterSetConverter.ConvertToUnicode(fillPtr,iUnconvertedUDElementsPtr,state);
			if (newUnconvertedCount<0)
				break;
			// Update original buffer length & check retry count
			outputPtr.SetLength(outputPtr.Length()+fillPtr.Length());
			if (newUnconvertedCount==unconvertedCount)
				{
				if (++retryCount>KMaxSmsAlphabetConversionRetries)
					{
					__ASSERT_DEBUG(EFalse,Panic(KGsmuPanicConversionRetriedOut));
					break;
					}
				}
			else
				{
				iUnconvertedUDElementsPtr.Delete(0,unconvertedCount-newUnconvertedCount);
				retryCount=0;
				}
			unconvertedCount=newUnconvertedCount;
			// Check for realloc
			if (unconvertedCount)
				outputPtr.Set(CheckAllocBufferL(&iConvertedNativeCharacters,iConvertedNativeCharacters->Length()+Max(unconvertedCount,KMinSmsAlphabetConversionAllocIncrement),outputPtr.Length()));
			}
		return outputPtr;
		}
	} // CSmsAlphabetConverter::ConvertToNativeL


/**
 *  Tests if the character is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aChar  Character to investigate.
 * 
 *  @return  ETrue if the character is supported.
 * 
 *  @note Since the function is based on the old behaviour (pre-PREQ2090)
 *        it does not accept a downgraded character or alternative encoding
 *        as being supported.
 */
TBool CSmsAlphabetConverter::IsSupportedL(TChar aChar)
	{
	LOGGSMU2("[1] CSmsAlphabetConverter::IsSupportedL(aChar=0x%04x)", (TUint) aChar);

	TBool isDowngrade, isRequiresAlternativeEncoding;

    TBool  supported = IsSupportedL(aChar, ESmsEncodingNone,
            isDowngrade, isRequiresAlternativeEncoding);
	
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);

	return supported;
	} // CSmsAlphabetConverter::IsSupportedL


/**
 *  Tests if the descriptor text is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aDes                                 Text string to check.
 *  @param aNumberOfUnconvertibleCharacters     Exit param for the number of
 *                                              characters unconvertible.
 *  @param aIndexOfFirstUnconvertibleCharacter  Exit param for the first
 *                                              unconverted character.
 * 
 *  @return  ETrue if the character is supported.
 */
TBool CSmsAlphabetConverter::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
                                          TInt& aIndexOfFirstUnconvertibleCharacter)
	{
	LOGGSMU2("[2] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", &aDes);

	TInt desLength = aDes.Length();
	//
	// Initialise the exit params...
	//
	aNumberOfUnconvertibleCharacters    = 0;
	aIndexOfFirstUnconvertibleCharacter = desLength;

    //
    // Create buffers for the input converted to 7Bit and a buffer for it once
    // converted back again...
    //
    HBufC8* encodedBuf       = HBufC8::NewLC(desLength*2); // worse case
    HBufC*  backToUnicodeAfterStdBuf = HBufC::NewLC(desLength);
    TPtr8  encoded(encodedBuf->Des());
    TPtr  backToUnicodeAfterStd(backToUnicodeAfterStdBuf->Des());

    //
    // Convert the input string to standard 7bit (with downgrades if needed)...
    // 
    PrepareForConversionFromNativeL(ESmsEncodingNone);

    TInt  notConverted = iCharacterSetConverter.ConvertFromUnicode(encoded, aDes);

    if (notConverted > 0)
        {
        aNumberOfUnconvertibleCharacters += notConverted;
        }
    else if (notConverted < 0)
        {
        aNumberOfUnconvertibleCharacters = desLength;
        }
    
    //
    // Convert it back again to the native format...
    //
    TInt  state       = CCnvCharacterSetConverter::KStateDefault;
    TInt  notRestored = iCharacterSetConverter.ConvertToUnicode(backToUnicodeAfterStd, encoded, state);

    if (notRestored > 0)
        {
        aNumberOfUnconvertibleCharacters += notRestored;
        }
    else if (notRestored < 0)
        {
        aNumberOfUnconvertibleCharacters = desLength;
        }

    //
    // Work out if the string is acceptable as it is (e.g. no unconvertible
    // and no downgrades). We only need do this if the previous conversions were
    // complete with no issues.
    //
    for (TInt pos = desLength-1;  pos >= 0;  --pos)
        {
        if (backToUnicodeAfterStd[pos] != aDes[pos])
            {
            aNumberOfUnconvertibleCharacters++;
            aIndexOfFirstUnconvertibleCharacter = pos;
            }
        }
    
    CleanupStack::PopAndDestroy(backToUnicodeAfterStdBuf);
    CleanupStack::PopAndDestroy(encodedBuf);
	
	//
	// Useful logging...
	//
	TBool  supported = (aNumberOfUnconvertibleCharacters == 0);

	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);

	return supported;
	} // CSmsAlphabetConverter::IsSupportedL


/**
 *  Tests if the character is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aChar                         Character to investigate.
 *  @param aEncoding                     Alternative 7bit encoding (if used).
 *  @param aIsDowngrade                  Exit param set to ETrue if the
 *                                       character has to be downgraded.
 *  @param aRequiresAlternativeEncoding  Exit param set to ETrue if the
 *                                       alternative encoding has to be
 *                                       used to encode it.
 * 
 *  @return  ETrue if the character is supported.
 */
TBool CSmsAlphabetConverter::IsSupportedL(TChar aChar, TSmsEncoding aEncoding,
		                                  TBool& aIsDowngrade,
                                          TBool& aRequiresAlternativeEncoding)
	{
	LOGGSMU2("[3] CSmsAlphabetConverter::IsSupportedL(aChar=0x%04x)", (TUint) aChar);

	//
	// Convert the character...
	//
	TInt  numberOfUnconvertibleCharacters, numberOfDowngradedCharacters, 
            numberRequiringAlternativeEncoding, indexOfFirstUnconvertibleCharacter;
	TBuf<4>   toEncode;

	toEncode.SetLength(1);
	toEncode[0]=(TText)aChar;

	TBool supported = IsSupportedL(toEncode, aEncoding, 
	        numberOfUnconvertibleCharacters,
	        numberOfDowngradedCharacters,
	        numberRequiringAlternativeEncoding,
	        indexOfFirstUnconvertibleCharacter);

	//
	// Calculate the exit params...
	//
	aIsDowngrade                 = (numberOfDowngradedCharacters > 0);
	aRequiresAlternativeEncoding = (numberRequiringAlternativeEncoding > 0);
	    
	//
	// Useful logging...
	//
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIsDowngrade=%d.", aIsDowngrade);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aRequiresAlternativeEncoding=%d.", aRequiresAlternativeEncoding);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);

	return supported;
	} // CSmsAlphabetConverter::IsSupportedL


/**
 *  Tests if the descriptor text is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aDes                                 Text string to check.
 *  @param aEncoding                            Alternative 7bit encoding (if used).
 *  @param aNumberOfUnconvertibleCharacters     Exit param for the number of
 *                                              characters unconvertible.
 *  @param aNumberOfDowngradedCharacters        Exit param for the number of
 *                                              downgraded characters.
 *  @param aNumberRequiringAlternativeEncoding  Exit param for the number of
 *                                              characters requiring use of
 *                                              the alternative encoder.
 *  @param aIndexOfFirstUnconvertibleCharacter  Exit param for the first
 *                                              unconverted character.
 * 
 *  @return  ETrue if the character is supported.
 */
TBool CSmsAlphabetConverter::IsSupportedL(const TDesC& aDes, TSmsEncoding aEncoding,
										  TInt& aNumberOfUnconvertibleCharacters,
                                          TInt& aNumberOfDowngradedCharacters,
                                          TInt& aNumberRequiringAlternativeEncoding,
                                          TInt& aIndexOfFirstUnconvertibleCharacter)
	{
	LOGGSMU2("[4] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", &aDes);

	TInt desLength = aDes.Length();
	//
	// Initialise the exit params...
	//
	aNumberOfUnconvertibleCharacters    = 0;
	aNumberOfDowngradedCharacters       = 0;
	aNumberRequiringAlternativeEncoding = 0;
	aIndexOfFirstUnconvertibleCharacter = desLength;
	
	//
	// Create buffers for the input converted to 7Bit and a buffer for it once
	// converted back again...
	//
    HBufC8* encodedBuf       = HBufC8::NewLC(desLength*2); // worse case
    HBufC*  backToUnicodeAfterStdBuf = HBufC::NewLC(desLength);
    TPtr8  encoded(encodedBuf->Des());
    TPtr  backToUnicodeAfterStd(backToUnicodeAfterStdBuf->Des());

    //
    // Convert the input string to standard 7bit (with downgrades if needed)...
    // 
    PrepareForConversionFromNativeL(ESmsEncodingNone);

    TInt  notConverted = iCharacterSetConverter.ConvertFromUnicode(encoded, aDes);

    if (notConverted > 0)
        {
        aNumberOfUnconvertibleCharacters += notConverted;
        }
    else if (notConverted < 0)
        {
        aNumberOfUnconvertibleCharacters = desLength;
        }
    
    //
    // Convert it back again to the native format...
    //
    TInt  state       = CCnvCharacterSetConverter::KStateDefault;
    TInt  notRestored = iCharacterSetConverter.ConvertToUnicode(backToUnicodeAfterStd, encoded, state);

    if (notRestored > 0)
        {
        aNumberOfUnconvertibleCharacters += notRestored;
        }
    else if (notRestored < 0)
        {
        aNumberOfUnconvertibleCharacters = desLength;
        }

    //
    // Work out if the string is acceptable as it is (e.g. no unconvertible
    // and no downgrades).
    //
    for (TInt pos = desLength-1;  pos >= 0;  --pos)
        {
        if (backToUnicodeAfterStd[pos] != aDes[pos])
            {
            if (backToUnicodeAfterStd[pos] != KReplacementCharacter)
                {
                aNumberOfDowngradedCharacters++;
                }
            else
                {
                aNumberOfUnconvertibleCharacters++;
                aIndexOfFirstUnconvertibleCharacter = pos;
                }
            }
        }

    TInt  totalCharFaultsSoFar = aNumberOfUnconvertibleCharacters + 
                                    aNumberOfDowngradedCharacters;
    
    //
    // If the total unconvertible plus downgrades is zero, then there is nothing
    // more to do as the string can be converted to 7bit with no issues and no
    // other encoder is needed.
    //
    // Otherwise we have to look at the alternative encoder...
    //
    if (totalCharFaultsSoFar == 0)
        {
        //
        // We are done (the return counts are already zero and therefore
        // correct at this point too!).
        //
        }
    else if (iSmsAlphabet != TSmsDataCodingScheme::ESmsAlphabet7Bit  ||
             aEncoding == ESmsEncodingNone)
        {
        //
        // The string was not perfectly converted, but there is no alternative
        // encoder to try.  We are done.
        //
        }
    else
        {
        //
        // Initialise the params...
        //
        TInt  tmpDowngradedCharacters        = 0;
        TInt  tmpUnconvertibleCharacters     = 0;
        TInt  tmpIndexOfFirstUnconvertibleCharacter = desLength;
		
        //
        // Convert the input string to the alternative encoding...
        //
        PrepareForConversionFromNativeL(aEncoding);

        notConverted = iCharacterSetConverter.ConvertFromUnicode(encoded, aDes);
        if (notConverted > 0)
            {
            tmpUnconvertibleCharacters = notConverted;
            }
        else if (notConverted < 0)
            {
            tmpUnconvertibleCharacters = desLength;
            }

        //
        // Convert it back again to the native format...
        //
        HBufC*  backToUnicodeAfterAltBuf = HBufC::NewLC(desLength);
        TPtr  backToUnicodeAfterAlt(backToUnicodeAfterAltBuf->Des());
        TInt  state       = CCnvCharacterSetConverter::KStateDefault;
        TInt  notRestored = iCharacterSetConverter.ConvertToUnicode(backToUnicodeAfterAlt, encoded, state);

        if (notRestored > 0)
            {
            tmpUnconvertibleCharacters += notRestored;
            }
        else if (notRestored < 0)
            {
            tmpUnconvertibleCharacters = desLength;
            }

        //
        // Now work out which characters are downgrades, require alternative encoding
        // or are unsupported.
        //
        for (TInt pos = desLength-1;  pos >= 0;  --pos)
            {
            if (backToUnicodeAfterStd[pos] != aDes[pos])
                {
                // Not supported by standard encoder...
                if (backToUnicodeAfterAlt[pos] == aDes[pos])
                    {
                    // Supported by alternative encoder...
                    aNumberRequiringAlternativeEncoding++;
                    }
                else if (backToUnicodeAfterStd[pos] != KReplacementCharacter)
                    {
                    // Downgraded by standard encoder...
                    tmpDowngradedCharacters++;
                    }
                else if (backToUnicodeAfterAlt[pos] != KReplacementCharacter)
                    {
                    // Downgraded by alternative encoder...
                    tmpDowngradedCharacters++;
                    aNumberRequiringAlternativeEncoding++;
                    }
                else
                    {
                    // Unconvertible...
                    tmpUnconvertibleCharacters++;
                    tmpIndexOfFirstUnconvertibleCharacter = pos;
                    }
                }
            }

        // Is this better?  
        if ( totalCharFaultsSoFar >= (tmpUnconvertibleCharacters + tmpDowngradedCharacters) )
            {
            // Best conversion is the alternative conversion
            aNumberOfUnconvertibleCharacters     = tmpUnconvertibleCharacters;
            aNumberOfDowngradedCharacters        = tmpDowngradedCharacters;
            aIndexOfFirstUnconvertibleCharacter  = tmpIndexOfFirstUnconvertibleCharacter;
            }
        else
            {
            // Best conversion is the standard conversion
            aNumberRequiringAlternativeEncoding = 0;
            }
        
        CleanupStack::PopAndDestroy(backToUnicodeAfterAltBuf);
        }
    
    CleanupStack::PopAndDestroy(backToUnicodeAfterStdBuf);
    CleanupStack::PopAndDestroy(encodedBuf);

	//
	// Useful logging...
	//
	TBool  supported = (aNumberOfUnconvertibleCharacters == 0);

	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfDowngradedCharacters=%d.", aNumberOfDowngradedCharacters);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberRequiringAlternativeEncoding=%d.", aNumberRequiringAlternativeEncoding);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);

	return supported;
	} // CSmsAlphabetConverter::IsSupportedL


/**
 *  Given a piece of text and an alternative encoding, this function works out
 *  which encoding is best to use and returns the ID of that converter.
 * 
 *  @param aNativeCharacters      Text to use as a sample.
 *  @param aEncoding              Suggested alternative 7bit encoding method.
 * 
 *  @return Encoding that should be used.
 */
TSmsEncoding CSmsAlphabetConverter::FindBestAlternativeEncodingL(const TDesC& aNativeCharacters,
									                     		 TSmsEncoding aSuggestedEncoding)
	{
	LOGGSMU2("CSmsAlphabetConverter::FindBestAlternativeEncodingL(): aSuggestedEncoding=%d",
			 aSuggestedEncoding);

	TSmsEncoding  encodingToUse = ESmsEncodingNone;

	//
	// If this is not 7bit or the alternative encoding is not set then do
	// nothing...
	//
	if (aSuggestedEncoding != ESmsEncodingNone  &&
		iSmsAlphabet == TSmsDataCodingScheme::ESmsAlphabet7Bit)
		{
		TInt  numberOfUnconvertibleCharacters, numberOfDowngradedCharacters;
		TInt  numberRequiringAlternativeEncoding, indexOfFirstUnconvertibleCharacter;
		
		//
		// First try the default encoding (but in this case treat downgrades
		// as unconverted, since later encoders might do better)...
		//
		IsSupportedL(aNativeCharacters, ESmsEncodingNone,
					 numberOfUnconvertibleCharacters,
                     numberOfDowngradedCharacters,
                     numberRequiringAlternativeEncoding,
                     indexOfFirstUnconvertibleCharacter);

		TInt leastUnconvertibleCharacters = numberOfUnconvertibleCharacters + numberOfDowngradedCharacters;

		//
		// Create a list of alternative encodings to try...
		//
		TSmsEncoding  encodingList[8];
		TInt          encodingCount = 0;
		
		if (aSuggestedEncoding == ESmsEncodingTurkishLockingAndSingleShift)
			{
			encodingList[encodingCount++] = ESmsEncodingTurkishSingleShift;
			encodingList[encodingCount++] = ESmsEncodingTurkishLockingShift;
			}
		else if (aSuggestedEncoding == ESmsEncodingPortugueseLockingAndSingleShift)
			{
			encodingList[encodingCount++] = ESmsEncodingPortugueseSingleShift;
			encodingList[encodingCount++] = ESmsEncodingPortugueseLockingShift;
			}

		encodingList[encodingCount++] = aSuggestedEncoding;
		encodingList[encodingCount++] = ESmsEncodingNone;

		//
		// Now try the all the alternatives...
		//
		for (TInt  encoder = 0;  encoder < encodingCount;  encoder++)
			{
			IsSupportedL(aNativeCharacters, encodingList[encoder],
						 numberOfUnconvertibleCharacters,
	                     numberOfDowngradedCharacters,
	                     numberRequiringAlternativeEncoding,
	                     indexOfFirstUnconvertibleCharacter);
			if (numberOfUnconvertibleCharacters + numberOfDowngradedCharacters < leastUnconvertibleCharacters)
				{
				encodingToUse = encodingList[encoder];
				leastUnconvertibleCharacters = numberOfUnconvertibleCharacters + numberOfDowngradedCharacters;
				}
			}
		}

	LOGGSMU2("CSmsAlphabetConverter::FindBestAlternativeEncodingL(): encodingToUse=%d", encodingToUse);

	return encodingToUse;
	} // CSmsAlphabetConverter::FindBestAlternativeEncoding


/**
 *  Confirms that the requested encoding method is present (e.g. the converter
 *  plug-in can be loaded).
 * 
 *  @param aEncoding  Alternative 7bit encoding method.
 * 
 *  @leave KErrNotSupported if the encoder is not available.
 */
void CSmsAlphabetConverter::ConfirmAlternativeEncoderL(TSmsEncoding aEncoding) const
	{
	//
	// Check the ID for the encoder exists...
	//
	if (aEncoding != ESmsEncodingNone)
		{
		TUint  encoderID;
		
		GetAlternativeEncoderIDL(aEncoding, encoderID);
		
		//
		// Confirm it can be loaded...
		//
		if (iCharacterSetConverter.PrepareToConvertToOrFromL(encoderID, iFs) != CCnvCharacterSetConverter::EAvailable)
			{
			User::Leave(KErrNotSupported);
			}
		}
	} // CSmsAlphabetConverter::ConfirmAlternativeEncoderL


/**
 *  Prepares the converted for conversion from native charset.
 *  Character set specific preparation is performed here.
 * 
 *  @param aEncoding  Alternative 7bit encoding to use if required.
 */
void CSmsAlphabetConverter::PrepareForConversionFromNativeL(TSmsEncoding aEncoding)
	{
	LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): aEncoding=%d",
			 aEncoding);

	__ASSERT_DEBUG(iIsBinary==EFalse,Panic(KGsmuPanicUnsupportedAlphabet));
	switch (iSmsAlphabet)
		{
		case TSmsDataCodingScheme::ESmsAlphabet7Bit:
			{
			//
			// If an alternative encoding has been specified then try and
			// load that converter...
			//
			if (aEncoding != ESmsEncodingNone)
				{
				TUint  alternativeEncoderID;
				
				GetAlternativeEncoderIDL(aEncoding, alternativeEncoderID);
				if (alternativeEncoderID != 0)
					{
					CCnvCharacterSetConverter::TAvailability  availability;
		
					LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",
							 alternativeEncoderID);
					
					availability = iCharacterSetConverter.PrepareToConvertToOrFromL(alternativeEncoderID, iFs);
					if (availability == CCnvCharacterSetConverter::EAvailable)
						{
			 			// Force unicode line termination characters to simple line feed
			 			iCharacterSetConverter.SetDowngradeForExoticLineTerminatingCharacters(
				 				CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed);
					
						// Job done, return
			 			return;
						}
					
					// Plug-in could not be loaded, so drop through and load the default!
					}
				}
			
			//
			// Check for the PREQ2090 7bit converter with Eastern European
			// downgrade support first, otherwise if the plug-in is not found
			// use the standard internal converter.
			//
			CCnvCharacterSetConverter::TAvailability  availability;
			
			availability = iCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierExtendedSms7Bit, iFs);
			if (availability == CCnvCharacterSetConverter::ENotAvailable)
				{
				availability = iCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit, iFs);
				if (availability == CCnvCharacterSetConverter::ENotAvailable)
					{
					User::Leave(KErrNotFound);
					}
				}

 			// Force unicode line termination characters to simple line feed
 			iCharacterSetConverter.SetDowngradeForExoticLineTerminatingCharacters(
 				CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed);
			break;
			}
		case TSmsDataCodingScheme::ESmsAlphabet8Bit:
			{
			CCnvCharacterSetConverter::TAvailability availability=iCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252,iFs);
			if (availability==CCnvCharacterSetConverter::ENotAvailable)
				{
				User::Leave(KErrNotFound);
				}

 			// Force unicode line termination characters to simple line feed
 			iCharacterSetConverter.SetDowngradeForExoticLineTerminatingCharacters(
 				CCnvCharacterSetConverter::EDowngradeExoticLineTerminatingCharactersToJustLineFeed);
			break;
			}
		case TSmsDataCodingScheme::ESmsAlphabetUCS2:
		default:
			{
            User::Leave(KErrNotSupported);
			}
		}
	} // CSmsAlphabetConverter::PrepareForConversionFromNativeL


/**
 *  Prepares the converted for conversion to unicode.  Character set
 *  specific preparation is performed here.
 * 
 *  @param aEncoding  Alternative 7bit encoding to use if required.
 */
void CSmsAlphabetConverter::PrepareForConversionToNativeL(TSmsEncoding aEncoding)
	{
	LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionToNativeL(): aEncoding=%d",
			 aEncoding);

	switch (iSmsAlphabet)
		{
		case TSmsDataCodingScheme::ESmsAlphabet7Bit:
			{
			//
			// If an alternative encoding has been specified then try and
			// load that converter...
			//
			if (aEncoding != ESmsEncodingNone)
				{
				TUint  alternativeEncoderID;
				
				GetAlternativeEncoderIDL(aEncoding, alternativeEncoderID);
				if (alternativeEncoderID != 0)
					{
					CCnvCharacterSetConverter::TAvailability  availability;
		
					LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",
							 alternativeEncoderID);
					
					availability = iCharacterSetConverter.PrepareToConvertToOrFromL(alternativeEncoderID, iFs);
					if (availability == CCnvCharacterSetConverter::EAvailable)
						{
						// Job done, return
			 			return;
						}
					
					// Plug-in could not be loaded, so drop through and load the default!
					}
				}
			
			//
			// Always use the internal converter, as it is quicker to prepare
			// and the PREQ2090 7bit converter with Eastern European downgrade
			// offers no benefit when converting to native.
			//
			CCnvCharacterSetConverter::TAvailability availability=iCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierSms7Bit,iFs);
			if (availability==CCnvCharacterSetConverter::ENotAvailable)
				{
				User::Leave(KErrNotFound);
				}
			break;
			}
		case TSmsDataCodingScheme::ESmsAlphabet8Bit:
			{
			CCnvCharacterSetConverter::TAvailability availability=iCharacterSetConverter.PrepareToConvertToOrFromL(KCharacterSetIdentifierCodePage1252,iFs);
			if (availability==CCnvCharacterSetConverter::ENotAvailable)
				{
				User::Leave(KErrNotFound);
				}
			break;
			}
		case TSmsDataCodingScheme::ESmsAlphabetUCS2:
		default:
			{
			User::Leave(KErrNotSupported);
			}
		}
	} // CSmsAlphabetConverter::PrepareForConversionToNativeL


/**
 *  This function returns the alternative encoding converters that are used
 *  incase the default GSM encoding cannot encode the message completely
 *  without data loss.
 * 
 *  @param aEncoding   Encoding to obtain the converter for.
 *  @param aEncoderID  Returned converter UID if present.
 * 
 *  @leave KErrArgument if the encoding enum is invalid or
 */
void CSmsAlphabetConverter::GetAlternativeEncoderIDL(TSmsEncoding aEncoding, TUint& aEncoderID) const
	{
	LOGGSMU2("CSmsAlphabetConverter::GetAlternativeEncoderIDL(%d)", aEncoding);

	aEncoderID = 0;
	
	//
	// Decide on appropriate encoders.
	//
	switch (aEncoding)
		{
		case ESmsEncodingNone:
			{
			// Nothing to set.
			}
			break;
		
		case ESmsEncodingTurkishSingleShift:
			{
			aEncoderID = KCharacterSetIdentifierTurkishSingleSms7Bit;
			}
			break;
		
		case ESmsEncodingTurkishLockingShift:
			{
			aEncoderID = KCharacterSetIdentifierTurkishLockingSms7Bit;
			}
			break;
		
		case ESmsEncodingTurkishLockingAndSingleShift:
			{
			aEncoderID = KCharacterSetIdentifierTurkishLockingAndSingleSms7Bit;
			}
			break;
		
		case ESmsEncodingSpanishSingleShift:
			{
			aEncoderID = KCharacterSetIdentifierSpanishSingleSms7Bit;
			}
			break;
		
		case ESmsEncodingPortugueseSingleShift:
			{
			aEncoderID = KCharacterSetIdentifierPortugueseSingleSms7Bit;
			}
			break;
		
		case ESmsEncodingPortugueseLockingShift:
			{
			aEncoderID = KCharacterSetIdentifierPortugueseLockingSms7Bit;
			}
			break;
		
		case ESmsEncodingPortugueseLockingAndSingleShift:
			{
			aEncoderID = KCharacterSetIdentifierPortugueseLockingAndSingleSms7Bit;
			}
			break;

		default:
			{
			//
			// Invalid encoder method!
			//
			User::Leave(KErrArgument);
			}
		};
	} // CSmsAlphabetConverter::GetAlternativeEncoderIDL


//
// Ensures the allocated 16 bit buffer is at least of the specified length
//
TPtr16 CSmsAlphabetConverter::CheckAllocBufferL(HBufC16** aBuffer,TInt aMaxLength,TInt aUsedLength)
	{
	LOGGSMU1("CSmsAlphabetConverter::CheckAllocBufferL()");

	if (*aBuffer!=NULL)
		{
		if ((*aBuffer)->Length()<aMaxLength)
			{
			*aBuffer=(*aBuffer)->ReAllocL(aMaxLength);
			(*aBuffer)->Des().SetLength(aMaxLength);
			}
		}
	else
		{
		*aBuffer=HBufC16::NewMaxL(aMaxLength);
		}
	return TPtr16((TUint16*)(*aBuffer)->Des().Ptr(),aUsedLength,(*aBuffer)->Length());
	} // CSmsAlphabetConverter::CheckAllocBufferL


//
// Ensures the allocated 8 bit buffer is at least of the specified length
//
TPtr8 CSmsAlphabetConverter::CheckAllocBufferL(HBufC8** aBuffer,TInt aMaxLength,TInt aUsedLength)
	{
	LOGGSMU1("CSmsAlphabetConverter::CheckAllocBufferL()");

	if (*aBuffer!=NULL)
		{
		if ((*aBuffer)->Length()<aMaxLength)
			{
			*aBuffer=(*aBuffer)->ReAllocL(aMaxLength);
			(*aBuffer)->Des().SetLength(aMaxLength);
			}
		}
	else
		{
		*aBuffer=HBufC8::NewMaxL(aMaxLength);
		}
	return TPtr8((TUint8*)(*aBuffer)->Des().Ptr(),aUsedLength,(*aBuffer)->Length());
	} // CSmsAlphabetConverter::CheckAllocBufferL


/**
 *  @internalComponent
 *  
 *  Determines whether the address format matches the specified type.
 *  
 *  @param aType Specifies an indicator type, as defined in the Common PCN Handset Specification
 *  @return returns ETrue if address is of specified type, EFalse otherwise 
 */
EXPORT_C TBool TGsmSmsTelNumber::IsInstanceOf(TTypeOfIndicator aType)
    {
    LOGGSMU1("TGsmSmsTelNumber::IsInstanceOf()");

    TBool rc = EFalse;

    (void) aType;

    if((aType == EVoiceMessageWaitingIndicator)
     && ((iTypeOfAddress & TGsmSmsTypeOfAddress::EGsmSmsTONMask)==EGsmSmsTONAlphaNumeric)
     && (iTelNumber.Length()==ECPHSSizeOfAddressField)
     && ((iTelNumber[ECPHSAddressIndicatorType] & ECPSHIndicatorTypeBitMask) == ECPSHVoiceMailId)
     && ((iTelNumber[ECPHSAddressIndicatorId] & ECPSHIndicatorIdBitMask) == ECPSHIndicatorId ))
      rc = ETrue;

    return rc;
    } // TGsmSmsTelNumber::IsInstanceOf


//
// CSmsAddress
//

CSmsAddress* CSmsAddress::NewL(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs)
	{
	LOGGSMU1("CSmsAddress::NewL()");

	CSmsAddress* address=new(ELeave) CSmsAddress(aCharacterSetConverter,aFs);
	CleanupStack::PushL(address);
	TPtrC ptr;
	address->SetAddressL(ptr);
	CleanupStack::Pop();
	return address;
	} // CSmsAddress::NewL


CSmsAddress::~CSmsAddress()
    {
    delete iBuffer;
    } // CSmsAddress::NewL


/**
 *  Duplicates this CSmsAddress object.
 * 
 *  @return  Pointer to the newly created CSmsAddress object.
 */
CSmsAddress* CSmsAddress::DuplicateL() const
	{
	LOGGSMU1("CSmsAddress::DuplicateL()");

	CSmsAddress*  address = CSmsAddress::NewL(iCharacterSetConverter, iFs);
	CleanupStack::PushL(address);

	address->SetRawAddressL(iTypeOfAddress, *iBuffer);
	
	CleanupStack::Pop();

	return address;
	} // CSmsAddress::DuplicateL


TPtrC CSmsAddress::Address() const
	{
	LOGGSMU1("CSmsAddress::Address()");

	TPtrC ptr;
	if (iBuffer)
		ptr.Set(iBuffer->Des());
	return ptr;
	} // CSmsAddress::Address


void CSmsAddress::SetRawAddressL(TGsmSmsTypeOfAddress aTypeOfAddress, TPtrC aBufferPtr)
    {
    LOGGSMU1("CSmsAddress::SetRawAddressL()");

    iTypeOfAddress = aTypeOfAddress;

    NewBufferL(aBufferPtr.Length());

	*iBuffer=aBufferPtr;
    } // CSmsAddress::SetRawAddressL


TGsmSmsTypeOfAddress& CSmsAddress::TypeOfAddress()
    {
    LOGGSMU1("CSmsAddress::TypeOfAddress()");

    return iTypeOfAddress;
    } // CSmsAddress::TypeOfAddress


void CSmsAddress::SetAddressL(const TDesC& aAddress)
	{
	LOGGSMU1("CSmsAddress::SetAddressL()");

	TInt length=aAddress.Length();
	NewBufferL(length);
	iBuffer->Des().Copy(aAddress);

	const TGsmSmsTypeOfNumber typeofnumber=length && (iBuffer->Des()[0]=='+')? EGsmSmsTONInternationalNumber: EGsmSmsTONUnknown;
	iTypeOfAddress.SetTON(typeofnumber);
	} // CSmsAddress::SetAddressL


void CSmsAddress::ParsedAddress(TGsmSmsTelNumber& aParsedAddress) const
	{
	aParsedAddress.iTypeOfAddress = iTypeOfAddress;

	TInt maxparsedlength=aParsedAddress.iTelNumber.MaxLength();

	if (iTypeOfAddress.TON()==EGsmSmsTONAlphaNumeric)
		{
		TInt parsedlength=Address().Length();
		if (parsedlength>maxparsedlength)
			parsedlength=maxparsedlength;
		aParsedAddress.iTelNumber.Copy(Address().Mid(0,parsedlength));
		}
	else
		{
		aParsedAddress.iTelNumber.SetLength(maxparsedlength);

		TInt length=iBuffer->Des().Length();
		TInt parsedlength=0;
		for (TInt i=0; (i<length) && (parsedlength<maxparsedlength); i++)
			{
			TText ch=iBuffer->Des()[i];
            switch(ch)
                {
                case '*':
                case '#':
                case 'a':
                case 'b':
                case 'c':
                    aParsedAddress.iTelNumber[parsedlength]=(TUint8) ch;
                    parsedlength++;
                    break;                    
                default:
                    if ((ch>='0') && (ch<='9'))
                        {
                        aParsedAddress.iTelNumber[parsedlength]=(TUint8) ch;
                        parsedlength++;
                        }
                    break;
                }			
			}

		aParsedAddress.iTelNumber.SetLength(parsedlength);
		}
	}


void CSmsAddress::SetParsedAddressL(const TGsmSmsTelNumber& aParsedAddress)
	{
	LOGGSMU1("CSmsAddress::SetParsedAddressL()");

	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
	DoSetParsedAddressL(aParsedAddress.iTelNumber);
	} // CSmsAddress::SetParsedAddressL


TUint8 CSmsAddress::SizeL()
    {
    LOGGSMU1("CSmsAddress::SizeL()");

    TUint8 size = 0;

    TBuf8<KSmsAddressMaxAddressLength> testBuffer;
    testBuffer.SetLength(KSmsAddressMaxAddressLength);
    TUint8* startPtr = &testBuffer[0];
    TUint8* endPtr = NULL;

    TRAPD(err,endPtr = EncodeL(startPtr));

    if (err != KErrNone)
        {
        User::Leave(KErrArgument);
        }
    else
        {
        // handle architectures whose address space increments or whose address space decrements.
        (endPtr > startPtr) ? (size = endPtr - startPtr) : (size = startPtr - endPtr);
        }

	return size;
    } // CSmsAddress::SizeL


TUint8* CSmsAddress::EncodeL(TUint8* aPtr) const
	{
	TGsmSmsTelNumber parsedaddress;
	ParsedAddress(parsedaddress);

	switch (iTypeOfAddress.TON())
		{
		case EGsmSmsTONAlphaNumeric:
			{
			// Mark buffer for length encoding after conversion
			TUint8* lengthPtr=aPtr++;
			// Encode type
			aPtr=iTypeOfAddress.EncodeL(aPtr);
			// 7-bit conversion
			TPtrC address=Address();
			TInt convertedNumUDUnits=0;
			TPtr8 packedPtr(aPtr,0,KSmsAddressMaxAddressValueLength);
			TSmsAlphabetPacker packer(TSmsDataCodingScheme::ESmsAlphabet7Bit,EFalse,0);
			aPtr+=packer.ConvertAndPackL(iCharacterSetConverter,iFs,packedPtr,address,convertedNumUDUnits);
			// Now encode length
			TSmsOctet length=(convertedNumUDUnits*7+3)/4;
			length.EncodeL(lengthPtr);
			break;
			}
		case EGsmSmsTONInternationalNumber:
		default:
			{
			TSmsOctet length=parsedaddress.iTelNumber.Length();
			if (length > KSmsAddressMaxAddressValueLength * 2)
			// each address value occupies one nibble.
                {
                User::Leave(KErrArgument);
                }
			aPtr=length.EncodeL(aPtr);
			aPtr=iTypeOfAddress.EncodeL(aPtr);
			TSmsOctet octet;
			for (TInt i=0; i<length; i++)
				{
                if ((i%2)==0)  //  even
                    {
                    switch(parsedaddress.iTelNumber[i])
                        {
                        case '*':
                            {
                            octet=10; // 1010 as a binary, according to 23.040 …
                            }
                            break;

                        case '#':
                            {
                            octet=11; // 1011 as a binary, according to 23.040…
                            }
                            break; 

                        case 'a':
                            {
                            octet=12; // 1100 as a binary, according to 23.040...
                            }
                            break;

                        case 'b':
                            {
                            octet=13; // 1101 as a binary, according to 23.040…
                            }
                            break;

                        case 'c':
                            {
                            octet=14; // 1110 as a binary, according to 23.040…
                            }
                            break;

                        default:
                            octet=(parsedaddress.iTelNumber[i])-'0';
                            break;
                        }
                    } 
                else
                    {
                    TInt tempOctet = 0;
       
                    switch(parsedaddress.iTelNumber[i])
                        {
                        case '*':
                            {
                            tempOctet=10; // 1010 as a binary, according to 23.040…
                            }
                            break;

                        case '#':
                            {
                            tempOctet=11; // 1011 as a binary, according to 23.040…
                            }
                            break;

                        case 'a':
                            {
                            tempOctet=12; // 1100 as a binary, according to 23.040…
                            }
                            break;

                        case 'b':
                            {
                            tempOctet=13; // 1101 as a binary, according to 23.040…
                            }
                            break;

                        case 'c':
                            {
                            tempOctet=14; // 1110 as a binary, according to 23.040…
                            }
                            break;

                        default:
                            tempOctet=(parsedaddress.iTelNumber[i])-'0';
                            break;
                        }
                    octet=octet|tempOctet<<4;
                    aPtr=octet.EncodeL(aPtr);				
				    }
                
			    } // end for loop

			if (length%2)   // odd number of semioctets
				{
				octet=octet|0xF0;
				aPtr=octet.EncodeL(aPtr);
				}
						
		    } // end default case
	    }
	return aPtr;
	}


void CSmsAddress::DecodeL(TGsmuLex8& aPdu)
	{
	TSmsOctet length;  //represents the number of valid semi-octets
	length.DecodeL(aPdu);
	iTypeOfAddress.DecodeL(aPdu);

	switch (iTypeOfAddress.TON())
		{
		case EGsmSmsTONAlphaNumeric:
			{
			const TUint cphs1 = aPdu.GetL();
			const TUint cphs2 = aPdu.GetL();
			aPdu.UnGet();
			aPdu.UnGet();

			const TPtrC8 remainder(aPdu.Remainder());
			// we assume that it is a cphs message waiting indicator
            // we might want to do further tests tobe sure that it is a CPHS message
			if(    (length==4)
				&& ((cphs1 & 0x7E) == 0x10) // x001 000x constant value
				&& ((cphs2 & 0x7E) == 0x00) // x000 000x constant value
			  )
				{
				TGsmSmsTelNumber parsedaddress;
				parsedaddress.iTelNumber.SetLength(length);
				//Copy the two bytes of the cphs message waiting address into the parsed address
				parsedaddress.iTelNumber[0]=(TUint8)length;
				parsedaddress.iTelNumber[1]= (TUint8)iTypeOfAddress;
				parsedaddress.iTelNumber[2]= (TUint8)aPdu.GetL();
				parsedaddress.iTelNumber[3]= (TUint8)aPdu.GetL();
				DoSetParsedAddressL(parsedaddress.iTelNumber);
				}
			else if(length==11 && remainder.Left(6).CompareF(KMOSES) ==KErrNone ) //check for MOSES
				{
					DoSetParsedAddressL(KNETWORK);
					aPdu.IncL(6);
				}
			else
				{
				// Encoded length is number of semi-octets used to store address using
				// 7-bit char set - determine number of user data units required
				const TInt numUDUnits=length*4/7;
				// Unpack the data - assume max converted length twice the unconverted length
				// VEP Why this assumption, the length will be doubled at the client because of that??
				// EXT-568BMW
				// Fix is not to multiply by 2
				//NewBufferL(2*numUDUnits);
				NewBufferL(numUDUnits);
				TPtr unpackedPtr((TText*)iBuffer->Des().Ptr(),0,iBuffer->Length());

				if (remainder.Length() < KSmsAddressMaxAddressValueLength)
					User::Leave(KErrGsmuDecoding);

				TPtrC8 packedPtr(remainder.Ptr(), KSmsAddressMaxAddressValueLength);
				TSmsAlphabetPacker unpacker(TSmsDataCodingScheme::ESmsAlphabet7Bit,EFalse,0);
				unpacker.UnpackAndConvertL(iCharacterSetConverter,iFs,packedPtr,unpackedPtr,numUDUnits);
				aPdu.IncL(length / 2);
				if ((length % 2) != 0)
					aPdu.IncL();
				}
			break;
			}
		case EGsmSmsTONInternationalNumber:
		default:
			{
			TGsmSmsTelNumber parsedaddress;
			if (length>parsedaddress.iTelNumber.MaxLength())
				User::Leave(KErrGsmuDecoding);
			parsedaddress.iTelNumber.SetLength(length);
			TSmsOctet octet;
			for (TInt i=0; i<length; i++)
				{
				if ((i%2)==0)  //  even
					{
                    TUint8 tempOctet = 0;
                    octet.DecodeL(aPdu);
                    tempOctet = (TUint8)octet&0x0F; // four topmost bits set to zero
                    
                    switch(tempOctet)
                        {
                        case 10: // 1010
                            {
                            parsedaddress.iTelNumber[i] = '*';
                            }
                            break;

                        case 11: // 1011
                            {
                            parsedaddress.iTelNumber[i] = '#';
                            }
                            break; 

                        case 12: // 1100
                            {
                            parsedaddress.iTelNumber[i] = 'a';
                            }
                            break;

                        case 13: //1101
                            {
                            parsedaddress.iTelNumber[i] = 'b'; 
                            }
                            break;

                        case 14: //1110
                            {
                            parsedaddress.iTelNumber[i] = 'c';
                            }
                            break;

                        case 15: 
                            // Skip if 1111 is received 
                            break;

                        default:
                            parsedaddress.iTelNumber[i]=(TUint8) (tempOctet+'0');
                            break;
                        }
					}
				else
                    {
                    TUint8 tempOctet = 0;
                    octet&0xF0; // four least significant bits…
                    tempOctet = (TUint8)octet>>4;

                    switch(tempOctet)
                        {
                        case 10: // 1010
                            {
                            parsedaddress.iTelNumber[i] = '*';
                            }
                            break;

                        case 11: // 1011
                            {
                            parsedaddress.iTelNumber[i] = '#';
                            }
                            break;

                        case 12: // 1100
                            {
                            parsedaddress.iTelNumber[i] = 'a';
                            }
                            break;

                        case 13: // 1101
                            {
                            parsedaddress.iTelNumber[i] = 'b';
                            }
                            break;

                        case 14: // 1110
                            {
                            parsedaddress.iTelNumber[i] = 'c';
                            }
                            break;

                        case 15: 
                            // Skip if 1111 is received 
                            break;

                        default:
                            parsedaddress.iTelNumber[i]=(TUint8) (tempOctet+'0'); 
                            // unwanted bits zeroed in the beginning
       
                            break;
                        }
                    }
				}
			DoSetParsedAddressL(parsedaddress.iTelNumber);
			}
		}
	}

void CSmsAddress::InternalizeL(RReadStream& aStream)
	{
	aStream >> iTypeOfAddress;
	HBufC* buffer=HBufC::NewL(aStream,256);
	delete iBuffer;
	iBuffer=buffer;
	} // CSmsAddress::InternalizeL


void CSmsAddress::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << iTypeOfAddress;
	aStream << *iBuffer;
	} // CSmsAddress::ExternalizeL


CSmsAddress::CSmsAddress(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs):
	iCharacterSetConverter(aCharacterSetConverter),
	iFs(aFs),
	iTypeOfAddress(EGsmSmsTONUnknown, EGsmSmsNPIISDNTelephoneNumberingPlan)
	{
	} // CSmsAddress::CSmsAddress


void CSmsAddress::NewBufferL(TInt aLength)
	{
	LOGGSMU1("CSmsAddress::NewBufferL()");

    HBufC* buffer=HBufC::NewL(aLength);
    delete iBuffer;
    iBuffer=buffer;
    iBuffer->Des().SetLength(aLength);
    iBuffer->Des().FillZ();
	}


void CSmsAddress::DoSetParsedAddressL(const TDesC& aAddress)
	{
	LOGGSMU2("CSmsAddress::DoSetParsedAddressL() the length of the Address [Length = %d", aAddress.Length());

	TInt length=aAddress.Length();
	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
	    (length && (aAddress[0]!='+')))
		{
		NewBufferL(length+1);
		iBuffer->Des()[0]='+';
		TPtr ptr((TText*) (iBuffer->Des().Ptr()+1),length,length);
		ptr.Copy(aAddress);
		}
	else
		{
		NewBufferL(length);
		iBuffer->Des().Copy(aAddress);
		}
	} // CSmsAddress::DoSetParsedAddressL


TSmsServiceCenterTimeStamp::TSmsServiceCenterTimeStamp()
	{
	iTimeZoneNumQuarterHours = 0;
	} // TSmsServiceCenterTimeStamp::TSmsServiceCenterTimeStamp


void TSmsServiceCenterTimeStamp::SetTimeOffset(TInt aNumQuarterHours)
	{
	__ASSERT_DEBUG((aNumQuarterHours>=-KSmsMaxTimeZoneNumQuarterHours) && (aNumQuarterHours<=KSmsMaxTimeZoneNumQuarterHours),Panic(KGsmuPanicNumQuarterHoursOutOfRange));
	iTimeZoneNumQuarterHours=aNumQuarterHours;
	} // TSmsServiceCenterTimeStamp::SetTimeOffset


TUint8* TSmsServiceCenterTimeStamp::EncodeL(TUint8* aPtr) const
    {
    LOGGSMU1("TSmsServiceCenterTimeStamp::EncodeL()");

    TInt numquarterhours=iTimeZoneNumQuarterHours;

    TInt timeZoneOffsetInSeconds = numquarterhours * CSmsMessage::E15MinutesRepresentedInSeconds;
    TTimeIntervalSeconds offsetFromUTCToLocal(timeZoneOffsetInSeconds);

    TTime time = iTime;
    time += offsetFromUTCToLocal;

    TDateTime datetime=time.DateTime();

    TSmsOctet octet;
    octet.FillSemiOctets(datetime.Year()%100);
    aPtr=octet.EncodeL(aPtr);
    octet.FillSemiOctets(datetime.Month()+1);
    aPtr=octet.EncodeL(aPtr);
    octet.FillSemiOctets(datetime.Day()+1);
    aPtr=octet.EncodeL(aPtr);
    octet.FillSemiOctets(datetime.Hour());
    aPtr=octet.EncodeL(aPtr);
    octet.FillSemiOctets(datetime.Minute());
    aPtr=octet.EncodeL(aPtr);
    octet.FillSemiOctets(datetime.Second());
    aPtr=octet.EncodeL(aPtr);

    TInt signbit=ESmsTimeZonePositive;
    if (numquarterhours<0)
        {
        numquarterhours=-numquarterhours;
        signbit=ESmsTimeZoneNegative;
        }

    TSmsOctet timezone;
    timezone.FillSemiOctets(numquarterhours);
    timezone=timezone|signbit;
    return timezone.EncodeL(aPtr);
    } // TSmsServiceCenterTimeStamp::EncodeL


void TSmsServiceCenterTimeStamp::DecodeL(TGsmuLex8& aPdu, TInt& aTimeError)
	{
	LOGGSMU1("TSmsServiceCenterTimeStamp::DecodeL()");

	TSmsOctet octet;
	octet.DecodeL(aPdu);
	TInt year=octet.SemiOctetsToNum();
	if (year>95)
		year+=1900;
	else
		year+=2000;
	octet.DecodeL(aPdu);
	TInt month=octet.SemiOctetsToNum();
	octet.DecodeL(aPdu);

	TInt day=octet.SemiOctetsToNum();
	octet.DecodeL(aPdu);
	TInt hour=octet.SemiOctetsToNum();
	octet.DecodeL(aPdu);
	TInt minute=octet.SemiOctetsToNum();
	octet.DecodeL(aPdu);
	TInt second=octet.SemiOctetsToNum();

    TDateTime datetime;
    aTimeError = datetime.Set(year,(TMonth) (month-1),day-1,hour,minute,second,0);

    TSmsOctet timezone;
    timezone.DecodeL(aPdu);

    TInt signBit = (timezone&ESmsTimeZoneSignBitMask) ?  ESmsTimeZoneNegative : ESmsTimeZonePositive;
    timezone=timezone &(~ESmsTimeZoneSignBitMask); // clear sign bit

    TInt offsetToUTCInSeconds = 0;
    if (timezone.SemiOctetsToNum() <= KSmsMaxTimeZoneNumQuarterHours)
        {
        offsetToUTCInSeconds = ((TInt) timezone.SemiOctetsToNum()) * CSmsMessage::E15MinutesRepresentedInSeconds;
        if (signBit == ESmsTimeZoneNegative)    
            {
            offsetToUTCInSeconds = -offsetToUTCInSeconds;
            }

        TTimeIntervalSeconds offsetToUTC(offsetToUTCInSeconds) ;      

        if (aTimeError == KErrNone)
            {
            TTime time = datetime;    	
            time -= offsetToUTC;
            iTime = time;
    	
            iTimeZoneNumQuarterHours=(signBit == ESmsTimeZonePositive) ? timezone.SemiOctetsToNum(): -timezone.SemiOctetsToNum();
            }
            
        }
    else // Time zone out of range, set to 0 per 23.040 4.4.0 Section 9.2.3.11
        {
    	if (aTimeError == KErrNone)
            {    		
            iTime = datetime;    	
    	    iTimeZoneNumQuarterHours=0;
    	    }            
        }
	} // TSmsServiceCenterTimeStamp::DecodeL


void TSmsServiceCenterTimeStamp::InternalizeL(RReadStream& aStream)
	{
	TInt64 time;
	aStream >> time;
	iTime=time;
	iTimeZoneNumQuarterHours=aStream.ReadInt32L();
	} // TSmsServiceCenterTimeStamp::InternalizeL


void TSmsServiceCenterTimeStamp::ExternalizeL(RWriteStream& aStream) const
	{
	aStream << iTime.Int64();
	aStream.WriteInt32L(iTimeZoneNumQuarterHours);
	} // TSmsServiceCenterTimeStamp::ExternalizeL


TSmsValidityPeriod::TSmsValidityPeriod(TSmsFirstOctet& aFirstOctet):
	iFirstOctet(aFirstOctet),
	iTimeIntervalMinutes(EOneDayUnitInMinutes)
	{
	} // TSmsValidityPeriod::TSmsValidityPeriod


TTime TSmsValidityPeriod::Time() const
	{
	LOGGSMU1("TSmsValidityPeriod::Time()");

	TTime time;
	time.UniversalTime();
	time+=iTimeIntervalMinutes;
	return time;
	} // TSmsValidityPeriod::Time


TUint8* TSmsValidityPeriod::EncodeL(TUint8* aPtr) const
	{
	LOGGSMU1("TSmsValidityPeriod::EncodeL()");

	TInt validityperiodformat=ValidityPeriodFormat();
	switch (validityperiodformat)
		{
		case (TSmsFirstOctet::ESmsVPFNone):
			break;
		case (TSmsFirstOctet::ESmsVPFInteger):
			{
			TInt timeintervalminutes=iTimeIntervalMinutes.Int();
			__ASSERT_DEBUG((timeintervalminutes>=EFiveMinuteUnitInMinutes) && (timeintervalminutes<=63*EOneWeekUnitLimitInMinutes),Panic(KGsmuPanicValidityPeriodOutOfRange));
			TSmsOctet octet;
			if (timeintervalminutes<=EFiveMinuteUnitLimitInMinutes)
                octet=((timeintervalminutes/EFiveMinuteUnitInMinutes)-1);
			else if (timeintervalminutes<=EHalfHourUnitLimitInMinutes)
                octet=(((timeintervalminutes-(EHalfHourUnitLimitInMinutes/2))/EHalfHourUnitInMinutes)+EFiveMinuteUnitLimit);

			else if (timeintervalminutes<=EOneDayUnitLimitInMinutes)
                octet=((timeintervalminutes/EOneDayUnitInMinutes)+166);
			else
                octet=((timeintervalminutes/EOneWeekUnitInMinutes)+192);

			aPtr=octet.EncodeL(aPtr);
			break;
			}
		case (TSmsFirstOctet::ESmsVPFSemiOctet):
			{
			TSmsServiceCenterTimeStamp timestamp;
			timestamp.SetTime(Time());

	 		TTimeIntervalSeconds timeIntervalInSeconds(User::UTCOffset());
			timestamp.SetTimeOffset(timeIntervalInSeconds.Int() / CSmsMessage::E15MinutesRepresentedInSeconds);

			aPtr=timestamp.EncodeL(aPtr);
			break;
			}
		default:
            __ASSERT_DEBUG(EFalse,Panic(KGsmuPanicUnsupportedValidityPeriodFormat));
			User::Leave(KErrGsmSMSTPVPFNotSupported);
            break;
		};
	return aPtr;
	} // TSmsValidityPeriod::EncodeL
	
TUint8* TSmsValidityPeriod::EncodeL(TUint8* aPtr, const TEncodeParams* aEncodeParams) const
	{
	LOGGSMU1("TSmsValidityPeriod::EncodeL()");

	TInt validityperiodformat=ValidityPeriodFormat();
	switch (validityperiodformat)
		{
		case (TSmsFirstOctet::ESmsVPFNone):
			break;
		case (TSmsFirstOctet::ESmsVPFInteger):
			{
			TInt timeintervalminutes=iTimeIntervalMinutes.Int();
			__ASSERT_DEBUG((timeintervalminutes>=EFiveMinuteUnitInMinutes) && (timeintervalminutes<=63*EOneWeekUnitLimitInMinutes),Panic(KGsmuPanicValidityPeriodOutOfRange));
			TSmsOctet octet;
			if (timeintervalminutes<=EFiveMinuteUnitLimitInMinutes)
                octet=((timeintervalminutes/EFiveMinuteUnitInMinutes)-1);
			else if (timeintervalminutes<=EHalfHourUnitLimitInMinutes)
                octet=(((timeintervalminutes-(EHalfHourUnitLimitInMinutes/2))/EHalfHourUnitInMinutes)+EFiveMinuteUnitLimit);

			else if (timeintervalminutes<=EOneDayUnitLimitInMinutes)
                octet=((timeintervalminutes/EOneDayUnitInMinutes)+166);
			else
                octet=((timeintervalminutes/EOneWeekUnitInMinutes)+192);

			aPtr=octet.EncodeL(aPtr);
			break;
			}
		case (TSmsFirstOctet::ESmsVPFSemiOctet):
			{			
			//The reason TSmsValidityPeriod::EncodeL(TUint8* aPtr, const TEncodeParams* aEncodeParams) was
			//created was to allow the CSmsMessage's time stamp to be used when generating the validity time.
			//The CSmsMessage's time stamp is typically created when the message is constructed by the SMS Stack client.
			//This means the validity time is based from the point the SMS Stack client actually sends the message, rather
			//than the SMS Stack encodes it
						
			TSmsServiceCenterTimeStamp timestamp;
			timestamp.SetTime( *aEncodeParams->iTimeStamp + iTimeIntervalMinutes ); 									    		    		    		    		    

	 		TTimeIntervalSeconds timeIntervalInSeconds( *aEncodeParams->iTimeIntervalInSeconds );
			timestamp.SetTimeOffset(timeIntervalInSeconds.Int() / CSmsMessage::E15MinutesRepresentedInSeconds);

			aPtr=timestamp.EncodeL(aPtr);
			break;
			}
		default:
            __ASSERT_DEBUG(EFalse,Panic(KGsmuPanicUnsupportedValidityPeriodFormat));
			User::Leave(KErrGsmSMSTPVPFNotSupported);
            break;
		};
	return aPtr;
	} // TSmsValidityPeriod::EncodeL	

void TSmsValidityPeriod::DecodeL(TGsmuLex8& aPdu)
	{
	LOGGSMU1("TSmsValidityPeriod::DecodeL()");

	TInt validityperiodformat=ValidityPeriodFormat();
	switch (validityperiodformat)
		{
		case (TSmsFirstOctet::ESmsVPFNone):
			break;
		case (TSmsFirstOctet::ESmsVPFInteger):
			{
			TSmsOctet octet;
			octet.DecodeL(aPdu);
            if (octet<=EFiveMinuteUnitLimit)
                iTimeIntervalMinutes=(octet+1)*EFiveMinuteUnitInMinutes;
			else if (octet<=EHalfHourUnitLimit)
                iTimeIntervalMinutes=((EOneDayUnitInMinutes/2)+((octet-EFiveMinuteUnitLimit)*EHalfHourUnitInMinutes));
			else if (octet<=EOneDayUnitLimit)
                iTimeIntervalMinutes=(octet-166)*EOneDayUnitInMinutes;
			else
                iTimeIntervalMinutes=(octet-192)*EOneWeekUnitInMinutes;
			break;
			}
		case (TSmsFirstOctet::ESmsVPFSemiOctet):
			{
			TSmsServiceCenterTimeStamp timestamp;
			TInt timeError;
			timestamp.DecodeL(aPdu, timeError);
			User::LeaveIfError(timeError);
			TTime time;
			time.UniversalTime();
			timestamp.Time().MinutesFrom(time,iTimeIntervalMinutes);
			break;
			}
		default:
            __ASSERT_DEBUG(EFalse,Panic(KGsmuPanicUnsupportedValidityPeriodFormat));
			User::Leave(KErrGsmSMSTPVPFNotSupported);
            break;
		};
	} // TSmsValidityPeriod::DecodeL


void TSmsValidityPeriod::InternalizeL(RReadStream& aStream)
	{
	TInt timeintervalinminutes=aStream.ReadInt32L();
	iTimeIntervalMinutes=timeintervalinminutes;
	} // TSmsValidityPeriod::InternalizeL


void TSmsValidityPeriod::ExternalizeL(RWriteStream& aStream) const
	{
	aStream.WriteInt32L(iTimeIntervalMinutes.Int());
	} // TSmsValidityPeriod::ExternalizeL


CSmsInformationElement* CSmsInformationElement::NewL(TSmsInformationElementIdentifier aIdentifier,const TDesC8& aData)
	{
	LOGGSMU1("CSmsInformationElement::NewL()");

	CSmsInformationElement* informationelement=new(ELeave) CSmsInformationElement(aIdentifier);
	CleanupStack::PushL(informationelement);
	informationelement->ConstructL(aData);
	CleanupStack::Pop();
	return informationelement;
	} // CSmsInformationElement::NewL


CSmsInformationElement* CSmsInformationElement::NewL()
	{
	LOGGSMU1("CSmsInformationElement::NewL()");

	CSmsInformationElement* informationelement=new(ELeave) CSmsInformationElement(ESmsIEIConcatenatedShortMessages8BitReference);
	CleanupStack::PushL(informationelement);
	TPtrC8 data;
	informationelement->ConstructL(data);
	CleanupStack::Pop();
	return informationelement;
	} // CSmsInformationElement::NewL


/**
 *  Destructor.
 */
CSmsInformationElement::~CSmsInformationElement()
	{
	delete iData;
	} // CSmsInformationElement::NewL


/**
 *  Gets the Information Element data.
 *  
 *  @return Information Element data
 *  @capability None
 */
EXPORT_C TPtr8 CSmsInformationElement::Data()
	{
	LOGGSMU1("CSmsInformationElement::Data()");

	return iData->Des();
	} // CSmsInformationElement::Data


/**
 *  Gets the (const) Information Element data.
 *  
 *  @return Information Element data
 *  @capability None
 */
EXPORT_C const TDesC8& CSmsInformationElement::Data() const
	{
	LOGGSMU1("CSmsInformationElement::Data()");

	return *iData;
	} // CSmsInformationElement::Data


/**
 *  Gets the Information Element Identifier.
 *  
 *  @return Information Element Identifier
 *  @capability None
 */
EXPORT_C CSmsInformationElement::TSmsInformationElementIdentifier CSmsInformationElement::Identifier() const
	{
	return TSmsId(TInt(iIdentifier));
	} // CSmsInformationElement::TSmsInformationElementIdentifier


TUint8* CSmsInformationElement::EncodeL(TUint8* aPtr) const
	{
	LOGGSMU1("CSmsInformationElement::EncodeL()");

	TSmsOctet id=iIdentifier;
	aPtr=id.EncodeL(aPtr);
	TSmsOctet informationelementlength=iData->Des().Length();
	aPtr=informationelementlength.EncodeL(aPtr);
	Mem::Copy(aPtr,iData->Des().Ptr(),informationelementlength);
	aPtr+=TInt(informationelementlength);
	return aPtr;
	} // CSmsInformationElement::EncodeL


void CSmsInformationElement::DecodeL(TGsmuLex8& aPdu)
	{
	LOGGSMU1("CSmsInformationElement::DecodeL()");

	TSmsOctet id;
	id.DecodeL(aPdu);
	iIdentifier=static_cast<TSmsInformationElementIdentifier>((TInt)id);

	TSmsOctet informationelementlength;
	informationelementlength.DecodeL(aPdu);

 	switch(iIdentifier)
 	{
 	case (ESmsIEIConcatenatedShortMessages8BitReference):
 		if(informationelementlength !=3)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEISpecialSMSMessageIndication):
 		if(informationelementlength !=2)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEIApplicationPortAddressing8Bit):
 		if(informationelementlength !=2)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEIApplicationPortAddressing16Bit):
 		if(informationelementlength !=4)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEISMSCControlParameters):
 		if(informationelementlength !=1)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEIUDHSourceIndicator):
 		if(informationelementlength !=1)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEIConcatenatedShortMessages16BitReference):
 		if(informationelementlength !=4)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEIRFC822EmailHeader):
 		if(informationelementlength !=1)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
  	case (ESmsHyperLinkFormat):
 		if(informationelementlength !=4)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
  	case (ESmsNationalLanguageSingleShift):
 		if(informationelementlength != 1)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
  	case (ESmsNationalLanguageLockingShift):
 		if(informationelementlength != 1)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	case (ESmsIEISIMToolkitSecurityHeaders1):
 	case (ESmsIEISIMToolkitSecurityHeaders2):
 	case (ESmsIEISIMToolkitSecurityHeaders3):
 	case (ESmsIEISIMToolkitSecurityHeaders4):
 	case (ESmsIEISIMToolkitSecurityHeaders5):
 	case (ESmsIEISIMToolkitSecurityHeaders6):
 	case (ESmsIEISIMToolkitSecurityHeaders7):
 	case (ESmsIEISIMToolkitSecurityHeaders8):
 	case (ESmsIEISIMToolkitSecurityHeaders9):
 	case (ESmsIEISIMToolkitSecurityHeaders10):
 	case (ESmsIEISIMToolkitSecurityHeaders11):
 	case (ESmsIEISIMToolkitSecurityHeaders12):
 	case (ESmsIEISIMToolkitSecurityHeaders13):
 	case (ESmsIEISIMToolkitSecurityHeaders14):
 	case (ESmsIEISIMToolkitSecurityHeaders15):
 	case (ESmsIEISIMToolkitSecurityHeaders16):
 	if(informationelementlength !=0)
 			User::Leave(KErrGsmSMSTpduNotSupported);
 		break;
 	default:
 		break;
 	}

	const TPtrC8 data(aPdu.NextAndIncL(informationelementlength));
	NewDataL(informationelementlength);
	TPtr8 ptr(iData->Des());
	ptr.Copy(data);
	} // CSmsInformationElement::DecodeL


void CSmsInformationElement::InternalizeL(RReadStream& aStream)
	{
	TSmsOctet id;
	aStream >> id;
	iIdentifier=static_cast<TSmsInformationElementIdentifier>((TInt)id);
	delete iData;
	iData=NULL;
	iData=HBufC8::NewL(aStream,CSmsUserData::KSmsMaxUserDataSize);
	} // CSmsInformationElement::InternalizeL


void CSmsInformationElement::ExternalizeL(RWriteStream& aStream) const
	{
	TSmsOctet id;
	id=(TInt)iIdentifier;
	aStream << id;
	aStream << *iData;
	} // CSmsInformationElement::ExternalizeL


void CSmsInformationElement::ConstructL(const TDesC8& aData)
	{
	LOGGSMU1("CSmsInformationElement::ConstructL()");

	NewDataL(aData.Length());
	iData->Des().Copy(aData);
	} // CSmsInformationElement::ConstructL


void CSmsInformationElement::NewDataL(TInt aLength)
	{
	LOGGSMU1("CSmsInformationElement::NewDataL()");

	HBufC8* data=HBufC8::NewL(aLength);
	delete iData;
	iData=data;
	iData->Des().SetLength(aLength);
	} // CSmsInformationElement::NewDataL


TUint CSmsInformationElement::Length()const
	{
	LOGGSMU1("CSmsInformationElement::Length()");

	return 2+iData->Length();  // 2 stands for IEID and IEDL
	} // CSmsInformationElement::Length


/**
 *  @internalComponent
 *  
 *  This method maps an information element to an index into an array of categories.
 *  
 *  @param aId
 *  The information Element Identifier.
 *  @param aIndex
 *  The index into the array of categories
 *  @return
 *  True if the information element can be mapped.
 *  False otherwise.
 */
TBool TSmsInformationElementCategories::TranslateCategoryToIndex(TInformationElementId aId, TInt& aIndex)
    {
    LOGGSMU1("CSmsMessage::TranslateCategoryToIndex");

    TBool rc = ETrue;

    if (aId < CSmsInformationElement::ESmsIEMaximum)
        {
        switch (aId)
            {
            case CSmsInformationElement::ESmsIEIConcatenatedShortMessages8BitReference:
            case CSmsInformationElement::ESmsIEIConcatenatedShortMessages16BitReference:
            case CSmsInformationElement::ESmsIEISMSCControlParameters:
            case CSmsInformationElement::ESmsIEIRFC822EmailHeader:
                {
                aIndex = EIndexCtrlMandatoryInEveryPDUButWithValueSpecificToPDU;
                break;
                }
            case CSmsInformationElement::ESmsIEISpecialSMSMessageIndication:
                {
                aIndex = EIndexCtrlMandatoryInEveryPDUMultipleInstancesPerPDU;
                break;
                }
            case CSmsInformationElement::ESmsHyperLinkFormat:
                {
                aIndex = EIndexCtrlMultipleInstancesAllowed;
                break;
                }
            case CSmsInformationElement::ESmsNationalLanguageSingleShift:
            case CSmsInformationElement::ESmsNationalLanguageLockingShift:
                {
                aIndex = EIndexCtrlOptionalInEveryPDUWithValueSpecificToPDU;
                break;
                }
            case CSmsInformationElement::ESmsReplyAddressFormat:
                {
                aIndex = EIndexCtrlMandatoryIn1stPDUOnly;
                break;
                }
            case CSmsInformationElement::ESmsEnhanceVoiceMailInformation:
                {
                aIndex = EIndexCtrlSingleInstanceOnly;
                break;
                }
            case CSmsInformationElement::ESmsEnhancedTextFormatting:
            case CSmsInformationElement::ESmsEnhancedPredefinedSound:
            case CSmsInformationElement::ESmsEnhancedUserDefinedSound:
            case CSmsInformationElement::ESmsEnhancedPredefinedAnimation:
            case CSmsInformationElement::ESmsEnhancedLargeAnimation:
            case CSmsInformationElement::ESmsEnhancedSmallAnimation:
            case CSmsInformationElement::ESmsEnhancedLargePicture:
            case CSmsInformationElement::ESmsEnhancedSmallPicture:
            case CSmsInformationElement::ESmsEnhancedVariablePicture:
            case CSmsInformationElement::ESmsEnhancedUserPromptIndicator:
            case CSmsInformationElement::ESmsEnhancedExtendedObject:
            case CSmsInformationElement::ESmsEnhancedReusedExtendedObject:
            case CSmsInformationElement::ESmsEnhancedCompressionControl:
            case CSmsInformationElement::ESmsEnhancedODI:
            case CSmsInformationElement::ESmsEnhancedStandardWVG:
            case CSmsInformationElement::ESmsEnhancedCharacterSizeWVG:
            case CSmsInformationElement::ESmsEnhancedextendedObjectDataRequest:
                {
                aIndex = EIndexEmsInformationElement;
                break;
                }
            case CSmsInformationElement::ESmsIEIReserved:
            case CSmsInformationElement::ESmsIEIValueNotUsed:
                {
                rc = EFalse;
                break;
                }
            default:
                {
                aIndex = EIndexCtrlMandatoryInEveryPDUAndWithIdenticalValues;
                break;
                }
            }
        }
    else
        {
        rc = EFalse;
        LOGGSMU3("CSmsMessage::TranslateCategoryToIndex id = %d, found = %d", aId, rc);
        }
    return rc;
    } // TSmsInformationElementCategories::TranslateCategoryToIndex


/**
 *  @internalComponent
 *  
 *  This method gets an information element identifier's category.
 *  
 *  @param aId
 *  The information Element Identifier.
 *  @param aCategory
 *  The category of information element.
 *  @return
 *  ETrue if successful, EFalse if an information identifier is unknown or cannot
 *  be mapped.
 */
TBool TSmsInformationElementCategories::GetCategoryDefinition(TInformationElementId aId, TInformationElementCategory& aCategory)
    {
    LOGGSMU1("TSmsInformationElementCategories::GetCategoryDefinition");
    TInt index;

    if (TranslateCategoryToIndex(aId,index))
        {
        aCategory = categories[index];
        }
    else
        {
        LOGGSMU2("TSmsInformationElementCategories::GetCategoryDefinition, Failure, aId = %d", aId);
        return EFalse;
        }

    return ETrue;
    } // TSmsInformationElementCategories::GetCategoryDefinition


const TSmsInformationElementCategories::TInformationElementCategory TSmsInformationElementCategories::categories[TSmsInformationElementCategories::ENumberOfIndices] =
    {
    TSmsInformationElementCategories::EEmsInformationElement,                           // EDefaultEMSIndex
    TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUAndWithIdenticalValues,   // EDefaultControlIndex
    TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU,  // EIndexForSpecialSMSMessageIndication, Concatenated Short Messages
    TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU,// EIndexForIRFC822EmailHeader, Application Port Addresses
    TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly,                       // EIndexReplyAddressFormat
    TSmsInformationElementCategories::ECtrlSingleInstanceOnly,                          // EIndexEnhanceVoiceMailInformation
    TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed                     // EIndexForHyperLinkFormat
    };


CSmsUserData* CSmsUserData::NewL(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsFirstOctet& aFirstOctet,const TSmsDataCodingScheme& aDataCodingScheme)
	{
	LOGGSMU1("CSmsUserData::NewL()");

	CSmsUserData* userdata=new(ELeave) CSmsUserData(aCharacterSetConverter,aFs,aFirstOctet,aDataCodingScheme);
	CleanupStack::PushL(userdata);
	userdata->ConstructL();
	CleanupStack::Pop();
	return userdata;
	} // CSmsUserData::NewL


/**
 *  Destructor.
 */
CSmsUserData::~CSmsUserData()
    {
    iInformationElementArray.ResetAndDestroy();
    delete iBody;
    } // CSmsUserData::NewL


/**
 *  Gets an information element by index.
 *  
 *  @param aIndex Index of the information element within the User Data
 *  @return Information element
 *  @capability None
 */
EXPORT_C  CSmsInformationElement& CSmsUserData::InformationElement(TInt aIndex) const
	{
	LOGGSMU1("CSmsUserData::InformationElement()");

	return *iInformationElementArray[aIndex];
	} // CSmsUserData::InformationElement


CSmsInformationElement*& CSmsUserData::InformationElementPtr(TInt aIndex)
    {
    LOGGSMU1("CSmsUserData::InformationElementPtr()");

    return iInformationElementArray[aIndex];
    } // CSmsUserData::InformationElementPtr


/**
 *  Gets the index of an information element.
 *  
 *  @param aIdentifier An information element Identifier to search for
 *  @param aIndex The index within the User Data of the information element (if
 *  found). If more than 1 instance of this information element exists, then
 *  the 1st instance will be returned.
 *  
 *  Use InformationELementIndexL to get all elements.
 *  @return True if aIdentifier is found in the User Data
 *  @capability None
 */
EXPORT_C TBool CSmsUserData::InformationElementIndex(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier,TInt& aIndex) const
	{
	LOGGSMU1("CSmsUserData::InformationElementIndex()");

	TBool found=EFalse;
	TInt count=NumInformationElements();
	for (TInt i=0; (!found) && (i<count); i++)
		if (InformationElement(i).Identifier()==aIdentifier)
			{
			found=ETrue;
			aIndex=i;
			}
	return found;
	} // CSmsUserData::InformationElementIndex


/**
 *  Gets the last index of an information element.
 *  
 *  @param aIdentifier An information element Identifier to search for
 *  @param aIndex The index within the User Data of the information element (if
 *  found). If more than 1 instance of this information element exists, then
 *  the last instance will be returned.
 *  
 *  Use InformationELementIndexL to get all elements.
 *  @return True if aIdentifier is found in the User Data
 *  @capability None
 */
EXPORT_C TBool CSmsUserData::InformationElementLastIndex(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier,TInt& aIndex) const
	{
	LOGGSMU1("CSmsUserData::InformationElementLastIndex()");

	TBool found=EFalse;
	TInt count=NumInformationElements();
	for (TInt i=count-1; (!found) && (i>=0); i--)
		if (InformationElement(i).Identifier()==aIdentifier)
			{
			found=ETrue;
			aIndex=i;
			}
	return found;
	} // CSmsUserData::InformationElementLastIndex


/**
 *  @internalComponent
 *  
 *  Locates every information element of type aIdentifier and
 *  stores its location index in the output array aIndices.
 *  
 *  @param aIdentifer
 *  The information element Identifier to search for
 *  @param aIndices
 *  A collection containing the location index for each information element of this type.
 */
void CSmsUserData::InformationElementIndicesL(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier, CArrayFixFlat<TInt>& aIndices) const
    {
    LOGGSMU1("CSmsUserData::InformationElementIndicesL()");

    aIndices.Reset();
    
	TInt count=NumInformationElements();
	for (TInt i=0; i<count; i++)
	    {
    	if (InformationElement(i).Identifier()==aIdentifier)
            {
            aIndices.AppendL(i);
            }
        }
    } // CSmsUserData::InformationElementIndicesL


/**
 *  Note that whilst a pointer to the aIe is passed as an
 *  input argument, the information element is still owned
 *  by the calling function, regardless of the return code.
 *  @param aInformationElement An EMS Information Element
 */
TBool CSmsUserData::EmsInformationElementWillFitL(CEmsInformationElement* aIe,CSmsEMSBufferSegmenter& aSeg,TUint& aCharsAddedToCurrentPDU)
	{
	LOGGSMU1("CSmsUserData::EmsInformationElementWillFitL()");

	// Before using an EmsInformationElement polymorphically as an SmsIE,
	// we need to make sure that the IE has been encoded
	aIe->EncodeInformationElementL();
	iInformationElementArray.AppendL(aIe);

	TInt sizeLeft=MaxPackedUDUnitsInBodyRemaining();
	iInformationElementArray.Delete(iInformationElementArray.Count()-1);
	if(sizeLeft==0 && iBody && (iBody->Length() > 0) && (*iBody)[iBody->Length()-1] == KSms7BitAlphabetEscapeChar)
	{
		--aCharsAddedToCurrentPDU;
		--aSeg.iElementsExtracted;
		TPtr8 ptr(iBody->Des());
		ptr.Delete(iBody->Length()-1,1);
		--sizeLeft;
	}
	return sizeLeft>=0;
	} // CSmsUserData::EmsInformationElementWillFitL


/**
 *  Tests whether the control information element will fit in the current PDU.
 *  
 *  Note that whilst a pointer to the aIe is passed as an
 *  input argument, the information element is still owned
 *  by the calling function, regardless of the return code.
 *  
 *  @param aInformationElement A pointer to an information Element
 *  @capability None
 */
TBool CSmsUserData::ControlInformationElementWillFitL(CSmsInformationElement* aIe)
    {
    LOGGSMU1("CSmsUserData::ControlInformationElementWillFitL()");

    if (aIe == NULL)
        {
        User::Leave(KErrGeneral);
        }

    TSmsInformationElementCategories::TInformationElementCategory category;

    if (TSmsInformationElementCategories::GetCategoryDefinition(aIe->Identifier(), category) == EFalse  ||
    	category == TSmsInformationElementCategories::EEmsInformationElement)
        {
        User::Leave(KErrArgument);
        }

    iInformationElementArray.AppendL(aIe);

    TInt sizeLeft=MaxPackedUDUnitsInBodyRemaining();
    iInformationElementArray.Delete(iInformationElementArray.Count()-1);

    // Not considering whether escape characters exist in the buffer
    // as control information elements do not add text to the buffer.

    return sizeLeft>=0;
    } // CSmsUserData::ControlInformationElementWillFitL


/**
 *  Adds an information element.
 *  This method can be used to create information elements in the range:
 *  00 - 09 - i.e. Control Information Elements
 *  It can be used to create information elements in the following ranges
 *  (on the assumption that the information element is intended to be encoded into
 *  every PDU):
 *  24 - 25 - i.e. National Language Encodings
 *  70 - 7F - i.e. SIM Tool Kit Security Headers
 *  80 - 9F - i.e  SMS to SME specific use
 *  C0 - CF - i.e. SC specific use
 *  
 *  Information elements in the following ranges should not be
 *  added using this interface. Instead they should be added using
 *  the following identified interfaces:
 *  0A-1F - Use the interfaces provided to support EMS Elements
 *  20 - Use the interfaces provided for Email in CSmsMessage
 *  21 - Use the interface provided by CSmsHyperLinkOperations
 *  22 - Use the interface provided by CSmsReplyAddressOperations
 *  23 - Use the interface provided by CSmsEnhancedVoiceMailOperations
 *  
 *  This interface should not be used for information element in the following
 *  ranges, these are reserved for future use in TS23.040 V6.5.0 and their
 *  characteristics and repeatability have not yet been defined.
 *  26-6F
 *  A0-BF
 *  E0-FF
 *  
 *  @param aIdentifier An information element Identifier for aData
 *  @param aData The information element to add to the User Data
 *  @leave
 *  KErrNotSupported if the information element is not supported via this interface.
 *  @capability None
 */
EXPORT_C void CSmsUserData::AddInformationElementL(TSmsId aIdentifier,const TDesC8& aData)
    {
    LOGGSMU1("CSmsUserData::AddInformationElementL");

    if  ((aIdentifier >= 0x21) && (aIdentifier <= 0x23) ||
         (aIdentifier >= 0x26) && (aIdentifier <= 0x6F) ||
         (aIdentifier >= 0xA0) && (aIdentifier <= 0xBF) ||
         (aIdentifier >= 0xE0) && (aIdentifier <= 0xFF))
        {
        User::Leave(KErrNotSupported);
        }
    UpdateInformationElementArrayL(aIdentifier, aData);

    } // CSmsUserData::AddInformationElementL


/**
 *  @internalComponent
 *  
 *  Either adds an information element to
 *  iInformationElementArray.
 *  
 *  @param aIdentifier An information element Identifier for aData
 *  @param aData The information element to add to the User Data
 */
void CSmsUserData::UpdateInformationElementArrayL(TSmsId aIdentifier,const TDesC8& aData)
    {
    LOGGSMU1("CSmsUserData::UpdateInformationElementsL");

    TInt count=NumInformationElements();
    if(!CEmsFactory::Supported(aIdentifier))
        {
        for (TInt i=0; i<count; i++)
            {
 	        if (InformationElement(i).Identifier()==aIdentifier)
                {
                TSmsInformationElementCategories::TInformationElementCategory category;
                
                if (TSmsInformationElementCategories::GetCategoryDefinition(aIdentifier, category) == EFalse)
                	{
                	User::Leave(KErrArgument);
                	}

                switch (category)
                    {
                    case TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU:
                        {
                        if (InformationElement(i).Identifier() == CSmsInformationElement::ESmsIEISpecialSMSMessageIndication)
                            {
                            LOGGSMU3("CSmsUserData::AddInformationElementL1 category = %d, identifier = %d",category,aIdentifier);

                            //if Msg type is the same, swap with the most recent value
                            if ((InformationElement(i).Data()[0] & ((TUint8) EGsmSmsSpecialMessageIndicationTypeMask)) ==
                                (aData[0] & ((TUint8) EGsmSmsSpecialMessageIndicationTypeMask)))
                                {
                                User::Leave(KErrAlreadyExists);
                                }
                            }
                        else
                            {
                            LOGGSMU4("CSmsUserData::AddInformationElementL3 category = %d, identifier = %d, data = %S",category,aIdentifier, &aData);
                            User::Leave(KErrArgument);
                            }
                        break;
                        }
                    case TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUAndWithIdenticalValues:
                    case TSmsInformationElementCategories::ECtrlMandatoryIn1stPDUOnly:
                    case TSmsInformationElementCategories::ECtrlSingleInstanceOnly:
                        {
                        LOGGSMU3("CSmsUserData::AddInformationElementL4 category = %d, identifier = %d",category,aIdentifier);
                        User::Leave(KErrAlreadyExists);
                        break;
                        }
                    case TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
                        {
                        LOGGSMU3("CSmsUserData::AddInformationElementL5 category = %d, identifier = %d",category,aIdentifier);
                        break;
                        }
                    case TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU:
                        {
                        LOGGSMU3("CSmsUserData::AddInformationElementL6 category = %d, identifier = %d",category,aIdentifier);
                        User::Leave(KErrAlreadyExists);
                        // currently the email header is updated in:
                        // void CSmsMessage::DecodeBufferL(CArrayPtr<CSmsPDU>& aSmsPDUArray,CSmsBufferBase& aBuffer)
                        break;
                        }
                    default:
                        {
                        LOGGSMU3("CSmsUserData::AddInformationElementL8 category = %d, identifier = %d",category,aIdentifier);
                        User::Leave(KErrNotSupported);
                        break;
                        }
                    }
                }
            }
        }

    	CSmsInformationElement* informationElement=CSmsInformationElement::NewL(aIdentifier,aData);
    	CleanupStack::PushL(informationElement);
    	iInformationElementArray.AppendL(informationElement);
    	CleanupStack::Pop();
    	SetHeaderPresent(ETrue);
    } // CSmsUserData::UpdateInformationElementArrayL


void CSmsUserData::AddEmsInformationElementL(CEmsInformationElement* aIe)
	{
	LOGGSMU1("CSmsUserData::AddEmsInformationElementL()");

	// Before using an EmsInformationElement polymorphically as an SmsIE,
	// we need to make sure that the IE has been encoded
	aIe->EncodeInformationElementL();
	iInformationElementArray.AppendL(aIe);
	SetHeaderPresent(ETrue);
	} // CSmsUserData::AddEmsInformationElementL


/**
 *  Removes an information element at the specified index.
 *  
 *  @param aIndex Information element index
 *  @capability None
 */
EXPORT_C void CSmsUserData::RemoveInformationElement(TInt aIndex)
	{
	LOGGSMU1("CSmsUserData::RemoveInformationElement()");
	// Since iInformationElementArray[aIndex] pointer is removed from iInformationElementArray, there is no double free issue.
	// coverity[double_free]
	delete iInformationElementArray[aIndex];
	iInformationElementArray[aIndex] = NULL;
	iInformationElementArray.Delete(aIndex);

	if (NumInformationElements()==0)
		{
		SetHeaderPresent(EFalse);
		}
	} // CSmsUserData::RemoveInformationElement


TInt CSmsUserData::MaxPackedUDUnitsInBodyRemaining() const
	{
	LOGGSMU1("CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");

	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits();
	TInt maxPackedUDUnitsInBody=0;
	if (iDataCodingScheme.TextCompressed()||(iDataCodingScheme.Alphabet()!=TSmsDataCodingScheme::ESmsAlphabet7Bit))
		{
		maxPackedUDUnitsInBody=KSmsMaxUserDataSize-totalHeaderLengthInUDLUnits;
		if (iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabetUCS2)
			{
			// Cannot split unicode character across PDU boundary
			maxPackedUDUnitsInBody&=~1;
			}
		}
	else // 7-bit
		{
		maxPackedUDUnitsInBody=(8*KSmsMaxUserDataSize)/7-totalHeaderLengthInUDLUnits;
		}

	if (iBody)
		return maxPackedUDUnitsInBody-=iBody->Length();
	return maxPackedUDUnitsInBody;
	} // CSmsUserData::MaxPackedUDUnitsInBodyRemaining


TInt CSmsUserData::MaxPackedUDUnitsInBodyRemaining(TUint aIELen) const
	{
	LOGGSMU1("CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");

	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits(aIELen);
	TInt maxPackedUDUnitsInBody=0;
	if (iDataCodingScheme.TextCompressed()||(iDataCodingScheme.Alphabet()!=TSmsDataCodingScheme::ESmsAlphabet7Bit))
		{
		maxPackedUDUnitsInBody=KSmsMaxUserDataSize-totalHeaderLengthInUDLUnits;
		if (iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabetUCS2)
			{
			// Cannot split unicode character across PDU boundary
			maxPackedUDUnitsInBody&=~1;
			}
		}
	else // 7-bit
		{
		maxPackedUDUnitsInBody=(8*KSmsMaxUserDataSize)/7-totalHeaderLengthInUDLUnits;
		}

	if (iBody)
		return maxPackedUDUnitsInBody-=iBody->Length();
	return maxPackedUDUnitsInBody;
	} // CSmsUserData::MaxPackedUDUnitsInBodyRemaining


/**
 *  @capability None
 */
EXPORT_C TInt CSmsUserData::MaxBodyLengthInChars() const
	{
	LOGGSMU1("CSmsUserData::MaxBodyLengthInChars()");

	TInt totalheaderlengthinudlunits=TotalHeaderLengthInUDLUnits();
	TInt maxbodylengthinchars=0;
	if (iDataCodingScheme.TextCompressed())
		{
		maxbodylengthinchars=KSmsMaxUserDataSize-totalheaderlengthinudlunits;
		}
	else
		{
		switch (iDataCodingScheme.Alphabet())
			{
			case (TSmsDataCodingScheme::ESmsAlphabet7Bit):
				{
				maxbodylengthinchars=(8*KSmsMaxUserDataSize)/7-totalheaderlengthinudlunits;
				break;
				}
			case (TSmsDataCodingScheme::ESmsAlphabet8Bit):
				{
				maxbodylengthinchars=KSmsMaxUserDataSize-totalheaderlengthinudlunits;
				break;
				}
			case (TSmsDataCodingScheme::ESmsAlphabetUCS2):
				{
				maxbodylengthinchars=(KSmsMaxUserDataSize-totalheaderlengthinudlunits)/2;
				break;
				}
			default:
			    LOGGSMU1("CSmsUserData::MaxBodyLengthInChars() WARNING! default case has been reached");
                break;
 			}
		}
	return maxbodylengthinchars;
	} // CSmsUserData::MaxBodyLengthInChars


/**
 *  Gets the unpacked User Data Elements.
 *  
 *  @return Unpacked User Data Elements
 *  @capability None
 */
EXPORT_C TPtrC8 CSmsUserData::Body() const
	{
	LOGGSMU1("CSmsUserData::Body()");

	return iBody->Des();
	} // CSmsUserData::Body


/**
 *  Sets the User Data (unpacked).
 *  
 *  @param aBody Unpacked User Data Elements
 *  @capability None
 */
EXPORT_C void CSmsUserData::SetBodyL(const TDesC8& aBody)
	{
	LOGGSMU1("CSmsUserData::SetBodyL()");

	//Some tests fail with this line in, despite it being a valid condition!
	//__ASSERT_DEBUG(aBody.Length() <= MaxBodyLengthInChars(), User::Leave(KErrTooBig));

	NewBodyL(aBody.Length());
	iBody->Des().Copy(aBody);
	} // CSmsUserData::SetBodyL


void CSmsUserData::AppendBodyL(const TDesC8& aBody)
	{
	LOGGSMU1("CSmsUserData::AppendBodyL()");

	if (iBody)
		{
		//Some tests fail with this line in, despite it being a valid condition!
		//__ASSERT_DEBUG(aBody.Length() + iBody->Length() <= MaxBodyLengthInChars(), User::Leave(KErrTooBig));

		iBody = iBody->ReAllocL(aBody.Length()+iBody->Length());
		iBody->Des().Append(aBody);
		}
	else
		{
		SetBodyL(aBody);
		}
	} // CSmsUserData::AppendBodyL


/**
 *  Tests if the character is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aChar  Character to investigate.
 * 
 *  @return  ETrue if the character is supported.
 * 
 *  @note Since the function is based on the old behaviour (pre-PREQ2090)
 *        it does not accept a downgraded character or alternative encoding
 *        as being supported.
 *
 *  @capability None
 */
EXPORT_C TBool CSmsUserData::IsSupportedL(TChar aChar)
	{
	LOGGSMU1("CSmsUserData::IsSupportedL()");

	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
	TBool result=converter->IsSupportedL(aChar);
	CleanupStack::PopAndDestroy();

	return result;
	} // CSmsUserData::IsSupportedL


/**
 *  Tests if the descriptor text is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aDes                                 Text string to check.
 *  @param aNumberOfUnconvertibleCharacters     Exit param for the number of
 *                                              characters unconvertible.
 *  @param aIndexOfFirstUnconvertibleCharacter  Exit param for the first
 *                                              unconverted character.
 * 
 *  @return  ETrue if the character is supported.
 *
 *  @capability None
 */
EXPORT_C TBool CSmsUserData::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
                                          TInt& aIndexOfFirstUnconvertibleCharacter) const
	{
	LOGGSMU1("[1] CSmsUserData::IsSupportedL()");

	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
	TBool result=converter->IsSupportedL(aDes, aNumberOfUnconvertibleCharacters,
			                             aIndexOfFirstUnconvertibleCharacter);
	CleanupStack::PopAndDestroy();

	return result;
	} // CSmsUserData::IsSupportedL


/**
 *  Tests if the descriptor text is supported by the current character set.
 *  This function can be used with 7bit and 8bit alphabets.
 * 
 *  @param aDes                                 Text string to check.
 *  @param aEncoding                            Alternative encoding method.
 *  @param aNumberOfUnconvertibleCharacters     Exit param for the number of
 *                                              characters unconvertible.
 *  @param aNumberOfDowngradedCharacters        Exit param for the number of
 *                                              downgraded characters.
 *  @param aNumberRequiringAlternativeEncoding  Exit param for the number of
 *                                              characters requiring use of
 *                                              the alternative encoder.
 *  @param aIndexOfFirstUnconvertibleCharacter  Exit param for the first
 *                                              unconverted character.
 * 
 *  @return  ETrue if the character is supported.
 *
 *  @capability None
 */
EXPORT_C TBool CSmsUserData::IsSupportedL(const TDesC& aDes, TSmsEncoding aEncoding,
										  TInt& aNumberOfUnconvertibleCharacters,
                                          TInt& aNumberOfDowngradedCharacters,
                                          TInt& aNumberRequiringAlternativeEncoding,
                                          TInt& aIndexOfFirstUnconvertibleCharacter) const
	{
	LOGGSMU1("[2] CSmsUserData::IsSupportedL()");

	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
	TBool result=converter->IsSupportedL(aDes, aEncoding,
			                             aNumberOfUnconvertibleCharacters,
			                             aNumberOfDowngradedCharacters,
			                             aNumberRequiringAlternativeEncoding,
			                             aIndexOfFirstUnconvertibleCharacter);
	CleanupStack::PopAndDestroy();

	return result;
	} // CSmsUserData::IsSupportedL


TUint8* CSmsUserData::EncodeL(TUint8* aPtr) const
	{
	LOGGSMU1("CSmsUserData::EncodeL()");

	__ASSERT_DEBUG(0<=MaxPackedUDUnitsInBodyRemaining(),Panic(KGsmuPanicUserDataBodyTooLong));
	// Encode the user data length
	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits();
	TSmsOctet userDataLength=totalHeaderLengthInUDLUnits+TSmsOctet(BodyLengthInUDLUnits());
	aPtr=userDataLength.EncodeL(aPtr);
	// Encode any user data header
	if (HeaderPresent())
		{
		TSmsOctet headerLength=HeaderLength();
		aPtr=headerLength.EncodeL(aPtr);
		TInt numInformationElements=NumInformationElements();
		for (TInt i=0; i<numInformationElements; i++)
			aPtr=iInformationElementArray[i]->EncodeL(aPtr);
		}
	// Pack the user data body
	TInt startBit=0;
	if (iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabet7Bit)
		startBit=(totalHeaderLengthInUDLUnits*7)%8;
	TSmsAlphabetPacker packer(iDataCodingScheme.Alphabet(),IsBinaryData(),startBit);
	TPtr8 ptr((TUint8*)aPtr,0,packer.PackedOctetsRequiredL(Body().Length()));
	aPtr+=packer.PackL(ptr,Body());
	return aPtr;
	} // CSmsUserData::EncodeL


void CSmsUserData::DecodeL(TGsmuLex8& aPdu)
	{
	DecodeL(aPdu, EFalse);
	}

void CSmsUserData::DecodeL(TGsmuLex8& aPdu, TBool aAcceptTruncation)
	{	
	LOGGSMU1("CSmsUserData::DecodeL()");

	// Reset current data
	iInformationElementArray.ResetAndDestroy();
	// Decode the user data
	TSmsOctet userDataLength;
	userDataLength.DecodeL(aPdu);
	TSmsOctet headerLength;
	// Decode any user data header
	TBool headerPresent=HeaderPresent();
	/*
	if (headerPresent || IsHeaderPresent(aPtr,dataLength))
	*/
	if (headerPresent)
		{
		headerLength.DecodeL(aPdu);
		if ((1+headerLength)>KSmsMaxUserDataSize)
			User::Leave(KErrGsmSMSTpduNotSupported);
		while (HeaderLength()<headerLength)
			{
			CSmsInformationElement* informationelement=CSmsInformationElement::NewL();
			CleanupStack::PushL(informationelement);
			informationelement->DecodeL(aPdu);
			iInformationElementArray.AppendL(informationelement);
			CleanupStack::Pop(informationelement);
			}
		if (HeaderLength()!=headerLength)
			User::Leave(KErrGsmSMSTpduNotSupported);
		}
	// Decode the body - make sure we have enough buffer
	TInt headerLengthInUDLUnits=TotalHeaderLengthInUDLUnits();
	TInt bodyLengthInUDLUnits=userDataLength-headerLengthInUDLUnits;

	if(bodyLengthInUDLUnits <=0)
	{
		NewBodyL(0);
		return;
	}

	NewBodyL(bodyLengthInUDLUnits);

	// Unpack the body
	TInt startBit=0;
	if (iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabet7Bit)
		startBit=(headerLengthInUDLUnits*7)%8;
	TSmsAlphabetPacker unpacker(iDataCodingScheme.Alphabet(),IsBinaryData(),startBit);
	TInt bodyLengthInOctets=unpacker.PackedOctetsRequiredL(bodyLengthInUDLUnits);
	TPtr8 destPtr((TUint8*)iBody->Des().Ptr(),0,bodyLengthInUDLUnits);

	const TPtrC8 sourcePtr(aPdu.NextWithNoIncL(bodyLengthInOctets,aAcceptTruncation));
	if ( aAcceptTruncation && sourcePtr.Length() < bodyLengthInOctets)
		{
		// field was truncated in an acceptable situation (User Data in Status Report PDU)
		bodyLengthInUDLUnits = unpacker.NumUDUnitsL(sourcePtr.Length());
		}
	unpacker.UnpackL(sourcePtr,destPtr,bodyLengthInUDLUnits);

	//@note No need to call aPdu.IncL() because CSmsUserData is always at the end of a PDU
	} // CSmsUserData::DecodeL


void CSmsUserData::InternalizeL(RReadStream& aStream)
	{
	iInformationElementArray.ResetAndDestroy();
	TInt numiformationelements=aStream.ReadInt32L();
	// The "header present" flag must mirror whether information elements are present, and
	// the parental iFirstOctet should already be set by its InternalizeL()
	__ASSERT_DEBUG(((!HeaderPresent() && numiformationelements == 0) || (HeaderPresent() && numiformationelements > 0)), Panic(KGsmuPanicInformationElementIndexOutOfRange));
	for (TInt i=0; i<numiformationelements; i++)
		{
		CSmsInformationElement* informationelement=CSmsInformationElement::NewL();
		CleanupStack::PushL(informationelement);
		aStream >> *informationelement;
		iInformationElementArray.AppendL(informationelement);
		CleanupStack::Pop();
		}
	delete iBody;
	iBody=NULL;
	iBody=HBufC8::NewL(aStream,KSmsMaxUserDataLengthInChars);
	} // CSmsUserData::InternalizeL


void CSmsUserData::ExternalizeL(RWriteStream& aStream) const
	{
	TInt numiformationelements=iInformationElementArray.Count();
	aStream.WriteInt32L(numiformationelements);
	for (TInt i=0; i<numiformationelements; i++)
		aStream << *iInformationElementArray[i];
	aStream << *iBody;
	} // CSmsUserData::ExternalizeL


CSmsUserData::CSmsUserData(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsFirstOctet& aFirstOctet,const TSmsDataCodingScheme& aDataCodingScheme):
    iCharacterSetConverter(aCharacterSetConverter),
    iFs(aFs),
    iFirstOctet(aFirstOctet),
    iDataCodingScheme(aDataCodingScheme),
    iInformationElementArray(8)
    {
    } // CSmsUserData::CSmsUserData


void CSmsUserData::ConstructL()
	{
	LOGGSMU1("CSmsUserData::ConstructL()");

	NewBodyL(0);
	} // CSmsUserData::ConstructL


/**
 *  Duplicates this CSmsUserData object.
 * 
 *  @return  Pointer to the newly created CSmsUserData object.
 */
CSmsUserData* CSmsUserData::DuplicateL(TSmsFirstOctet& aFirstOctet,
									   const TSmsDataCodingScheme& aDataCodingScheme) const
	{
	LOGGSMU1("CSmsUserData::DuplicateL()");

	CSmsUserData*  userdata = CSmsUserData::NewL(iCharacterSetConverter, iFs,
	                                             aFirstOctet, aDataCodingScheme);
	CleanupStack::PushL(userdata);

	userdata->SetBodyL(Body());

	for (TInt ie = 0;  ie < iInformationElementArray.Count();  ie++)
		{
		CSmsInformationElement*  oldIE = iInformationElementArray[ie];

		if (CEmsFactory::Supported(oldIE->Identifier()))
			{
			CEmsInformationElement*  newIE = static_cast<CEmsInformationElement*>(oldIE)->DuplicateL();
			
			CleanupStack::PushL(newIE);
			userdata->AddEmsInformationElementL(newIE);
			CleanupStack::Pop(newIE);
			}
		else
			{
			userdata->UpdateInformationElementArrayL(oldIE->Identifier(), oldIE->Data());
			}
		}

	CleanupStack::Pop();

	return userdata;
	} // CSmsUserData::DuplicateL


TInt CSmsUserData::HeaderLength() const
	{
	LOGGSMU1("CSmsUserData::HeaderLength()");

	TInt numinformationelements=NumInformationElements();
	TInt headerlength=0;
	for (TInt i=0; i<numinformationelements; i++)
		headerlength+=iInformationElementArray[i]->Length();
	return headerlength;
	} // CSmsUserData::HeaderLength


TInt CSmsUserData::TotalHeaderLengthInUDLUnits() const
	{
	LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits()");

	TInt totalheaderlengthinudlunits=0;
	if (iInformationElementArray.Count()>0)
		{
		TInt totalheaderlength=1+HeaderLength();
		if (iDataCodingScheme.TextCompressed())
			{
			totalheaderlengthinudlunits=totalheaderlength;
			}
		else
			{
			switch(iDataCodingScheme.Alphabet())
				{
				case (TSmsDataCodingScheme::ESmsAlphabet7Bit):
					{
					totalheaderlengthinudlunits=((8*totalheaderlength)+6)/7; //  Rounds up
					break;
					}
				case (TSmsDataCodingScheme::ESmsAlphabet8Bit):
				case (TSmsDataCodingScheme::ESmsAlphabetUCS2):
					{
					totalheaderlengthinudlunits=totalheaderlength;
					break;
					}
				default:
				    LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits() WARNING default case has been reached");
                    break;
				}
			}
		}
	return totalheaderlengthinudlunits;
	} // CSmsUserData::TotalHeaderLengthInUDLUnits


TInt CSmsUserData::TotalHeaderLengthInUDLUnits(TInt aIElen) const
	{
	LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits()");

		TInt totalheaderlengthinudlunits=0;
		TInt totalheaderlength=aIElen;

		if (iInformationElementArray.Count()>0)
			totalheaderlength+=HeaderLength();

		if(totalheaderlength)totalheaderlength+=1; //UDHL

		if (iDataCodingScheme.TextCompressed())
			{
			totalheaderlengthinudlunits=totalheaderlength;
			}
		else
			{
			switch(iDataCodingScheme.Alphabet())
				{
				case (TSmsDataCodingScheme::ESmsAlphabet7Bit):
					{
					totalheaderlengthinudlunits=((8*totalheaderlength)+6)/7; //  Rounds up
					break;
					}
				case (TSmsDataCodingScheme::ESmsAlphabet8Bit):
				case (TSmsDataCodingScheme::ESmsAlphabetUCS2):
					{
					totalheaderlengthinudlunits=totalheaderlength;
					break;
					}
				default:
                    break;
				}
			}
		return totalheaderlengthinudlunits;
	} // CSmsUserData::TotalHeaderLengthInUDLUnits


TInt CSmsUserData::BodyLengthInUDLUnits() const
	{
	LOGGSMU1("CSmsUserData::BodyLengthInUDLUnits()");

	return iBody->Des().Length();
	} // CSmsUserData::BodyLengthInUDLUnits


void CSmsUserData::NewBodyL(TInt aLength)
	{
	LOGGSMU1("CSmsUserData::NewBodyL()");


		HBufC8* body=HBufC8::NewL(aLength);
		delete iBody;
		iBody=body;
		iBody->Des().SetLength(aLength);

	} // CSmsUserData::NewBodyL


TBool CSmsUserData::HeaderPresent() const
	{
	LOGGSMU1("CSmsUserData::HeaderPresent()");

	return (iFirstOctet&TSmsFirstOctet::ESmsUDHIMask)==TSmsFirstOctet::ESmsUDHIHeaderPresent;
	} // CSmsUserData::HeaderPresent


void CSmsUserData::SetHeaderPresent(TBool aHeaderPresent)
	{
	LOGGSMU1("CSmsUserData::SetHeaderPresent()");

	iFirstOctet=aHeaderPresent? (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderPresent: (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderNotPresent;
	} // CSmsUserData::SetHeaderPresent


TBool CSmsUserData::IsBinaryData() const
	{
	LOGGSMU1("CSmsUserData::IsBinaryData()");

	TInt index=0;
	return (iDataCodingScheme.TextCompressed()) ||
			((iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabet8Bit) &&
			(InformationElementIndex(CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit,index) ||
	        InformationElementIndex(CSmsInformationElement::ESmsIEIApplicationPortAddressing16Bit,index)));
	} // CSmsUserData::IsBinaryData


/**
 *  Converts type of number and numbering plan identification information
 *  from the type of address parameter to the NMobilePhone::TMobileTON
 *  and NMobilePhone::TMobileNPI format.
 *  
 *  @return aTon The number type
 *  @return aNpi The numbering plan
 *  
 *  @capability None
 */
EXPORT_C void TGsmSmsTypeOfAddress::ConvertToETelMM(NMobilePhone::TMobileTON& aTon,NMobilePhone::TMobileNPI& aNpi) const
    {
    LOGGSMU1("TGsmSmsTypeOfAddress::ConvertToETelMM()");

    switch (TON())
    {
		case EGsmSmsTONInternationalNumber:
            {
            aTon = (NMobilePhone::EInternationalNumber);
            break;
            }
        case EGsmSmsTONNationalNumber:
            {
            aTon = (NMobilePhone::ENationalNumber);
            break;
            }
        case EGsmSmsTONNetworkSpecificNumber:
            {
            aTon = (NMobilePhone::ENetworkSpecificNumber);
            break;
            }
        case EGsmSmsTONSubscriberNumber:
            {
            aTon = (NMobilePhone::ESubscriberNumber);
            break;
            }
        case EGsmSmsTONAlphaNumeric:
            {
            aTon = (NMobilePhone::EAlphanumericNumber);
            break;
            }
        case EGsmSmsTONAbbreviatedNumber:
            {
            aTon = (NMobilePhone::EAbbreviatedNumber);
            break;
            }

        default:
            {
            aTon = (NMobilePhone::EUnknownNumber);
            break;
            }
		}

    switch (NPI())
		{
        case EGsmSmsNPIISDNTelephoneNumberingPlan:
            {
            aNpi = (NMobilePhone::EIsdnNumberPlan);
            break;
            }
        case EGsmSmsNPIDataNumberingPlan:
            {
            aNpi = (NMobilePhone::EDataNumberPlan);
            break;
            }
        case EGsmSmsNPITelexNumberingPlan:
            {
            aNpi = (NMobilePhone::ETelexNumberPlan);
            break;
            }
        case EGsmSmsNPINationalNumberingPlan:
            {
            aNpi = (NMobilePhone::ENationalNumberPlan);
            break;
            }
        case EGsmSmsNPIPrivateNumberingPlan:
            {
            aNpi = (NMobilePhone::EPrivateNumberPlan);
            break;
            }
        case EGsmSmsNPIERMESNumberingPlan:
            {
            aNpi = (NMobilePhone::EERMESNumberPlan);
            break;
            }

        default:
            {
            aNpi = (NMobilePhone::EUnknownNumberingPlan);
            break;
            }
		}
	} // NMobilePhone::TMobileNPI


/**
 *  Converts type of number and numbering plan identification information
 *  from the NMobilePhone::TMobileTON and NMobilePhone::TMobileNPI format
 *  to the type of address parameter.
 *  
 *  @param aTon The number type
 *  @param aNpi The numbering plan
 *  
 *  @capability None
 */
EXPORT_C void TGsmSmsTypeOfAddress::SetFromETelMM(NMobilePhone::TMobileTON aTon,NMobilePhone::TMobileNPI aNpi)
    {
    LOGGSMU1("TGsmSmsTypeOfAddress::SetFromETelMM()");

    switch (aTon)
    {
		case NMobilePhone::EInternationalNumber:
            {
            SetTON( EGsmSmsTONInternationalNumber );
            break;
            }
        case NMobilePhone::ENationalNumber:
            {
            SetTON( EGsmSmsTONNationalNumber );
            break;
            }
        case NMobilePhone::ENetworkSpecificNumber:
            {
            SetTON( EGsmSmsTONNetworkSpecificNumber );
            break;
            }
        case NMobilePhone::ESubscriberNumber:
            {
            SetTON( EGsmSmsTONSubscriberNumber );
            break;
            }
        case NMobilePhone::EAlphanumericNumber:
            {
            SetTON( EGsmSmsTONAlphaNumeric );
            break;
            }
        case NMobilePhone::EAbbreviatedNumber:
            {
            SetTON( EGsmSmsTONAbbreviatedNumber );
            break;
            }

        default:
            {
            SetTON( EGsmSmsTONUnknown );
            break;
            }
		}

    switch (aNpi)
		{
        case NMobilePhone::EIsdnNumberPlan:
            {
            SetNPI( EGsmSmsNPIISDNTelephoneNumberingPlan );
            break;
            }
        case NMobilePhone::EDataNumberPlan:
            {
            SetNPI( EGsmSmsNPIDataNumberingPlan );
            break;
            }
        case NMobilePhone::ETelexNumberPlan:
            {
            SetNPI( EGsmSmsNPITelexNumberingPlan );
            break;
            }
        case NMobilePhone::ENationalNumberPlan:
            {
            SetNPI( EGsmSmsNPINationalNumberingPlan );
            break;
            }
        case NMobilePhone::EPrivateNumberPlan:
            {
            SetNPI( EGsmSmsNPIPrivateNumberingPlan );
            break;
            }
        case NMobilePhone::EERMESNumberPlan:
            {
            SetNPI( EGsmSmsNPIERMESNumberingPlan );
            break;
            }

        default:
            {
            SetNPI( EGsmSmsNPIUnknown );
            break;
            }
		}
	} // NMobilePhone::TMobileTON


/**
 *  @publishedAll
 *  
 *  Indicates whether this message is a Voice Mail Notification
 *  or a Voice Mail Deletion Confirmation.
 *  
 *  @return
 *  TVoiceMailInfoType, indicating whether this message is a Voice Mail
 *  Notification or a Voice Mail Deletion Confirmation.
 *  
 *  @capability None
 */
EXPORT_C TVoiceMailInfoType CEnhancedVoiceMailBoxInformation::Type() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Type()");

	return iType;
	} // CEnhancedVoiceMailBoxInformation::Type


/**
 *  @publishedAll
 *  
 *  Sets the subscriber profile per 23.040 v6.5 Section 9.2.3.24.13.1.
 *  
 *  @param aProfile
 *  The required subscriber profile
 *  
 *  @capability None
 */
EXPORT_C void CEnhancedVoiceMailBoxInformation::SetProfile(TSmsMessageProfileType aProfile)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetProfile()");

	iProfile = aProfile;
	} // CEnhancedVoiceMailBoxInformation::SetProfile


/**
 *  @publishedAll
 *  
 *  Gets the subscriber profile per 23.040 v6.5 Section 9.2.3.24.13.1.
 *  
 *  @param aProfile
 *  The current subscriber profile
 *  
 *  @capability None
 */
EXPORT_C TSmsMessageProfileType CEnhancedVoiceMailBoxInformation::Profile() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Profile()");

	return iProfile;
	} // CEnhancedVoiceMailBoxInformation::Profile


/**
 *  @publishedAll
 *  
 *  Configures the storage directive
 *  
 *  @param aIsStored
 *  Set to True if the SM is to be stored in the ME or USIM,
 *  False is the SM is to be discarded.
 *  
 *  @capability None
 */
EXPORT_C void CEnhancedVoiceMailBoxInformation::SetStorage(TBool aIsStored)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetStorage()");

	iStorage = aIsStored;
	} // CEnhancedVoiceMailBoxInformation::SetStorage


/**
 *  @publishedAll
 *  
 *  Indicates whether the SM is to be stored or discarded
 *  
 *  @return
 *  True if the SM is to be stored in the ME or USIM,
 *  False is the SM is to be discarded.
 *  
 *  @capability None
 */
EXPORT_C TBool CEnhancedVoiceMailBoxInformation::Store() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Store()");

	return iStorage;
	} // CEnhancedVoiceMailBoxInformation::Store


/**
 *  @publishedAll
 *  
 *  Used to set or reset the voice mail status to almost full.
 *  
 *  @param aIsStored
 *  Set to True the voice mail system is almost full.
 *  Set to False otherwise.
 *  
 *  @capability None
 */
EXPORT_C void CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity(TBool aIsAlmostFull)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity()");

	iAlmostFull = aIsAlmostFull;
	} // CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity


/**
 *  @publishedAll
 *  
 *  Indicates whether the voice mail system is almost at full capacity.
 *  
 *  @return
 *  True, if the voice mail system is almost full.
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity()");

	return iAlmostFull;
	} // CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity


/**
 *  @publishedAll
 *  
 *  Used to set or reset the voice mail status to full.
 *  
 *  @param aIsStored
 *  Set to True the voice mail system is full.
 *  Set to False otherwise.
 *  
 *  @capability None
 */
EXPORT_C void CEnhancedVoiceMailBoxInformation::SetMaximumCapacity(TBool aIsFull)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetMaximumCapacity()");

	iFull = aIsFull;
	} // CEnhancedVoiceMailBoxInformation::SetMaximumCapacity


/**
 *  @publishedAll
 *  
 *  Indicates whether the voice mail status is full.
 *  
 *  @return
 *  True if the voice mail system is almost full.
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CEnhancedVoiceMailBoxInformation::MaximumCapacity() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::MaximumCapacity()");

	return iFull;
	} // CEnhancedVoiceMailBoxInformation::MaximumCapacity


/**
 *  @publishedAll
 *  
 *  Indicates whether the message contains extension bytes
 *  
 *  @return
 *  True if the message contains extension bytes.
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CEnhancedVoiceMailBoxInformation::ExtensionIndicator() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ExtensionIndicator()");

	return iExtensionIndicator;
	} // CEnhancedVoiceMailBoxInformation::ExtensionIndicator


void CEnhancedVoiceMailBoxInformation::NewBufferL(TInt aLength)
	{
	LOGGSMU2("CEnhancedVoiceMailBoxInformation::NewBufferL, length = %d",aLength);

	HBufC* buffer=HBufC::NewL(aLength);
	delete iAccessAddress;
	iAccessAddress=buffer;
	iAccessAddress->Des().SetLength(aLength);
	iAccessAddress->Des().FillZ();
	} // CEnhancedVoiceMailBoxInformation::NewBufferL


/**
 *  @publishedAll
 *  
 *  Used to set the voice mail box number, overwriting any pre-existing number.
 *  
 *  @param aAddress
 *  The voice mail box address.
 *  
 *  @capability None
 */
EXPORT_C void  CEnhancedVoiceMailBoxInformation::SetAccessAddressL(const TDesC& aAddress)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetAccessAddressL()");

	TInt length=aAddress.Length();
	NewBufferL(length);
	iAccessAddress->Des().Copy(aAddress);

	const TGsmSmsTypeOfNumber typeofnumber=length && (iAccessAddress->Des()[0]=='+')? EGsmSmsTONInternationalNumber: EGsmSmsTONUnknown;
	iTypeOfAddress.SetTON(typeofnumber);
	} // CEnhancedVoiceMailBoxInformation::SetAccessAddressL


/**
 *  @publishedAll
 *  
 *  Retrieves the voice mail box number.
 *  
 *  @return
 *  A pointer to the voice mail box number.
 *  
 *  @capability None
 */
EXPORT_C TPtrC CEnhancedVoiceMailBoxInformation::AccessAddress() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::AccessAddress()");

	TPtrC ptr;
	if (iAccessAddress)
	    ptr.Set(iAccessAddress->Des());
	return ptr;
	} // CEnhancedVoiceMailBoxInformation::AccessAddress


/**
 *  @publishedAll
 *  
 *  Used to set the voice mail box number as a parsed address
 *  
 *  @param aParsedAddress
 *  The parsed address to be used as the voice mail box number.
 *  
 *  @capability None
 */
EXPORT_C void  CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL(const TGsmSmsTelNumber& aParsedAddress)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL()");

   	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
	DoSetParsedAddressL(aParsedAddress.iTelNumber);
	} // CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL


/**
 *  @publishedAll
 *  
 *  Used to get the voice mail box number as a parsed address.
 *  
 *  @param aParsedAddress
 *  An output parameter which is set to the parsed address.
 *  
 *  @capability None
 */
EXPORT_C void  CEnhancedVoiceMailBoxInformation::ParsedAccessAddress(TGsmSmsTelNumber& aParsedAddress) const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ParsedAccessAddress()");

	aParsedAddress.iTypeOfAddress = iTypeOfAddress;

	TInt maxparsedlength=aParsedAddress.iTelNumber.MaxLength();

	if (iTypeOfAddress.TON()==EGsmSmsTONAlphaNumeric)
		{
		TInt parsedlength=AccessAddress().Length();
		if (parsedlength>maxparsedlength)
			parsedlength=maxparsedlength;
		aParsedAddress.iTelNumber.Copy(AccessAddress().Mid(0,parsedlength));
		}
	else
		{
		aParsedAddress.iTelNumber.SetLength(maxparsedlength);

		TInt length=iAccessAddress->Des().Length();
		TInt parsedlength=0;
		for (TInt i=0; (i<length) && (parsedlength<maxparsedlength); i++)
			{
			TText ch=iAccessAddress->Des()[i];
			if ((ch>='0') && (ch<='9'))
				{
				aParsedAddress.iTelNumber[parsedlength]=(TUint8) ch;
				parsedlength++;
				}
			}

		aParsedAddress.iTelNumber.SetLength(parsedlength);
		}
	} // CEnhancedVoiceMailBoxInformation::ParsedAccessAddress


void CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL(const TDesC& aAddress)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL()");

	TInt length=aAddress.Length();
	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
	    (length && (aAddress[0]!='+')))
		{
		NewBufferL(length+1);
		iAccessAddress->Des()[0]='+';
		TPtr ptr((TText*) (iAccessAddress->Des().Ptr()+1),length,length);
		ptr.Copy(aAddress);
		}
	else
		{
		NewBufferL(length);
		iAccessAddress->Des().Copy(aAddress);
		}
	} // CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL


/**
 *  @publishedAll
 *  
 *  Sets the number of voice messages to a value in the range 0 to 255.
 *  
 *  @param aNumber
 *  The number of voice messages.
 *  
 *  @capability None
 */
EXPORT_C void   CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages(TUint8 aNumber)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages()");

	iNumberOfVoiceMessages=aNumber;
	} // CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages


/**
 *  @publishedAll
 *  
 *  Retrieves the number of voice messages that are unread.
 *  
 *  @return
 *  The number of unread voice messages.
 *  
 *  @capability None
 */
EXPORT_C TUint8 CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages() const
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages()");

	return iNumberOfVoiceMessages;
	} // CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages


TUint8* CEnhancedVoiceMailBoxInformation::EncodeL(TUint8* aPtr, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs) const
	{
	*aPtr =  (((TUint8) iType)       & EMask1Bit )       +
	        ((((TUint8) iProfile)    & EMask2Bits) << 2) +
	        ((((TUint8) iStorage)    & EMask1Bit ) << 4) +
	        ((((TUint8) iAlmostFull) & EMask1Bit ) << 5) +
	        ((((TUint8) iFull)       & EMask1Bit ) << 6) +
	         (((TUint8) iExtensionIndicator      ) << 7);

	LOGGSMU2("CEnhancedVoiceMailBoxInformation::EncodeL 1st byte = %d",*aPtr);
	aPtr++;

	// Create an address object to encode the mail box access address into the
	// format required by 23.040 v6.5.0 section 9.1.2.5.
	CSmsAddress* address = CSmsAddress::NewL(aCharacterSetConverter,aFs);
	CleanupStack::PushL(address);
	TPtrC accessAddressPtr;
	if (iAccessAddress)
	    {
		accessAddressPtr.Set(iAccessAddress->Des());
	    }
	address->SetRawAddressL(iTypeOfAddress,accessAddressPtr);
	aPtr = address->EncodeL(aPtr);
	CleanupStack::PopAndDestroy(address);

	*aPtr = (TUint8) iNumberOfVoiceMessages;
	aPtr++;

	return aPtr;
	} // CEnhancedVoiceMailBoxInformation::EncodeL


void CEnhancedVoiceMailBoxInformation::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
	{
	TUint8 Byte1 = aVoiceMailInfo.GetL();

	iType               = (TVoiceMailInfoType)       (Byte1       & EMask1Bit);
	iProfile            = (TSmsMessageProfileType ) ((Byte1 >> 2) & EMask2Bits);
	iStorage            = (TBool)                   ((Byte1 >> 4) & EMask1Bit);
	iAlmostFull         = (TBool)                   ((Byte1 >> 5) & EMask1Bit);
	iFull               = (TBool)                   ((Byte1 >> 6) & EMask1Bit);
	iExtensionIndicator = (TBool)                   ((Byte1 >> 7) & EMask1Bit);

	LOGGSMU2("CEnhancedVoiceMailBoxInformation::DecodeL 1st byte = %d", Byte1);

	// Create an address object to deccode the mail box access address from the
	// format required by 23.040 v6.5.0 section 9.1.2.5.
	CSmsAddress* decodedAddress = CSmsAddress::NewL(aCharacterSetConverter,aFs);
	CleanupStack::PushL(decodedAddress);

	// CSmsAddress::DecodeL is also used to decode source and destination addresses.
	// CSmsAddress::DecodeL expects internally that alphanumeric addresses will be size
	// CSmsAddress::KSmsAddressMaxAddressValueLength=10.
	// Need to add padding bytes to bring the address field up to the maximum size.
	const TPtrC8 remainder(aVoiceMailInfo.Remainder());

	if (remainder.Length() < CSmsAddress::KSmsAddressMaxAddressLength)
	    {
	    TBuf8<CSmsAddress::KSmsAddressMaxAddressLength> data;
	    data = remainder;
	    TInt actualLength = data.Length();
	    data.SetLength(CSmsAddress::KSmsAddressMaxAddressLength);

	    for (TUint8 j = actualLength; j < CSmsAddress::KSmsAddressMaxAddressLength; j++)
	        {
	        data[j] = 0;
	        }

	    TGsmuLex8 encodedAddress(data);
	    decodedAddress->DecodeL(encodedAddress);
	    // might want to check that aVoiceMailInfo can be incremented
	    // by encodedAddress.Offset.
	    aVoiceMailInfo.Inc(encodedAddress.Offset());
	    }
	else
	    {
	    decodedAddress->DecodeL(aVoiceMailInfo);
	    }

	TInt length=(decodedAddress->Address()).Length();
	NewBufferL(length);
	iAccessAddress->Des().Copy((decodedAddress->Address().Ptr()),length);

	iTypeOfAddress = decodedAddress->TypeOfAddress();

	CleanupStack::PopAndDestroy(decodedAddress);

	iNumberOfVoiceMessages = aVoiceMailInfo.GetL();
	LOGGSMU2("CEnhancedVoiceMailBoxInformation::DecodeL iNumberOfVoiceMessages = %d", iNumberOfVoiceMessages);
	} // CEnhancedVoiceMailBoxInformation::DecodeL


CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");

	// Consider changing this over to a Panic.
	iType               = EGsmSmsVoiceMailNotification;
	iOctet1Bit1         = EFalse;
	iProfile            = EGsmSmsProfileId1;
	iStorage            = EFalse;
	iAlmostFull         = EFalse;
	iFull               = EFalse;
	iExtensionIndicator = EFalse;
	iTypeOfAddress      = 0;
	} // CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation


CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation(TVoiceMailInfoType aTVoiceMailInfoType)
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");

	iType               = aTVoiceMailInfoType;
	iOctet1Bit1         = EFalse;
	iProfile            = EGsmSmsProfileId1;
	iStorage            = EFalse;
	iAlmostFull         = EFalse;
	iFull               = EFalse;
	iExtensionIndicator = EFalse;
	iTypeOfAddress      = 0;
	} // CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation


/**
 *  @internalComponent
 *  
 *  Prevent clients from using the copy constructor by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation(const CEnhancedVoiceMailBoxInformation&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the equality operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
TBool CEnhancedVoiceMailBoxInformation::operator==(const CEnhancedVoiceMailBoxInformation&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailBoxInformation::operator==");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    return EFalse;
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the assignment operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
void CEnhancedVoiceMailBoxInformation::operator=(const CEnhancedVoiceMailBoxInformation&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailBoxInformation::operator=");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

void CEnhancedVoiceMailBoxInformation::ConstructL()
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ConstructL()");

	NewBufferL(0);
	} // CEnhancedVoiceMailBoxInformation::ConstructL


CEnhancedVoiceMailBoxInformation::~CEnhancedVoiceMailBoxInformation()
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::~CEnhancedVoiceMailBoxInformation");
	delete iAccessAddress;
	} // CEnhancedVoiceMailBoxInformation::ConstructL


CEnhancedVoiceMailBoxInformation* CEnhancedVoiceMailBoxInformation::NewL()
	{
	LOGGSMU1("CEnhancedVoiceMailBoxInformation::NewL()");

	CEnhancedVoiceMailBoxInformation* aCEnhancedVoiceMailBoxInformation=new(ELeave) CEnhancedVoiceMailBoxInformation();
	CleanupStack::PushL(aCEnhancedVoiceMailBoxInformation);
	aCEnhancedVoiceMailBoxInformation->ConstructL();
	CleanupStack::Pop(aCEnhancedVoiceMailBoxInformation);
	return aCEnhancedVoiceMailBoxInformation;
	} // CEnhancedVoiceMailBoxInformation::NewL


/**
 *  @publishedAll
 *  
 *  Sets the message id to a value between 0 and 65535.
 *  
 *  @param aNumber
 *  The message id
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::SetMessageId(TUint16 aMessageId)
	{
	LOGGSMU1("CVoiceMailNotification::SetMessageId()");

	iMessageId = aMessageId;
	} // CVoiceMailNotification::SetMessageId


/**
 *  @publishedAll
 *  
 *  Retrieves the message id, a value in the range 0 to 65535.
 *  
 *  @return
 *  The message id,
 *  
 *  @capability None
 */
EXPORT_C TUint16 CVoiceMailNotification::MessageId() const
	{
	LOGGSMU1("CVoiceMailNotification::MessageId()");

	return iMessageId;
	} // CVoiceMailNotification::MessageId


/**
 *  @publishedAll
 *  
 *  Sets the voice mail message length to a value between 0 and 255
 *  
 *  @param aLength
 *  The voice mail message length.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::SetMessageLength(TUint8 aLength)
	{
	LOGGSMU1("CVoiceMailNotification::SetMessageLength()");

	iMessageLength=aLength;
	} // CVoiceMailNotification::SetMessageLength


/**
 *  @publishedAll
 *  
 *  Retrieves the voice mail message length, a value in the range 0 to 255.
 *  
 *  @return
 *  The voice mail message length.
 *  
 *  @capability None
 */
EXPORT_C TUint8 CVoiceMailNotification::MessageLength() const
	{
	LOGGSMU1("CVoiceMailNotification::MessageLength()");

	return iMessageLength;
	} // CVoiceMailNotification::MessageLength


/**
 *  @publishedAll
 *  
 *  Sets the number of days that the voice message will be retained to
 *  a value between 0 and 31. Values in excess of 31 will be capped at
 *  31.
 *  
 *  @param aDays
 *  The number of retention days.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::SetRetentionDays(TUint8 aDays)
	{
	LOGGSMU1("CVoiceMailNotification::SetRetentionDays()");

	if (aDays > 31)
	    {
	    iRetentionDays = 31;
	    }
	else
	    {
	    iRetentionDays = aDays;
	    }
	} // CVoiceMailNotification::SetRetentionDays


/**
 *  @publishedAll
 *  
 *  Retrieves the number of days the voice message will be retained.
 *  
 *  @return
 *  The number of days the voice message will be retained.
 *  
 *  @capability None
 */
EXPORT_C TUint8 CVoiceMailNotification::RetentionDays() const
	{
	LOGGSMU1("CVoiceMailNotification::RetentionDays()");

	return iRetentionDays;
	} // CVoiceMailNotification::RetentionDays


/**
 *  @publishedAll
 *  
 *  Sets the message priority to urgent
 *  
 *  @param aPriority
 *  Set to True if the priority is urgent,
 *  Otherwise set to False.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::SetPriorityIndication(TBool aPriority)
	{
	LOGGSMU1("CVoiceMailNotification::SetPriorityIndication()");

	iPriorityIndication=aPriority;
	} // CVoiceMailNotification::SetPriorityIndication


/**
 *  @publishedAll
 *  
 *  Retrieves the priority indication.
 *  
 *  @return
 *  True if the priority is urgent,
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CVoiceMailNotification::PriorityIndication() const
	{
	LOGGSMU1("CVoiceMailNotification::PriorityIndication()");

	return iPriorityIndication;
	} // CVoiceMailNotification::PriorityIndication


/**
 *  @publishedAll
 *  
 *  Indicates whether the voice mail notification contains extension bytes.
 *  
 *  @return
 *  True if the voice mail notification contains extension bytes.
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CVoiceMailNotification::MessageExtensionIndication() const
	{
	LOGGSMU1("CVoiceMailNotification::MessageExtensionIndication()");

	return iMessageExtensionIndicator;
	} // CVoiceMailNotification::MessageExtensionIndication


void CVoiceMailNotification::NewBufferL(TInt aLength)
	{
	LOGGSMU1("CVoiceMailNotification::NewBufferL()");

	HBufC* buffer=HBufC::NewL(aLength);
	delete iCallingLineIdentity;
	iCallingLineIdentity=buffer;
	iCallingLineIdentity->Des().SetLength(aLength);
	iCallingLineIdentity->Des().FillZ();
	} // CVoiceMailNotification::NewBufferL


/**
 *  @publishedAll
 *  
 *  Used to set the calling line idenity
 *  
 *  @param aLineIdentity
 *  
 *  @capability None
 */
EXPORT_C void  CVoiceMailNotification::SetCallingLineIdentityL(TDesC& aLineIdentity)
	{
	LOGGSMU1("CVoiceMailNotification::SetCallingLineIdentityL()");

	TInt length=aLineIdentity.Length();
	NewBufferL(length);
	iCallingLineIdentity->Des().Copy(aLineIdentity);

	const TGsmSmsTypeOfNumber typeofnumber=length && (iCallingLineIdentity->Des()[0]=='+')? EGsmSmsTONInternationalNumber: EGsmSmsTONUnknown;
	iTypeOfAddress.SetTON(typeofnumber);
	} // CVoiceMailNotification::SetCallingLineIdentityL


/**
 *  @publishedAll
 *  
 *  Retrieves the Calling Line Identity
 *  
 *  @return
 *  A pointer to the Calling Line Identity.
 *  
 *  @capability None
 */
EXPORT_C TPtrC CVoiceMailNotification::CallingLineIdentity() const
	{
	LOGGSMU1("CVoiceMailNotification::CallingLineIdentity()");

	TPtrC ptr;
	if (iCallingLineIdentity)
	    ptr.Set(iCallingLineIdentity->Des());
	return ptr;
	} // CVoiceMailNotification::CallingLineIdentity


/**
 *  @publishedAll
 *  
 *  Set the Calling Line Id as a parsed address.
 *  
 *  @param aParsedAddress
 *  The Calling Line Id as a parsed address.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::SetParsedCallingLineIdentityL(TGsmSmsTelNumber& aParsedAddress)
	{
	LOGGSMU1("CVoiceMailNotification::SetParsedCallingLineIdentityL()");

	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
	DoSetParsedAddressL(aParsedAddress.iTelNumber);
	} // CVoiceMailNotification::SetParsedCallingLineIdentityL


/**
 *  @publishedAll
 *  
 *  Gets the Calling Line Id as a parsed address.
 *  
 *  @param aParsedAddress
 *  An output parameter which is to be set to the parsed calling line ID.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailNotification::ParsedCallingLineIdentity(TGsmSmsTelNumber& aParsedAddress) const
	{
	LOGGSMU1("CVoiceMailNotification::ParsedCallingLineIdentity()");

	aParsedAddress.iTypeOfAddress = iTypeOfAddress;

	TInt maxparsedlength=aParsedAddress.iTelNumber.MaxLength();

	if (iTypeOfAddress.TON()==EGsmSmsTONAlphaNumeric)
		{
		TInt parsedlength=CallingLineIdentity().Length();
		if (parsedlength>maxparsedlength)
			parsedlength=maxparsedlength;
		aParsedAddress.iTelNumber.Copy(CallingLineIdentity().Mid(0,parsedlength));
		}
	else
		{
		aParsedAddress.iTelNumber.SetLength(maxparsedlength);

		TInt length=iCallingLineIdentity->Des().Length();
		TInt parsedlength=0;
		for (TInt i=0; (i<length) && (parsedlength<maxparsedlength); i++)
			{
			TText ch=iCallingLineIdentity->Des()[i];
			if ((ch>='0') && (ch<='9'))
				{
				aParsedAddress.iTelNumber[parsedlength]=(TUint8) ch;
				parsedlength++;
				}
			}

		aParsedAddress.iTelNumber.SetLength(parsedlength);
		}
	} // CVoiceMailNotification::ParsedCallingLineIdentity


void CVoiceMailNotification::NewExtensionL(TInt aLength)
	{
	LOGGSMU1("CVoiceMailNotification::NewExtensionL()");

	HBufC* buffer=HBufC::NewL(aLength);
	delete iExtension;
	iExtension=buffer;
	iExtension->Des().SetLength(aLength);
	iExtension->Des().FillZ();
	} // CVoiceMailNotification::NewExtensionL


/*void CVoiceMailNotification::SetExtension(TDesC& aExtension)
	{
	LOGGSMU1("CVoiceMailNotification::SetExtension()");

	TInt length=aExtension.Length();
	NewExtensionL(length);
	iExtension->Des().Copy(aExtension);
	} // CVoiceMailNotification::SetExtension

TPtrC CVoiceMailNotification::Extension() const
	{
	LOGGSMU1("CVoiceMailNotification::Extension()");

	TPtrC ptr;
	if (iExtension)
	    ptr.Set(iExtension->Des());
	return ptr;
	}*/


/**
 *  @internalComponent
 *  
 *  Determines the size of the encoded Voice Mail Notification.
 *  
 *  @param aCharacterSetConverter  A reference to a character set converter.
 *  @param aFs  A reference to the file server.
 *  @return The size of the encoded Voice Mail Notification
 *  
 *  @capability None
 */
TUint8 CVoiceMailNotification::SizeL(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
	{
	LOGGSMU1("CVoiceMailNotification::SizeL()");

	const TUint8 KTotalSizeOfFixedLengthAttributes = 4;
	TUint8 size = KTotalSizeOfFixedLengthAttributes;

	// need to find the size of the calling line ID.
	CSmsAddress* address = CSmsAddress::NewL(aCharacterSetConverter,aFs);
	CleanupStack::PushL(address);

	TPtrC callingLineIdentityPtr;
	if (iCallingLineIdentity)
	    {
		callingLineIdentityPtr.Set(iCallingLineIdentity->Des());
	    }

	address->SetRawAddressL(iTypeOfAddress,callingLineIdentityPtr);

	size += address->SizeL();
	CleanupStack::PopAndDestroy(address);

	return size;
	} // CVoiceMailNotification::SizeL


TUint8* CVoiceMailNotification::EncodeL(TUint8* aPtr, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs) const
	{
	// When changes are made to this function that affect the
	// number of bytes that are encoded, this should be reflected in
	// CVoiceMailNotification::SizeL()
	LOGGSMU1("CVoiceMailNotification::EncodeL");


	*aPtr =   (TUint8)  (iMessageId                         >> 8);  // Message Id MSB
	aPtr++;
	*aPtr =   (TUint8)   iMessageId;                                // Message Id LSB
	aPtr++;
	*aPtr =   (TUint8)   iMessageLength;
	aPtr++;
	*aPtr =   ((TUint8)  (iRetentionDays & EMask5Bits))             +
	         (((TUint8)   iPriorityIndication)               << 6)  +
	         (((TUint8)   iMessageExtensionIndicator)        << 7);
	aPtr++;

	CSmsAddress* address = CSmsAddress::NewL(aCharacterSetConverter,aFs);
	CleanupStack::PushL(address);

	TPtrC callingLineIdentityPtr;
	if (iCallingLineIdentity)
	    {
		callingLineIdentityPtr.Set(iCallingLineIdentity->Des());
	    }

	address->SetRawAddressL(iTypeOfAddress,callingLineIdentityPtr);

	aPtr = address->EncodeL(aPtr);
	CleanupStack::PopAndDestroy(address);

	return aPtr;
	} // CVoiceMailNotification::EncodeL


void CVoiceMailNotification::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
	{
	LOGGSMU1("CVoiceMailNotification::DecodeL");

	iMessageId = (((TUint16) aVoiceMailInfo.GetL()) << 8);
	iMessageId += ((TUint16) aVoiceMailInfo.GetL());

	iMessageLength=aVoiceMailInfo.GetL();

	TUint8 currentByte = aVoiceMailInfo.GetL();

	iRetentionDays             =   currentByte       & EMask5Bits;
	iPriorityIndication        = ((currentByte >> 6) & EMask1Bit);
	iMessageExtensionIndicator = ((currentByte >> 7) & EMask1Bit);

	CSmsAddress* decodedAddress = CSmsAddress::NewL(aCharacterSetConverter,aFs);
	CleanupStack::PushL(decodedAddress);

	const TPtrC8 remainder(aVoiceMailInfo.Remainder());
	// The address information element makes an assumption that aVoiceMail must
	// be of size CSmsAddress::KSmsAddressMaxAddressLength
	// Provide padding to ensure that this is the case.
	if (remainder.Length() < CSmsAddress::KSmsAddressMaxAddressLength)
	    {
	    TBuf8<CSmsAddress::KSmsAddressMaxAddressLength> data;
	    data = remainder;
	    TInt actualLength = data.Length();
	    data.SetLength(CSmsAddress::KSmsAddressMaxAddressLength);

	    for (TUint8 j = actualLength; j < CSmsAddress::KSmsAddressMaxAddressLength; j++)
	        {
	        data[j] = 0;
	        }

	    TGsmuLex8 encodedAddress(data);
	    decodedAddress->DecodeL(encodedAddress);
	    // Should be the last piece of data to be decoded
	    // The next line is included for completeness.
	    aVoiceMailInfo.Inc(encodedAddress.Offset());
	    }
	else
	    {
	    decodedAddress->DecodeL(aVoiceMailInfo);
	    }

	TInt length=(decodedAddress->Address()).Length();
	NewBufferL(length);
	iCallingLineIdentity->Des().Copy((decodedAddress->Address().Ptr()),length);

	iTypeOfAddress = decodedAddress->TypeOfAddress();

	CleanupStack::PopAndDestroy(decodedAddress);

	if (iMessageExtensionIndicator)
	    {
	    TUint8 extensionLength = aVoiceMailInfo.GetL();
	    aVoiceMailInfo.Inc(extensionLength);
	    }
	} // CVoiceMailNotification::DecodeL


/**
 *  @internalComponent
 *  
 *  Prevent clients from using the copy constructor by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
CVoiceMailNotification::CVoiceMailNotification(const CVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailNotification::CVoiceMailNotification");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the equality operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
TBool CVoiceMailNotification::operator==(const CVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailNotification::operator==");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    return EFalse;
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the assignment operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
void CVoiceMailNotification::operator=(const CVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailNotification::operator=");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

CVoiceMailNotification::CVoiceMailNotification()
	{
	LOGGSMU1("CVoiceMailNotification::CVoiceMailNotification()");

	iMessageId                 = 0;
	iMessageLength             = 0;
	iRetentionDays             = 0;
	iOctetN8Bit1               = EFalse;
	iPriorityIndication        = EFalse;
	iMessageExtensionIndicator = EFalse;
	iTypeOfAddress             = 0;
	} // CVoiceMailNotification::CVoiceMailNotification


/**
 *  @publishedAll
 *  
 *  Class Destructor
 *  
 *  @capability None
 */
EXPORT_C CVoiceMailNotification::~CVoiceMailNotification()
	{
	LOGGSMU1("CVoiceMailNotification::~CVoiceMailNotification");
	delete iCallingLineIdentity;
	delete iExtension;
	} // CVoiceMailNotification::CVoiceMailNotification


void CVoiceMailNotification::ConstructL()
	{
	LOGGSMU1("CVoiceMailNotification::ConstructL()");

	NewBufferL(0);
	NewExtensionL(0);
	} // CVoiceMailNotification::ConstructL


/**
 *  @publishedAll
 *  
 *  Class construction method.
 *  
 *  @capability None
 */
EXPORT_C CVoiceMailNotification* CVoiceMailNotification::NewL()
	{
	LOGGSMU1("CVoiceMailNotification::NewL()");

	CVoiceMailNotification* aCVoiceMailNotification=new(ELeave) CVoiceMailNotification();
	CleanupStack::PushL(aCVoiceMailNotification);
	aCVoiceMailNotification->ConstructL();
	CleanupStack::Pop(aCVoiceMailNotification);
	return aCVoiceMailNotification;
	} // CVoiceMailNotification::NewL


void CVoiceMailNotification::DoSetParsedAddressL(const TDesC& aAddress)
	{
	LOGGSMU1("CVoiceMailNotification::DoSetParsedAddressL()");

	TInt length=aAddress.Length();
	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
	    (length && (aAddress[0]!='+')))
		{
		NewBufferL(length+1);
		iCallingLineIdentity->Des()[0]='+';
		TPtr ptr((TText*) (iCallingLineIdentity->Des().Ptr()+1),length,length);
		ptr.Copy(aAddress);
		}
	else
		{
		NewBufferL(length);
		iCallingLineIdentity->Des().Copy(aAddress);
		}
	} // CVoiceMailNotification::DoSetParsedAddressL


/**
 *  @publishedAll
 *  
 *  Retrieves the number of voice message notifications contained in
 *  this information. The range is 0 to 15.
 *  
 *  @return
 *  The number of voice message notifications in this information element.
 *  
 *  @capability None
 */
EXPORT_C TUint8 CEnhancedVoiceMailNotification::NumberOfVoiceMails()
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::NumberOfVoiceMails()");

	return (TUint8) iNotifications->Count();
	} // CEnhancedVoiceMailNotification::NumberOfVoiceMails


/*void CEnhancedVoiceMailNotification::SetExtension(TDesC& aExtension)
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::SetExtension()");

	TInt length=aExtension.Length();
	NewExtensionL(length);
	iExtension->Des().Copy(aExtension);
	} // CEnhancedVoiceMailNotification::SetExtension

TPtrC CEnhancedVoiceMailNotification::Extension() const
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::Extension()");

	TPtrC ptr;
	if (iExtension)
	    ptr.Set(iExtension->Des());
	return ptr;
	}*/


/**
 *  @publishedAll
 *  
 *  Provides a reference to the collection that is used to contain the Voice Mail Notifications.
 *  A maximum of 15 voice mail confirmations is supported. If more that 15 voice mails notifications are added
 *  the CEnhancedVoiceMailNotification will not be added to the CSmsMessage by the CSmsEnhancedVoiceMailOperations
 *  class.
 *  
 *  @return
 *  A reference to the collection that is used to contain the Voice Mail Notifications.
 *  
 *  @capability None
 */
EXPORT_C RPointerArray<CVoiceMailNotification>& CEnhancedVoiceMailNotification::GetVoiceMailNotifications()
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::GetVoiceMailNotifications()");

	return *iNotifications;
	} // CEnhancedVoiceMailNotification::GetVoiceMailNotifications


void CEnhancedVoiceMailNotification::NewExtensionL(TInt aLength)
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::NewExtensionL()");

	HBufC* buffer=HBufC::NewL(aLength);
	delete iExtension;
	iExtension=buffer;
	iExtension->Des().SetLength(aLength);
	iExtension->Des().FillZ();
	} // CEnhancedVoiceMailNotification::NewExtensionL


/**
 *  @publishedAll
 *  
 *  Class construction method.
 *  
 *  @capability None
 */
EXPORT_C  CEnhancedVoiceMailNotification* CEnhancedVoiceMailNotification::NewL()
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::NewL()");

	CEnhancedVoiceMailNotification* aCEnhancedVoiceMailNotification=new(ELeave) CEnhancedVoiceMailNotification();
	CleanupStack::PushL(aCEnhancedVoiceMailNotification);
	aCEnhancedVoiceMailNotification->CEnhancedVoiceMailBoxInformation::ConstructL();
	aCEnhancedVoiceMailNotification->ConstructL();
	CleanupStack::Pop(aCEnhancedVoiceMailNotification);
	return aCEnhancedVoiceMailNotification;
	} // CEnhancedVoiceMailNotification::NewL


CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification() : CEnhancedVoiceMailBoxInformation(EGsmSmsVoiceMailNotification)
	{
	} // CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification


/**
 *  @internalComponent
 *  
 *  Prevent clients from using the copy constructor by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification(const CEnhancedVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the equality operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
TBool CEnhancedVoiceMailNotification::operator==(const CEnhancedVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailNotification::operator==");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    return EFalse;
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the assignment operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
void CEnhancedVoiceMailNotification::operator=(const CEnhancedVoiceMailNotification&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailNotification::operator=");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @publishedAll
 *  
 *  Class destructor.
 *  
 *  @capability None
 */
EXPORT_C  CEnhancedVoiceMailNotification::~CEnhancedVoiceMailNotification()
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::~CEnhancedVoiceMailNotification");
	delete iExtension;
	iNotifications->ResetAndDestroy();
	iNotifications->Close();
	delete iNotifications;
	} // CEnhancedVoiceMailNotification::operator


void CEnhancedVoiceMailNotification::ConstructL()
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::ConstructL()");

	NewExtensionL(0);
	iNotifications = new (ELeave) RPointerArray<CVoiceMailNotification>(KMaxNumberOfNotifications);
	} // CEnhancedVoiceMailNotification::ConstructL


TUint8* CEnhancedVoiceMailNotification::EncodeL(TUint8* aCurrentPtr, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs) const
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::EncodeL");

	TUint8* startPtr   = aCurrentPtr;

	aCurrentPtr = CEnhancedVoiceMailBoxInformation::EncodeL(aCurrentPtr, aCharacterSetConverter, aFs);

	TUint8 count = (TUint8)  iNotifications->Count();
	if (count > KMaxNumberOfNotifications)
	    {
	    User::Leave(KErrArgument);
	    }

	*aCurrentPtr = (count & KSmsNotificationBitMask);
	aCurrentPtr++;

	TInt16 spaceAlreadyAllocated = 0; // handle architectures whose address space increments and whose address space decrements.
	(aCurrentPtr > startPtr) ? (spaceAlreadyAllocated = aCurrentPtr - startPtr) : (spaceAlreadyAllocated = startPtr - aCurrentPtr);

	TInt16 remainingSize = (TInt16)(CEnhancedVoiceMailNotification::KSmsMaxEnhancedVoiceMailSize - spaceAlreadyAllocated);
	for (TUint i = 0; i < count; i++)
	    {
	    remainingSize -= (TInt16)(*iNotifications)[i]->SizeL(aCharacterSetConverter,aFs);
	    if (remainingSize < 0)
	        {
	        User::Leave(KErrArgument);
	        }

	    aCurrentPtr = (*iNotifications)[i]->EncodeL(aCurrentPtr, aCharacterSetConverter, aFs);
	    }

	return aCurrentPtr;
	} // CEnhancedVoiceMailNotification::EncodeL


void CEnhancedVoiceMailNotification::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
	{
	LOGGSMU1("CEnhancedVoiceMailNotification::DecodeL");

	CEnhancedVoiceMailBoxInformation::DecodeL(aVoiceMailInfo, aCharacterSetConverter, aFs);

	TUint8 numberOfNotifications = (aVoiceMailInfo.GetL() & KSmsNotificationBitMask);

	if (iExtensionIndicator)
	    {
	    TUint8 extensionLength = aVoiceMailInfo.GetL();
	    aVoiceMailInfo.Inc(extensionLength);
	    }

	for (TUint8 i = 0; i < numberOfNotifications; i++)
	    {
	    CVoiceMailNotification* voiceMailNotification = CVoiceMailNotification::NewL();
	    CleanupStack::PushL(voiceMailNotification);
	    voiceMailNotification->DecodeL(aVoiceMailInfo, aCharacterSetConverter, aFs);
	    iNotifications->AppendL(voiceMailNotification);
	    CleanupStack::Pop(voiceMailNotification);
	    }
	} // CEnhancedVoiceMailNotification::DecodeL


/**
 *  @publishedAll
 *  
 *  Sets the message ID of the specific Voice Mail message
 *  whose deletion is being confirmed.
 *  
 *  @param aMessageId
 *  The message ID of the specific voice mail message whose deletion
 *  is being confirmed.
 *  
 *  @capability None
 */
EXPORT_C void CVoiceMailDeletion::SetMessageId(TUint16 aMessageId)
	{
	LOGGSMU1("CVoiceMailDeletion::SetMessageId()");

	iMessageId=aMessageId;
	} // CVoiceMailDeletion::SetMessageId


/**
 *  @publishedAll
 *  
 *  Retrieves the message ID of the Voice Mail message
 *  whose deletion is being confirmed, range 0 to 65535.
 *  
 *  @return
 *  The message ID of the Voice Mail message whose deletion
 *  is being confirmed, range 0 to 65535.
 *  
 *  @capability None
 */
EXPORT_C TUint16 CVoiceMailDeletion::MessageId() const
	{
	LOGGSMU1("CVoiceMailDeletion::MessageId()");

	return iMessageId;
	} // CVoiceMailDeletion::MessageId


/**
 *  @publishedAll
 *  
 *  Indicates whether the voice mail deletion contains extension bytes.
 *  
 *  @return
 *  True if the voice mail deletion contains extension bytes.
 *  False otherwise.
 *  
 *  @capability None
 */
EXPORT_C TBool CVoiceMailDeletion::MessageExtensionIndication() const
	{
	LOGGSMU1("CVoiceMailDeletion::MessageExtensionIndication()");

	return iExtensionIndicator;
	} // CVoiceMailDeletion::MessageExtensionIndication


TUint8 CVoiceMailDeletion::SizeL()
	{
	LOGGSMU1("CVoiceMailDeletion::SizeL()");

	const TUint8 KSizeOfVoiceMailDeletion = 3;
	return KSizeOfVoiceMailDeletion;
	} // CVoiceMailDeletion::SizeL


TUint8* CVoiceMailDeletion::EncodeL(TUint8* aPtr) const
	{
	// When changes are made which affect the
	// number of bytes encoded, this should be
	// reflected in VoiceMailDeletion::SizeL()
	LOGGSMU1("CVoiceMailDeletion::EncodeL");

	*aPtr =  (TUint8) (iMessageId >> 8);
	aPtr++;
	*aPtr =  (TUint8) iMessageId;
	aPtr++;
	*aPtr = ((TUint8) iExtensionIndicator) << 7;
	aPtr++;
	return aPtr;
	} // CVoiceMailDeletion::EncodeL


void CVoiceMailDeletion::DecodeL(TGsmuLex8& aVoiceMailInfo)
	{
	LOGGSMU1("CVoiceMailDeletion::DecodeL");

	iMessageId = (((TUint16) aVoiceMailInfo.GetL()) << 8) +
	              ((TUint16) aVoiceMailInfo.GetL());
	iExtensionIndicator =    (aVoiceMailInfo.GetL() >> 7);

	if (iExtensionIndicator)
	    {
	    TUint8 extensionLength = aVoiceMailInfo.GetL();
	    aVoiceMailInfo.Inc(extensionLength);
	    }
	} // CVoiceMailDeletion::DecodeL


CVoiceMailDeletion::CVoiceMailDeletion()
	{
	iMessageId = 0;
	iExtensionIndicator = EFalse;
	} // CVoiceMailDeletion::CVoiceMailDeletion


/**
 *  @internalComponent
 *  
 *  Prevent clients from using the copy constructor by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
CVoiceMailDeletion::CVoiceMailDeletion(const CVoiceMailDeletion&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailDeletion::CVoiceMailDeletion");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the equality operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
TBool CVoiceMailDeletion::operator==(const CVoiceMailDeletion&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailDeletion::operator==");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    return EFalse;
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the assignment operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
void CVoiceMailDeletion::operator=(const CVoiceMailDeletion&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CVoiceMailDeletion::operator=");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @publishedAll
 *  
 *  Class destructor.
 *  
 *  @capability None
 */
EXPORT_C CVoiceMailDeletion::~CVoiceMailDeletion()
	{
	LOGGSMU1("CVoiceMailDeletion::~CVoiceMailDeletion");

	delete iExtension;
	} // CVoiceMailDeletion::operator


void CVoiceMailDeletion::ConstructL()
	{
	LOGGSMU1("CVoiceMailDeletion::ConstructL()");

	NewBufferL(0);
	} // CVoiceMailDeletion::ConstructL


void CVoiceMailDeletion::NewBufferL(TInt aLength)
	{
	LOGGSMU1("CVoiceMailDeletion::NewBufferL()");

	HBufC* buffer=HBufC::NewL(aLength);
	delete iExtension;
	iExtension=buffer;
	iExtension->Des().SetLength(aLength);
	iExtension->Des().FillZ();
	} // CVoiceMailDeletion::NewBufferL


/**
 *  @publishedAll
 *  
 *  Class constructor
 *  
 *  @capability None
 */
EXPORT_C CVoiceMailDeletion* CVoiceMailDeletion::NewL()
	{
	LOGGSMU1("CVoiceMailDeletion::NewL()");

	CVoiceMailDeletion* voiceMailDeletion=new(ELeave) CVoiceMailDeletion();
	CleanupStack::PushL(voiceMailDeletion);
	voiceMailDeletion->ConstructL();
	CleanupStack::Pop(voiceMailDeletion);
	return voiceMailDeletion;
	} // CVoiceMailDeletion::NewL


/*
void CVoiceMailDeletion::SetExtension(TDesC& aExtension)
	{
	LOGGSMU1("CVoiceMailDeletion::SetExtension()");

	TInt length=aExtension.Length();
	NewBufferL(length);
	iExtension->Des().Copy(aExtension);
	} // CVoiceMailDeletion::SetExtension


TPtrC CVoiceMailDeletion::Extension() const
	{
	LOGGSMU1("CVoiceMailDeletion::Extension()");

	TPtrC ptr;
	if (iExtension)
	    ptr.Set(iExtension->Des());
	return ptr;
	}*/


void CEnhancedVoiceMailDeleteConfirmations::NewExtensionL(TInt aLength)
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::NewExtensionL()");

	HBufC* buffer=HBufC::NewL(aLength);
	delete iExtension;
	iExtension=buffer;
	iExtension->Des().SetLength(aLength);
	iExtension->Des().FillZ();
	} // CEnhancedVoiceMailDeleteConfirmations::NewExtensionL


CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations() : CEnhancedVoiceMailBoxInformation(EGsmSmsVoiceMailDeleteConfirmation)
	{
	//NOP
	} // CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations


/**
 *  @publishedAll
 *  
 *  Class destructor
 *  
 *  @capability None
 */
EXPORT_C  CEnhancedVoiceMailDeleteConfirmations::~CEnhancedVoiceMailDeleteConfirmations()
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::~CEnhancedVoiceMailDeleteConfirmations");

	delete iExtension;
	iVoiceMailDeletions->ResetAndDestroy();
	iVoiceMailDeletions->Close();
	delete iVoiceMailDeletions;
	} // CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations


/**
 *  @internalComponent
 *  
 *  Prevent clients from using the copy constructor by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations(const CEnhancedVoiceMailDeleteConfirmations&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the equality operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
TBool CEnhancedVoiceMailDeleteConfirmations::operator==(const CEnhancedVoiceMailDeleteConfirmations&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::operator==");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    return EFalse;
    BULLSEYE_RESTORE
    }

/**
 *  @internalComponent
 *  
 *  Prevent clients from using the assignment operator by including it in the class definition
 *  but making it protected and not exporting it.
 *  
 *  @capability None
 */
void CEnhancedVoiceMailDeleteConfirmations::operator=(const CEnhancedVoiceMailDeleteConfirmations&)
    {
    // Ignore in code coverage - not intended to be used
    BULLSEYE_OFF    
    LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::operator=");
    Panic(KGsmuPanicMethodBodyNotImplemented);
    BULLSEYE_RESTORE
    }

void CEnhancedVoiceMailDeleteConfirmations::ConstructL()
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::ConstructL()");

	NewExtensionL(0);

	iVoiceMailDeletions = new (ELeave) RPointerArray<CVoiceMailDeletion>(15);
	} // CEnhancedVoiceMailDeleteConfirmations::ConstructL


/**
 *  @publishedAll
 *  
 *  Class constructor
 *  
 *  @capability None
 */
EXPORT_C  CEnhancedVoiceMailDeleteConfirmations* CEnhancedVoiceMailDeleteConfirmations::NewL()
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::NewL()");

	CEnhancedVoiceMailDeleteConfirmations* aCEnhancedVoiceMailDeleteConfirmations=new(ELeave) CEnhancedVoiceMailDeleteConfirmations();
	CleanupStack::PushL(aCEnhancedVoiceMailDeleteConfirmations);
	aCEnhancedVoiceMailDeleteConfirmations->CEnhancedVoiceMailBoxInformation::ConstructL();
	aCEnhancedVoiceMailDeleteConfirmations->ConstructL();
	CleanupStack::Pop(aCEnhancedVoiceMailDeleteConfirmations);
	return aCEnhancedVoiceMailDeleteConfirmations;
	} // CEnhancedVoiceMailDeleteConfirmations::NewL


/**
 *  @publishedAll
 *  
 *  Indicates the number of message IDs that follow in this IE.
 *  
 *  @return
 *  The number of message IDs that follow.
 *  
 *  @capability None
 */
EXPORT_C TUint8  CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes()
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes()");

	return iVoiceMailDeletions->Count();
	} // CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes


/**
 *  @publishedAll
 *  
 *  Provides a reference to the collection that is used to contain the Voice Mail Deletion
 *  notifications. Up to 31 instances of CVoiceMailDeletion can be stored. If more than
 *  31 instances are added, the CEnhancedVoiceMailDeleteConfirmations will not be added to
 *  the CSmsMessage.
 *  
 *  @return
 *  A reference to the collection that is used to contain the Voice Mail Deletion
 *  notifications.
 *  
 *  @capability None
 */
EXPORT_C RPointerArray<CVoiceMailDeletion>& CEnhancedVoiceMailDeleteConfirmations::GetVoiceMailDeletions()
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::GetVoiceMailDeletions()");

	return *iVoiceMailDeletions;
	} // CEnhancedVoiceMailDeleteConfirmations::GetVoiceMailDeletions


/*
void CEnhancedVoiceMailDeleteConfirmations::SetExtension(TDesC& aExtension)
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::SetExtension()");

	TInt length=aExtension.Length();
	NewBufferL(length);
	iExtension->Des().Copy(aExtension);
	} // CEnhancedVoiceMailDeleteConfirmations::SetExtension


TPtrC CEnhancedVoiceMailDeleteConfirmations::Extension() const
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::Extension()");

	TPtrC ptr;
	if (iExtension)
		{
		ptr.Set(iExtension->Des());
		}
	return ptr;
	}*/


TUint8* CEnhancedVoiceMailDeleteConfirmations::EncodeL(TUint8* aCurrentPtr, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs) const
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::EncodeL");

	TUint8* startPtr   = aCurrentPtr;

	aCurrentPtr = CEnhancedVoiceMailBoxInformation::EncodeL(aCurrentPtr, aCharacterSetConverter, aFs);

	TUint8 count = ((TUint8)iVoiceMailDeletions->Count());

	if (count > KMaxNumberOfNotifications)
	    {
	    User::Leave(KErrArgument);
	    }

	*aCurrentPtr= (count & KSmsNotificationBitMask);
	aCurrentPtr++;

	TInt16 spaceAlreadyAllocated; // handle architectures whose address space increments and whose address space decrements.
	(aCurrentPtr > startPtr) ? (spaceAlreadyAllocated = aCurrentPtr - startPtr) : (spaceAlreadyAllocated = startPtr - aCurrentPtr);

	// allow space for id and length bytes
	TInt16 remainingSize = (TInt16)(CEnhancedVoiceMailBoxInformation::KSmsMaxEnhancedVoiceMailSize - spaceAlreadyAllocated);

	for (TUint i = 0; i < count; i++)
	    {
	    remainingSize -= (TInt16)(*iVoiceMailDeletions)[i]->SizeL();
	    if (remainingSize < 0)
	        {
	        User::Leave(KErrArgument);
	        }

	    aCurrentPtr = (*iVoiceMailDeletions)[i]->EncodeL(aCurrentPtr);
	    }

	return aCurrentPtr;
	} // CEnhancedVoiceMailDeleteConfirmations::EncodeL


void CEnhancedVoiceMailDeleteConfirmations::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
	{
	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::DecodeL");

	CEnhancedVoiceMailBoxInformation::DecodeL(aVoiceMailInfo, aCharacterSetConverter, aFs);

	TUint numberOfVMDeletions = (aVoiceMailInfo.GetL() & KSmsNotificationBitMask);

	if (iExtensionIndicator)
		{
		TUint8 extensionLength = aVoiceMailInfo.GetL();
		aVoiceMailInfo.Inc(extensionLength);
		}

	for (TUint8 i = 0; i < numberOfVMDeletions; i++)
		{
		// Create a Voice Mail Deletion
		CVoiceMailDeletion* voiceMailDeletion = CVoiceMailDeletion::NewL();
		CleanupStack::PushL(voiceMailDeletion);
		voiceMailDeletion->DecodeL(aVoiceMailInfo);
		CleanupStack::Pop(voiceMailDeletion);
		iVoiceMailDeletions->Append(voiceMailDeletion);
		}
	} // CEnhancedVoiceMailDeleteConfirmations::DecodeL
