FCL/sf/os/cellularsrv: comparison smsprotocols/smsstack/gsmu/src/Gsmuelem.cpp

equal deleted inserted replaced

-:8ab6687fb94c
+:3adadc800673
-// Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
+// Copyright (c) 1999-2010 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".
 /**
 @file
 */
+#include "OstTraceDefinitions.h"
+#ifdef OST_TRACE_COMPILER_IN_USE
+#include "GsmuelemTraces.h"
+#endif
 #include <gsmuelem.h>
 #include <gsmumsg.h>
 #include "Gsmumain.h"
 #include <gsmusar.h>
 #include "gsmupriv.h"
 	} // TSmsStatus::TSmsStatus
 CSmsCommandData* CSmsCommandData::NewL(TSmsFirstOctet& aFirstOctet)
 	{
-	LOGGSMU1("CSmsCommandData::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_NEWL_1, "CSmsCommandData::NewL()");
 	CSmsCommandData* commanddata=new(ELeave) CSmsCommandData(aFirstOctet);
 	CleanupStack::PushL(commanddata);
 	TPtrC8 ptr;
 	commanddata->SetDataL(ptr);
 *
 *  @return  Pointer to the newly created CSmsCommandData object.
 */
 CSmsCommandData* CSmsCommandData::DuplicateL() const
 	{
-	LOGGSMU1("CSmsCommandData::DuplicateL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_DUPLICATEL_1, "CSmsCommandData::DuplicateL()");
 	CSmsCommandData*  smsCommandData = CSmsCommandData::NewL(iFirstOctet);
 	CleanupStack::PushL(smsCommandData);
 	smsCommandData->SetDataL(Data());
 	} // CSmsCommandData::DuplicateL
 CSmsInformationElement& CSmsCommandData::InformationElement(TInt aIndex) const
 	{
-	LOGGSMU1("CSmsCommandData::InformationElement()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_INFORMATIONELEMENT_1, "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()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_INFORMATIONELEMENTPTR_1, "CSmsCommandData::InformationElementPtr()");
 return iInformationElementArray[aIndex];
 BULLSEYE_RESTORE
 }
 TBool CSmsCommandData::InformationElementIndex(CSmsInformationElement::TSmsInformationElementIdentifier aIdentifier,
 		TInt& aIndex) const
 	{
-	LOGGSMU1("CSmsCommandData::InformationElementIndex()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_INFORMATIONELEMENTINDEX_1, "CSmsCommandData::InformationElementIndex()");
 	TBool found=EFalse;
 	TInt count=NumInformationElements();
 	for (TInt i=0; (!found) && (i<count); i++)
 		if (InformationElement(i).Identifier()==aIdentifier)
 	} // CSmsCommandData::InformationElementIndex
 void CSmsCommandData::AddInformationElementL(const TSmsId aIdentifier,const TDesC8& aData)
 	{
-	LOGGSMU1("CSmsCommandData::AddInformationElementL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_ADDINFORMATIONELEMENTL_1, "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
 	} // CSmsCommandData::AddInformationElementL
 void CSmsCommandData::RemoveInformationElement(TInt aIndex)
 	{
-	LOGGSMU1("CSmsCommandData::RemoveInformationElement()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_REMOVEINFORMATIONELEMENT_1, "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);
 	} // CSmsCommandData::RemoveInformationElement
 TPtrC8 CSmsCommandData::Data() const
 	{
-	LOGGSMU1("CSmsCommandData::Data()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_DATA_1, "CSmsCommandData::Data()");
 	TPtrC8 ptr;
 	ptr.Set(iBuffer->Des());
 	return ptr;
 	} // CSmsCommandData::Data
 void CSmsCommandData::SetDataL(const TDesC8& aData)
 	{
-	LOGGSMU1("CSmsCommandData::SetDataL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_SETDATAL_1, "CSmsCommandData::SetDataL()");
 	TInt length=aData.Length();
 	__ASSERT_DEBUG(length<=KSmsMaxDataSize,Panic(KGsmuPanicCommandDataLengthTooLong));
 	HBufC8* buffer=HBufC8::NewL(length);
 	delete iBuffer;
 	} // CSmsCommandData::SetDataL
 TUint8* CSmsCommandData::EncodeL(TUint8* aPtr) const
 	{
-	LOGGSMU1("CSmsCommandData::EncodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_ENCODEL_1, "CSmsCommandData::EncodeL()");
 	__ASSERT_DEBUG(iBuffer->Length()<=MaxDataLength(),Panic(KGsmuPanicCommandDataBufferTooLong));
 	TSmsOctet datalength=iBuffer->Length()+TSmsOctet(TotalHeaderLengthInUDLUnits());
 	aPtr=datalength.EncodeL(aPtr);
 	TPtr8 ptr((TUint8*) aPtr,datalength);
 	} // CSmsCommandData::EncodeL
 void CSmsCommandData::DecodeL(TGsmuLex8& aPdu)
 	{
-	LOGGSMU1("CSmsCommandData::DecodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_DECODEL_1, "CSmsCommandData::DecodeL()");
 	iInformationElementArray.ResetAndDestroy();
 	const TBool headerPresent=HeaderPresent();
 	TSmsOctet dataLength;
 	dataLength.DecodeL(aPdu);
 	} // CSmsCommandData::CSmsCommandData
 TInt CSmsCommandData::HeaderLength() const
 	{
-	LOGGSMU1("CSmsCommandData::HeaderLength()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_HEADERLENGTH_1, "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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_TOTALHEADERLENGTHINUDLUNITS_1, "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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_HEADERPRESENT_1, "CSmsCommandData::HeaderPresent()");
 	return (iFirstOctet&TSmsFirstOctet::ESmsUDHIMask)==TSmsFirstOctet::ESmsUDHIHeaderPresent;
 	} // CSmsCommandData::HeaderPresent
 void CSmsCommandData::SetHeaderPresent(TBool aHeaderPresent)
 	{
-	LOGGSMU1("CSmsCommandData::SetHeaderPresent()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSCOMMANDDATA_SETHEADERPRESENT_1, "CSmsCommandData::SetHeaderPresent()");
 	iFirstOctet=aHeaderPresent? (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderPresent: (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderNotPresent;
 	} // CSmsCommandData::SetHeaderPresent
 	} // TSmsProtocolIdentifier::TSmsTelematicDeviceIndicator
 void TSmsProtocolIdentifier::SetTelematicDeviceIndicator(TSmsTelematicDeviceIndicator aIndicator)
 	{
-	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceIndicator()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SETTELEMATICDEVICEINDICATOR_1, "TSmsProtocolIdentifier::SetTelematicDeviceIndicator()");
 	__ASSERT_DEBUG(PIDType()==ESmsPIDTelematicInterworking,Panic(KGsmuPanicNoTelematicInterworking));
 	//iValue=(TUint8) ((iValue&ESmsPIDTypeMask)|aIndicator);
 	iValue=(TUint8) ((iValue&(~EPIDTelematicDeviceIndicatorMask))|aIndicator);
 	} // TSmsProtocolIdentifier::TSmsTelematicDeviceType
 void TSmsProtocolIdentifier::SetTelematicDeviceType(TSmsTelematicDeviceType aDeviceType)
 	{
-	LOGGSMU1("TSmsProtocolIdentifier::SetTelematicDeviceType()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SETTELEMATICDEVICETYPE_1, "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()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SHORTMESSAGEALPROTOCOL_1, "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()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SETSHORTMESSAGEALPROTOCOL_1, "TSmsProtocolIdentifier::SetShortMessageALProtocol()");
 __ASSERT_DEBUG(TelematicDeviceIndicator()==ESmsNoTelematicDevice,Panic(KGsmuPanicNoTelematicDevice));
 iValue=(TUint8) ((iValue&(~ESmsShortMessageALProtocolMask))|aProtocol);
 BULLSEYE_RESTORE
 }
 TInt TSmsProtocolIdentifier::ShortMessageType() const
 	{
-	LOGGSMU1("TSmsProtocolIdentifier::ShortMessageType()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SHORTMESSAGETYPE_1, "TSmsProtocolIdentifier::ShortMessageType()");
 	__ASSERT_DEBUG(PIDType()==ESmsPIDShortMessageType,Panic(KGsmuPanicNoShortMessageType));
 	return (TSmsShortMessageType) (iValue&ESmsShortMessageTypeMask);
 	} // TSmsProtocolIdentifier::ShortMessageType
 void TSmsProtocolIdentifier::SetShortMessageType(TSmsShortMessageType aShortMessageType)
 	{
-	LOGGSMU1("TSmsProtocolIdentifier::SetShortMessageType()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSPROTOCOLIDENTIFIER_SETSHORTMESSAGETYPE_1, "TSmsProtocolIdentifier::SetShortMessageType()");
 	__ASSERT_DEBUG(PIDType()==ESmsPIDShortMessageType,Panic(KGsmuPanicNoShortMessageType));
 	//iValue=(TUint8) ((iValue&(~ESmsPIDTypeMask))|aShortMessageType);
 	iValue=(TUint8) ((iValue&(~ESmsShortMessageTypeMask))|aShortMessageType);
 	} // TSmsProtocolIdentifier::SetShortMessageType
 	} // CSmsDeliverReport::DecodeL
 TBool TSmsDataCodingScheme::TextCompressed() const
 	{
-	LOGGSMU1("TSmsDataCodingScheme::TextCompressed()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_TEXTCOMPRESSED_1, "TSmsDataCodingScheme::TextCompressed()");
 	TInt bits7to4=Bits7To4();
 	return (bits7to4==ESmsDCSTextCompressedWithNoClassInfo)    || (bits7to4==ESmsDCSTextCompressedWithClassInfo)      ||
 (bits7to4==ESmsDCSAutoDelNoClassInfoCompressedText) || (bits7to4==ESmsDCSAutoDelClassInfoTextCompressedText);
 	} // TSmsDataCodingScheme::TextCompressed
 void TSmsDataCodingScheme::SetTextCompressed(TBool aCompressed)
 	{
-	LOGGSMU1("TSmsDataCodingScheme::SetTextCompressed()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETTEXTCOMPRESSED_1, "TSmsDataCodingScheme::SetTextCompressed()");
 	TInt bits7to4=Bits7To4();
 	if (aCompressed)
 		{
 		switch (bits7to4)
 	} // TSmsDataCodingScheme::SetTextCompressed
 TSmsDataCodingScheme::TSmsAlphabet TSmsDataCodingScheme::Alphabet() const
 	{
-	LOGGSMU1("TSmsDataCodingScheme::TSmsAlphabet()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_ALPHABET_1, "TSmsDataCodingScheme::TSmsAlphabet()");
 	TInt bits7to4=Bits7To4();
 	TInt alphabet=ESmsAlphabet7Bit;
 	switch (bits7to4)
 		{
 			{
 			alphabet=ESmsAlphabetUCS2;
 			break;
 			}
 		default:
-		    LOGGSMU1("TSmsDataCodingScheme::Alphabet() WARNING! default case has been reached");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_ALPHABET_2, "TSmsDataCodingScheme::Alphabet() WARNING! default case has been reached");
 break;
 		}
 	return (TSmsAlphabet) alphabet;
 	} // TSmsDataCodingScheme::TSmsAlphabet
 void TSmsDataCodingScheme::SetAlphabet(TSmsAlphabet aAlphabet)
 	{
-	LOGGSMU1("TSmsDataCodingScheme::SetAlphabet()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETALPHABET_1, "TSmsDataCodingScheme::SetAlphabet()");
 	TInt bits7to4=Bits7To4();
 	switch (bits7to4)
 		{
 		case (ESmsDCSTextUncompressedWithNoClassInfo):
 			}
 		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
 			{
 if (aAlphabet!=ESmsAlphabet7Bit)
 {
-LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETALPHABET_2, "TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
 }
 			break;
 			}
 		case (ESmsDCSMessageWaitingIndication7Bit):
 			{
 			    {
 				iValue=(TUint8) (ESmsDCSMessageWaitingIndicationUCS2|(iValue&(~ESmsDCSBits7To4Mask)));
 			    }
 			else
 {
-		LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
+		OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETALPHABET_3, "TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
 			    }
 			break;
 			}
 		case (ESmsDCSMessageWaitingIndicationUCS2):
 			{
 			    {
 				iValue=(TUint8) (ESmsDCSMessageWaitingIndication7Bit|(iValue&(~ESmsDCSBits7To4Mask)));
 			    }
 			else
 			    {
-				LOGGSMU3("TSmsDataCodingScheme::SetAlphabet() WARNING! Not Supported With Discard Message  [Bits7To4=%d], [aAlphabet=%d]", bits7to4, aAlphabet);
+				OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETALPHABET_4, "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");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETALPHABET_5, "TSmsDataCodingScheme::SetAlphabet() WARNING! default case has been reached");
 break;
 		}
 	} // TSmsDataCodingScheme::SetAlphabet
 TBool TSmsDataCodingScheme::Class(TSmsClass& aClass) const
 	{
-	LOGGSMU1("TSmsDataCodingScheme::Class()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_CLASS_1, "TSmsDataCodingScheme::Class()");
 	switch (Bits7To4())
 		{
 		case (ESmsDCSTextUncompressedWithClassInfo):
 		case (ESmsDCSTextCompressedWithClassInfo):
 	} // TSmsDataCodingScheme::Class
 void TSmsDataCodingScheme::SetClass(TBool aClassDefined,TSmsDataCodingScheme::TSmsClass aClass)
 	{
-	LOGGSMU1("TSmsDataCodingScheme::SetClass()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETCLASS_1, "TSmsDataCodingScheme::SetClass()");
 	TInt bits7to4=Bits7To4();
 	if (aClassDefined)
 		{
 		switch (bits7to4)
 				{
 				iValue=(TUint8) (iValue&(~ESmsClassMask)|aClass);
 				break;
 				}
 			default:
-		        LOGGSMU1("WARNING! default case has been reached");
+		        OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETCLASS_2, "WARNING! default case has been reached");
 break;
 			}
 		}
 	else
 		{
 	} // TSmsDataCodingScheme::SetClass
 TSmsDataCodingScheme::TSmsIndicationState TSmsDataCodingScheme::IndicationState() const
 	{
-	LOGGSMU1("TSmsDataCodingScheme::IndicationState()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_INDICATIONSTATE_1, "TSmsDataCodingScheme::IndicationState()");
 	TInt bits7to4=Bits7To4();
 	TSmsIndicationState state=ESmsIndicationInactive;
 	switch (bits7to4)
 		{
 			{
 			state=(TSmsIndicationState) (iValue&ESmsIndicationStateMask);
 			break;
 			}
 		default:
-		    LOGGSMU1("WARNING! default case has been reached");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_INDICATIONSTATE_2, "WARNING! default case has been reached");
 break;
 		}
 	return state;
 	} // TSmsDataCodingScheme::TSmsIndicationState
 void TSmsDataCodingScheme::SetIndicationState(TSmsIndicationState aState)
 	{
-	LOGGSMU1("TSmsDataCodingScheme::SetIndicationState()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETINDICATIONSTATE_1, "TSmsDataCodingScheme::SetIndicationState()");
 	TInt bits7to4=Bits7To4();
 	switch (bits7to4)
 		{
 		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
 			{
 			iValue=(TUint8) (aState | (iValue&(~ESmsIndicationStateMask)));
 			break;
 			}
 		default:
-		    LOGGSMU1("TSmsDataCodingScheme::SetIndicationState() WARNING! default case has been reached");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETINDICATIONSTATE_2, "TSmsDataCodingScheme::SetIndicationState() WARNING! default case has been reached");
 break;
 		}
 	} // TSmsDataCodingScheme::SetIndicationState
 TSmsDataCodingScheme::TSmsIndicationType TSmsDataCodingScheme::IndicationType() const
 	{
-	LOGGSMU1("TSmsDataCodingScheme::IndicationType()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_INDICATIONTYPE_1, "TSmsDataCodingScheme::IndicationType()");
 	TInt bits7to4=Bits7To4();
 	TSmsIndicationType type=ESmsVoicemailMessageWaiting;
 	switch (bits7to4)
 		{
 			{
 			type=(TSmsIndicationType) (iValue&ESmsIndicationTypeMask);
 			break;
 			}
 		default:
-		    LOGGSMU1("TSmsDataCodingScheme::IndicationType() WARNING default case has been reached");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_INDICATIONTYPE_2, "TSmsDataCodingScheme::IndicationType() WARNING default case has been reached");
 break;
 		}
 	return type;
 	} // TSmsDataCodingScheme::TSmsIndicationType
 void TSmsDataCodingScheme::SetIndicationType(TSmsIndicationType aType)
 	{
-	LOGGSMU1("TSmsDataCodingScheme::SetIndicationType()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETINDICATIONTYPE_1, "TSmsDataCodingScheme::SetIndicationType()");
 	TInt bits7to4=Bits7To4();
 	switch (bits7to4)
 		{
 		case (ESmsDCSMessageWaitingIndicationDiscardMessage):
 			{
 			iValue=(TUint8) (aType | (iValue&(~ESmsIndicationTypeMask)));
 			break;
 			}
 		default:
-		    LOGGSMU1("TSmsDataCodingScheme::SetIndicationType() WARNING! default case has been reached");
+		    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSDATACODINGSCHEME_SETINDICATIONTYPE_2, "TSmsDataCodingScheme::SetIndicationType() WARNING! default case has been reached");
 break;
 		}
 	} // TSmsDataCodingScheme::SetIndicationType
 *  @return New CSmsAlphabetConverter object
 *  @capability None
 */
 EXPORT_C CSmsAlphabetConverter* CSmsAlphabetConverter::NewLC(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsDataCodingScheme::TSmsAlphabet aSmsAlphabet,TBool aIsBinary)
 	{
-	LOGGSMU1("CSmsAlphabetConverter::NewLC()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSALPHABETCONVERTER_NEWLC_1, "CSmsAlphabetConverter::NewLC()");
 	CSmsAlphabetConverter* converter=new (ELeave)CSmsAlphabetConverter(aCharacterSetConverter,aFs,aSmsAlphabet,aIsBinary);
 	CleanupStack::PushL(converter);
 	converter->ConstructL();
 	return converter;
 //
 // Ensures this is a supported character set if not binary conversion
 //
 void CSmsAlphabetConverter::ConstructL()
 	{
-	LOGGSMU1("CSmsAlphabetConverter::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_CONSTRUCTL_1, "CSmsAlphabetConverter::ConstructL()");
 	if (!iIsBinary)
 		{
 		switch (iSmsAlphabet)
 // clients to provided efficient converted length calculation where no
 // conversion is required.
 //
 void CSmsAlphabetConverter::ConversionPropertiesL(TSmsAlphabetConversionProperties& aConversionProperties) const
 	{
-	LOGGSMU1("CSmsAlphabetConverter::ConversionPropertiesL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_CONVERSIONPROPERTIESL_1, "CSmsAlphabetConverter::ConversionPropertiesL()");
 	// Set defaults
 	aConversionProperties.iWidthConversion=ESmsAlphabetWidthConversionFixed;
 	aConversionProperties.iUDElementsPerNativeCharacter=1;
 *  @return Converted characters
 *  @capability None
 */
 EXPORT_C TPtrC8 CSmsAlphabetConverter::ConvertFromNativeL(const TDesC& aNativeCharacters)
 	{
-	LOGGSMU1("CSmsAlphabetConverter::ConvertFromNativeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSALPHABETCONVERTER_CONVERTFROMNATIVEL_1, "CSmsAlphabetConverter::ConvertFromNativeL()");
 	TInt  numberOfUnconvertibleCharacters, numberOfDowngradedCharacters;
 	return ConvertFromNativeL(aNativeCharacters, ESmsEncodingNone,
 			                  numberOfUnconvertibleCharacters,
 EXPORT_C TPtrC8 CSmsAlphabetConverter::ConvertFromNativeL(const TDesC& aNativeCharacters,
 TSmsEncoding aEncoding,
 TInt& aNumberOfUnconvertibleCharacters,
 			                                              TInt& aNumberOfDowngradedCharacters)
 	{
-	LOGGSMU2("CSmsAlphabetConverter::ConvertFromNativeL(): aEncoding=%d", aEncoding);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSALPHABETCONVERTER_CONVERTFROMNATIVEL1_1, "CSmsAlphabetConverter::ConvertFromNativeL(): aEncoding=%d", aEncoding);
 	aNumberOfUnconvertibleCharacters = 0;
 	aNumberOfDowngradedCharacters    = 0;
 	// Check for some shortcuts
 *
 *  @capability None
 */
 EXPORT_C TPtrC CSmsAlphabetConverter::ConvertToNativeL(const TDesC8& aUDElements)
 	{
-	LOGGSMU1("CSmsAlphabetConverter::ConvertToNativeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSALPHABETCONVERTER_CONVERTTONATIVEL_1, "CSmsAlphabetConverter::ConvertToNativeL()");
 	return ConvertToNativeL(aUDElements, ESmsEncodingNone);
 	} // CSmsAlphabetConverter::ConvertToNativeL
 *  @capability None
 */
 EXPORT_C TPtrC CSmsAlphabetConverter::ConvertToNativeL(const TDesC8& aUDElements,
 													   TSmsEncoding aEncoding)
 	{
-	LOGGSMU2("CSmsAlphabetConverter::ConvertToNativeL(): aEncoding=%d", aEncoding);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSALPHABETCONVERTER_CONVERTTONATIVEL1_1, "CSmsAlphabetConverter::ConvertToNativeL(): aEncoding=%d", aEncoding);
 	// Check for some shortcuts
 	if (iIsBinary ||  iSmsAlphabet == TSmsDataCodingScheme::ESmsAlphabet8Bit)
 		{
 		// Binary data stored as padded unicode
 *        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);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL_1, "[1] CSmsAlphabetConverter::IsSupportedL(aChar=0x%04x)", (TUint) aChar);
 	TBool isDowngrade, isRequiresAlternativeEncoding;
 TBool  supported = IsSupportedL(aChar, ESmsEncodingNone,
 isDowngrade, isRequiresAlternativeEncoding);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL_2, "CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
 	return supported;
 	} // CSmsAlphabetConverter::IsSupportedL
 *  @return  ETrue if the character is supported.
 */
 TBool CSmsAlphabetConverter::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
 TInt& aIndexOfFirstUnconvertibleCharacter)
 	{
-	LOGGSMU2("[2] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", &aDes);
+	OstTraceDefExt1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL1_1, "[2] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", aDes);
 	TInt desLength = aDes.Length();
 	//
 	// Initialise the exit params...
 	//
 	//
 	// Useful logging...
 	//
 	TBool  supported = (aNumberOfUnconvertibleCharacters == 0);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL1_2, "CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL1_3, "CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL1_4, "CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
 	return supported;
 	} // CSmsAlphabetConverter::IsSupportedL
 */
 TBool CSmsAlphabetConverter::IsSupportedL(TChar aChar, TSmsEncoding aEncoding,
 		                                  TBool& aIsDowngrade,
 TBool& aRequiresAlternativeEncoding)
 	{
-	LOGGSMU2("[3] CSmsAlphabetConverter::IsSupportedL(aChar=0x%04x)", (TUint) aChar);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL2_1, "[3] CSmsAlphabetConverter::IsSupportedL(aChar=0x%04x)", (TUint) aChar);
 	//
 	// Convert the character...
 	//
 	TInt  numberOfUnconvertibleCharacters, numberOfDowngradedCharacters,
 	aRequiresAlternativeEncoding = (numberRequiringAlternativeEncoding > 0);
 	//
 	// Useful logging...
 	//
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIsDowngrade=%d.", aIsDowngrade);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL2_2, "CSmsAlphabetConverter::IsSupportedL(): aIsDowngrade=%d.", aIsDowngrade);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aRequiresAlternativeEncoding=%d.", aRequiresAlternativeEncoding);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL2_3, "CSmsAlphabetConverter::IsSupportedL(): aRequiresAlternativeEncoding=%d.", aRequiresAlternativeEncoding);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL2_4, "CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
 	return supported;
 	} // CSmsAlphabetConverter::IsSupportedL
 										  TInt& aNumberOfUnconvertibleCharacters,
 TInt& aNumberOfDowngradedCharacters,
 TInt& aNumberRequiringAlternativeEncoding,
 TInt& aIndexOfFirstUnconvertibleCharacter)
 	{
-	LOGGSMU2("[4] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", &aDes);
+	OstTraceDefExt1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_1, "[4] CSmsAlphabetConverter::IsSupportedL(aDes=\"%S\")", aDes);
 	TInt desLength = aDes.Length();
 	//
 	// Initialise the exit params...
 	//
 	//
 	// Useful logging...
 	//
 	TBool  supported = (aNumberOfUnconvertibleCharacters == 0);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_2, "CSmsAlphabetConverter::IsSupportedL(): aNumberOfUnconvertibleCharacters=%d.", aNumberOfUnconvertibleCharacters);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberOfDowngradedCharacters=%d.", aNumberOfDowngradedCharacters);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_3, "CSmsAlphabetConverter::IsSupportedL(): aNumberOfDowngradedCharacters=%d.", aNumberOfDowngradedCharacters);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aNumberRequiringAlternativeEncoding=%d.", aNumberRequiringAlternativeEncoding);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_4, "CSmsAlphabetConverter::IsSupportedL(): aNumberRequiringAlternativeEncoding=%d.", aNumberRequiringAlternativeEncoding);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_5, "CSmsAlphabetConverter::IsSupportedL(): aIndexOfFirstUnconvertibleCharacter=%d.", aIndexOfFirstUnconvertibleCharacter);
-	LOGGSMU2("CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_ISSUPPORTEDL3_6, "CSmsAlphabetConverter::IsSupportedL(): supported=%d.", supported);
 	return supported;
 	} // CSmsAlphabetConverter::IsSupportedL
 *  @return Encoding that should be used.
 */
 TSmsEncoding CSmsAlphabetConverter::FindBestAlternativeEncodingL(const TDesC& aNativeCharacters,
 									                     		 TSmsEncoding aSuggestedEncoding)
 	{
-	LOGGSMU2("CSmsAlphabetConverter::FindBestAlternativeEncodingL(): aSuggestedEncoding=%d",
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_FINDBESTALTERNATIVEENCODINGL_1, "CSmsAlphabetConverter::FindBestAlternativeEncodingL(): aSuggestedEncoding=%d",aSuggestedEncoding);
-			 aSuggestedEncoding);
 	TSmsEncoding  encodingToUse = ESmsEncodingNone;
 	//
 	// If this is not 7bit or the alternative encoding is not set then do
 				leastUnconvertibleCharacters = numberOfUnconvertibleCharacters + numberOfDowngradedCharacters;
 				}
 			}
 		}
-	LOGGSMU2("CSmsAlphabetConverter::FindBestAlternativeEncodingL(): encodingToUse=%d", encodingToUse);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_FINDBESTALTERNATIVEENCODINGL_2, "CSmsAlphabetConverter::FindBestAlternativeEncodingL(): encodingToUse=%d", encodingToUse);
 	return encodingToUse;
 	} // CSmsAlphabetConverter::FindBestAlternativeEncoding
 *
 *  @param aEncoding  Alternative 7bit encoding to use if required.
 */
 void CSmsAlphabetConverter::PrepareForConversionFromNativeL(TSmsEncoding aEncoding)
 	{
-	LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): aEncoding=%d",
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_PREPAREFORCONVERSIONFROMNATIVEL_1, "CSmsAlphabetConverter::PrepareForConversionFromNativeL(): aEncoding=%d",aEncoding);
-			 aEncoding);
 	__ASSERT_DEBUG(iIsBinary==EFalse,Panic(KGsmuPanicUnsupportedAlphabet));
 	switch (iSmsAlphabet)
 		{
 		case TSmsDataCodingScheme::ESmsAlphabet7Bit:
 				GetAlternativeEncoderIDL(aEncoding, alternativeEncoderID);
 				if (alternativeEncoderID != 0)
 					{
 					CCnvCharacterSetConverter::TAvailability  availability;
-					LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",
+					OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_PREPAREFORCONVERSIONFROMNATIVEL_2, "CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",alternativeEncoderID);
-							 alternativeEncoderID);
 					availability = iCharacterSetConverter.PrepareToConvertToOrFromL(alternativeEncoderID, iFs);
 					if (availability == CCnvCharacterSetConverter::EAvailable)
 						{
 			 			// Force unicode line termination characters to simple line feed
 *
 *  @param aEncoding  Alternative 7bit encoding to use if required.
 */
 void CSmsAlphabetConverter::PrepareForConversionToNativeL(TSmsEncoding aEncoding)
 	{
-	LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionToNativeL(): aEncoding=%d",
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_PREPAREFORCONVERSIONTONATIVEL_1, "CSmsAlphabetConverter::PrepareForConversionToNativeL(): aEncoding=%d",aEncoding);
-			 aEncoding);
 	switch (iSmsAlphabet)
 		{
 		case TSmsDataCodingScheme::ESmsAlphabet7Bit:
 			{
 				GetAlternativeEncoderIDL(aEncoding, alternativeEncoderID);
 				if (alternativeEncoderID != 0)
 					{
 					CCnvCharacterSetConverter::TAvailability  availability;
-					LOGGSMU2("CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",
+					OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_PREPAREFORCONVERSIONTONATIVEL_2, "CSmsAlphabetConverter::PrepareForConversionFromNativeL(): Converter 0x%08x",alternativeEncoderID);
-							 alternativeEncoderID);
 					availability = iCharacterSetConverter.PrepareToConvertToOrFromL(alternativeEncoderID, iFs);
 					if (availability == CCnvCharacterSetConverter::EAvailable)
 						{
 						// Job done, return
 *
 *  @leave KErrArgument if the encoding enum is invalid or
 */
 void CSmsAlphabetConverter::GetAlternativeEncoderIDL(TSmsEncoding aEncoding, TUint& aEncoderID) const
 	{
-	LOGGSMU2("CSmsAlphabetConverter::GetAlternativeEncoderIDL(%d)", aEncoding);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_GETALTERNATIVEENCODERIDL_1, "CSmsAlphabetConverter::GetAlternativeEncoderIDL(%d)", aEncoding);
 	aEncoderID = 0;
 	//
 	// Decide on appropriate encoders.
 //
 // 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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_CHECKALLOCBUFFERL_1, "CSmsAlphabetConverter::CheckAllocBufferL()");
 	if (*aBuffer!=NULL)
 		{
 		if ((*aBuffer)->Length()<aMaxLength)
 			{
 //
 // 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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSALPHABETCONVERTER_CHECKALLOCBUFFERL1_1, "CSmsAlphabetConverter::CheckAllocBufferL()");
 	if (*aBuffer!=NULL)
 		{
 		if ((*aBuffer)->Length()<aMaxLength)
 			{
 *  @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()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, TGSMSMSTELNUMBER_ISINSTANCEOF_1, "TGsmSmsTelNumber::IsInstanceOf()");
 TBool rc = EFalse;
 (void) aType;
 // CSmsAddress
 //
 CSmsAddress* CSmsAddress::NewL(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs)
 	{
-	LOGGSMU1("CSmsAddress::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_NEWL_1, "CSmsAddress::NewL()");
 	CSmsAddress* address=new(ELeave) CSmsAddress(aCharacterSetConverter,aFs);
 	CleanupStack::PushL(address);
 	TPtrC ptr;
 	address->SetAddressL(ptr);
 *
 *  @return  Pointer to the newly created CSmsAddress object.
 */
 CSmsAddress* CSmsAddress::DuplicateL() const
 	{
-	LOGGSMU1("CSmsAddress::DuplicateL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_DUPLICATEL_1, "CSmsAddress::DuplicateL()");
 	CSmsAddress*  address = CSmsAddress::NewL(iCharacterSetConverter, iFs);
 	CleanupStack::PushL(address);
 	address->SetRawAddressL(iTypeOfAddress, *iBuffer);
 	} // CSmsAddress::DuplicateL
 TPtrC CSmsAddress::Address() const
 	{
-	LOGGSMU1("CSmsAddress::Address()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_ADDRESS_1, "CSmsAddress::Address()");
 	TPtrC ptr;
 	if (iBuffer)
 		ptr.Set(iBuffer->Des());
 	return ptr;
 	} // CSmsAddress::Address
 void CSmsAddress::SetRawAddressL(TGsmSmsTypeOfAddress aTypeOfAddress, TPtrC aBufferPtr)
 {
-LOGGSMU1("CSmsAddress::SetRawAddressL()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_SETRAWADDRESSL_1, "CSmsAddress::SetRawAddressL()");
 iTypeOfAddress = aTypeOfAddress;
 NewBufferL(aBufferPtr.Length());
 } // CSmsAddress::SetRawAddressL
 TGsmSmsTypeOfAddress& CSmsAddress::TypeOfAddress()
 {
-LOGGSMU1("CSmsAddress::TypeOfAddress()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_TYPEOFADDRESS_1, "CSmsAddress::TypeOfAddress()");
 return iTypeOfAddress;
 } // CSmsAddress::TypeOfAddress
 void CSmsAddress::SetAddressL(const TDesC& aAddress)
 	{
-	LOGGSMU1("CSmsAddress::SetAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_SETADDRESSL_1, "CSmsAddress::SetAddressL()");
 	TInt length=aAddress.Length();
 	NewBufferL(length);
 	iBuffer->Des().Copy(aAddress);
 	}
 void CSmsAddress::SetParsedAddressL(const TGsmSmsTelNumber& aParsedAddress)
 	{
-	LOGGSMU1("CSmsAddress::SetParsedAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_SETPARSEDADDRESSL_1, "CSmsAddress::SetParsedAddressL()");
 	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
 	DoSetParsedAddressL(aParsedAddress.iTelNumber);
 	} // CSmsAddress::SetParsedAddressL
 TUint8 CSmsAddress::SizeL()
 {
-LOGGSMU1("CSmsAddress::SizeL()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_SIZEL_1, "CSmsAddress::SizeL()");
 TUint8 size = 0;
 TBuf8<KSmsAddressMaxAddressLength> testBuffer;
 testBuffer.SetLength(KSmsAddressMaxAddressLength);
 	} // CSmsAddress::CSmsAddress
 void CSmsAddress::NewBufferL(TInt aLength)
 	{
-	LOGGSMU1("CSmsAddress::NewBufferL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_NEWBUFFERL_1, "CSmsAddress::NewBufferL()");
 HBufC* buffer=HBufC::NewL(aLength);
 delete iBuffer;
 iBuffer=buffer;
 iBuffer->Des().SetLength(aLength);
 	}
 void CSmsAddress::DoSetParsedAddressL(const TDesC& aAddress)
 	{
-	LOGGSMU2("CSmsAddress::DoSetParsedAddressL() the length of the Address [Length = %d", aAddress.Length());
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSADDRESS_DOSETPARSEDADDRESSL_1, "CSmsAddress::DoSetParsedAddressL() the length of the Address [Length = %d", aAddress.Length());
 	TInt length=aAddress.Length();
 	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
 	    (length && (aAddress[0]!='+')))
 		{
 	} // TSmsServiceCenterTimeStamp::SetTimeOffset
 TUint8* TSmsServiceCenterTimeStamp::EncodeL(TUint8* aPtr) const
 {
-LOGGSMU1("TSmsServiceCenterTimeStamp::EncodeL()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSSERVICECENTERTIMESTAMP_ENCODEL_1, "TSmsServiceCenterTimeStamp::EncodeL()");
 TInt numquarterhours=iTimeZoneNumQuarterHours;
 TInt timeZoneOffsetInSeconds = numquarterhours * CSmsMessage::E15MinutesRepresentedInSeconds;
 TTimeIntervalSeconds offsetFromUTCToLocal(timeZoneOffsetInSeconds);
 } // TSmsServiceCenterTimeStamp::EncodeL
 void TSmsServiceCenterTimeStamp::DecodeL(TGsmuLex8& aPdu, TInt& aTimeError)
 	{
-	LOGGSMU1("TSmsServiceCenterTimeStamp::DecodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSSERVICECENTERTIMESTAMP_DECODEL_1, "TSmsServiceCenterTimeStamp::DecodeL()");
 	TSmsOctet octet;
 	octet.DecodeL(aPdu);
 	TInt year=octet.SemiOctetsToNum();
 	if (year>95)
 	} // TSmsValidityPeriod::TSmsValidityPeriod
 TTime TSmsValidityPeriod::Time() const
 	{
-	LOGGSMU1("TSmsValidityPeriod::Time()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSVALIDITYPERIOD_TIME_1, "TSmsValidityPeriod::Time()");
 	TTime time;
 	time.UniversalTime();
 	time+=iTimeIntervalMinutes;
 	return time;
 	} // TSmsValidityPeriod::Time
 TUint8* TSmsValidityPeriod::EncodeL(TUint8* aPtr) const
 	{
-	LOGGSMU1("TSmsValidityPeriod::EncodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSVALIDITYPERIOD_ENCODEL_1, "TSmsValidityPeriod::EncodeL()");
 	TInt validityperiodformat=ValidityPeriodFormat();
 	switch (validityperiodformat)
 		{
 		case (TSmsFirstOctet::ESmsVPFNone):
 	return aPtr;
 	} // TSmsValidityPeriod::EncodeL
 TUint8* TSmsValidityPeriod::EncodeL(TUint8* aPtr, const TEncodeParams* aEncodeParams) const
 	{
-	LOGGSMU1("TSmsValidityPeriod::EncodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSVALIDITYPERIOD_ENCODEL1_1, "TSmsValidityPeriod::EncodeL()");
 	TInt validityperiodformat=ValidityPeriodFormat();
 	switch (validityperiodformat)
 		{
 		case (TSmsFirstOctet::ESmsVPFNone):
 	return aPtr;
 	} // TSmsValidityPeriod::EncodeL
 void TSmsValidityPeriod::DecodeL(TGsmuLex8& aPdu)
 	{
-	LOGGSMU1("TSmsValidityPeriod::DecodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSVALIDITYPERIOD_DECODEL_1, "TSmsValidityPeriod::DecodeL()");
 	TInt validityperiodformat=ValidityPeriodFormat();
 	switch (validityperiodformat)
 		{
 		case (TSmsFirstOctet::ESmsVPFNone):
 	} // TSmsValidityPeriod::ExternalizeL
 CSmsInformationElement* CSmsInformationElement::NewL(TSmsInformationElementIdentifier aIdentifier,const TDesC8& aData)
 	{
-	LOGGSMU1("CSmsInformationElement::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_NEWL_1, "CSmsInformationElement::NewL()");
 	CSmsInformationElement* informationelement=new(ELeave) CSmsInformationElement(aIdentifier);
 	CleanupStack::PushL(informationelement);
 	informationelement->ConstructL(aData);
 	CleanupStack::Pop();
 	} // CSmsInformationElement::NewL
 CSmsInformationElement* CSmsInformationElement::NewL()
 	{
-	LOGGSMU1("CSmsInformationElement::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_NEWL1_1, "CSmsInformationElement::NewL()");
 	CSmsInformationElement* informationelement=new(ELeave) CSmsInformationElement(ESmsIEIConcatenatedShortMessages8BitReference);
 	CleanupStack::PushL(informationelement);
 	TPtrC8 data;
 	informationelement->ConstructL(data);
 *  @return Information Element data
 *  @capability None
 */
 EXPORT_C TPtr8 CSmsInformationElement::Data()
 	{
-	LOGGSMU1("CSmsInformationElement::Data()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSINFORMATIONELEMENT_DATA_1, "CSmsInformationElement::Data()");
 	return iData->Des();
 	} // CSmsInformationElement::Data
 *  @return Information Element data
 *  @capability None
 */
 EXPORT_C const TDesC8& CSmsInformationElement::Data() const
 	{
-	LOGGSMU1("CSmsInformationElement::Data()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSINFORMATIONELEMENT_DATA1_1, "CSmsInformationElement::Data()");
 	return *iData;
 	} // CSmsInformationElement::Data
 	} // CSmsInformationElement::TSmsInformationElementIdentifier
 TUint8* CSmsInformationElement::EncodeL(TUint8* aPtr) const
 	{
-	LOGGSMU1("CSmsInformationElement::EncodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_ENCODEL_1, "CSmsInformationElement::EncodeL()");
 	TSmsOctet id=iIdentifier;
 	aPtr=id.EncodeL(aPtr);
 	TSmsOctet informationelementlength=iData->Des().Length();
 	aPtr=informationelementlength.EncodeL(aPtr);
 	} // CSmsInformationElement::EncodeL
 void CSmsInformationElement::DecodeL(TGsmuLex8& aPdu)
 	{
-	LOGGSMU1("CSmsInformationElement::DecodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_DECODEL_1, "CSmsInformationElement::DecodeL()");
 	TSmsOctet id;
 	id.DecodeL(aPdu);
 	iIdentifier=static_cast<TSmsInformationElementIdentifier>((TInt)id);
 	} // CSmsInformationElement::ExternalizeL
 void CSmsInformationElement::ConstructL(const TDesC8& aData)
 	{
-	LOGGSMU1("CSmsInformationElement::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_CONSTRUCTL_1, "CSmsInformationElement::ConstructL()");
 	NewDataL(aData.Length());
 	iData->Des().Copy(aData);
 	} // CSmsInformationElement::ConstructL
 void CSmsInformationElement::NewDataL(TInt aLength)
 	{
-	LOGGSMU1("CSmsInformationElement::NewDataL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_NEWDATAL_1, "CSmsInformationElement::NewDataL()");
 	HBufC8* data=HBufC8::NewL(aLength);
 	delete iData;
 	iData=data;
 	iData->Des().SetLength(aLength);
 	} // CSmsInformationElement::NewDataL
 TUint CSmsInformationElement::Length()const
 	{
-	LOGGSMU1("CSmsInformationElement::Length()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSINFORMATIONELEMENT_LENGTH_1, "CSmsInformationElement::Length()");
 	return 2+iData->Length();  // 2 stands for IEID and IEDL
 	} // CSmsInformationElement::Length
 *  True if the information element can be mapped.
 *  False otherwise.
 */
 TBool TSmsInformationElementCategories::TranslateCategoryToIndex(TInformationElementId aId, TInt& aIndex)
 {
-LOGGSMU1("CSmsMessage::TranslateCategoryToIndex");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSINFORMATIONELEMENTCATEGORIES_TRANSLATECATEGORYTOINDEX_1, "CSmsMessage::TranslateCategoryToIndex");
 TBool rc = ETrue;
 if (aId < CSmsInformationElement::ESmsIEMaximum)
 {
 }
 }
 else
 {
 rc = EFalse;
-LOGGSMU3("CSmsMessage::TranslateCategoryToIndex id = %d, found = %d", aId, rc);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSINFORMATIONELEMENTCATEGORIES_TRANSLATECATEGORYTOINDEX_2, "CSmsMessage::TranslateCategoryToIndex id = %d, found = %d", aId, rc);
 }
 return rc;
 } // TSmsInformationElementCategories::TranslateCategoryToIndex
 *  ETrue if successful, EFalse if an information identifier is unknown or cannot
 *  be mapped.
 */
 TBool TSmsInformationElementCategories::GetCategoryDefinition(TInformationElementId aId, TInformationElementCategory& aCategory)
 {
-LOGGSMU1("TSmsInformationElementCategories::GetCategoryDefinition");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSINFORMATIONELEMENTCATEGORIES_GETCATEGORYDEFINITION_1, "TSmsInformationElementCategories::GetCategoryDefinition");
 TInt index;
 if (TranslateCategoryToIndex(aId,index))
 {
 aCategory = categories[index];
 }
 else
 {
-LOGGSMU2("TSmsInformationElementCategories::GetCategoryDefinition, Failure, aId = %d", aId);
+OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, TSMSINFORMATIONELEMENTCATEGORIES_GETCATEGORYDEFINITION_2, "TSmsInformationElementCategories::GetCategoryDefinition, Failure, aId = %d", aId);
 return EFalse;
 }
 return ETrue;
 } // TSmsInformationElementCategories::GetCategoryDefinition
 };
 CSmsUserData* CSmsUserData::NewL(CCnvCharacterSetConverter& aCharacterSetConverter,RFs& aFs,TSmsFirstOctet& aFirstOctet,const TSmsDataCodingScheme& aDataCodingScheme)
 	{
-	LOGGSMU1("CSmsUserData::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_NEWL_1, "CSmsUserData::NewL()");
 	CSmsUserData* userdata=new(ELeave) CSmsUserData(aCharacterSetConverter,aFs,aFirstOctet,aDataCodingScheme);
 	CleanupStack::PushL(userdata);
 	userdata->ConstructL();
 	CleanupStack::Pop();
 *  @return Information element
 *  @capability None
 */
 EXPORT_C  CSmsInformationElement& CSmsUserData::InformationElement(TInt aIndex) const
 	{
-	LOGGSMU1("CSmsUserData::InformationElement()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_INFORMATIONELEMENT_1, "CSmsUserData::InformationElement()");
 	return *iInformationElementArray[aIndex];
 	} // CSmsUserData::InformationElement
 CSmsInformationElement*& CSmsUserData::InformationElementPtr(TInt aIndex)
 {
-LOGGSMU1("CSmsUserData::InformationElementPtr()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_INFORMATIONELEMENTPTR_1, "CSmsUserData::InformationElementPtr()");
 return iInformationElementArray[aIndex];
 } // CSmsUserData::InformationElementPtr
 *  @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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_INFORMATIONELEMENTINDEX_1, "CSmsUserData::InformationElementIndex()");
 	TBool found=EFalse;
 	TInt count=NumInformationElements();
 	for (TInt i=0; (!found) && (i<count); i++)
 		if (InformationElement(i).Identifier()==aIdentifier)
 *  @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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_INFORMATIONELEMENTLASTINDEX_1, "CSmsUserData::InformationElementLastIndex()");
 	TBool found=EFalse;
 	TInt count=NumInformationElements();
 	for (TInt i=count-1; (!found) && (i>=0); i--)
 		if (InformationElement(i).Identifier()==aIdentifier)
 *  @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()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_INFORMATIONELEMENTINDICESL_1, "CSmsUserData::InformationElementIndicesL()");
 aIndices.Reset();
 	TInt count=NumInformationElements();
 	for (TInt i=0; i<count; i++)
 *  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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_EMSINFORMATIONELEMENTWILLFITL_1, "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);
 *  @param aInformationElement A pointer to an information Element
 *  @capability None
 */
 TBool CSmsUserData::ControlInformationElementWillFitL(CSmsInformationElement* aIe)
 {
-LOGGSMU1("CSmsUserData::ControlInformationElementWillFitL()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_CONTROLINFORMATIONELEMENTWILLFITL_1, "CSmsUserData::ControlInformationElementWillFitL()");
 if (aIe == NULL)
 {
 User::Leave(KErrGeneral);
 }
 *  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");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_ADDINFORMATIONELEMENTL_1, "CSmsUserData::AddInformationElementL");
 if  ((aIdentifier >= 0x21) && (aIdentifier <= 0x23) ||
 (aIdentifier >= 0x26) && (aIdentifier <= 0x6F) ||
 (aIdentifier >= 0xA0) && (aIdentifier <= 0xBF) ||
 (aIdentifier >= 0xE0) && (aIdentifier <= 0xFF))
 *  @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");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_1, "CSmsUserData::UpdateInformationElementsL");
 TInt count=NumInformationElements();
 if(!CEmsFactory::Supported(aIdentifier))
 {
 for (TInt i=0; i<count; i++)
 {
 case TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUMultipleInstancesPerPDU:
 {
 if (InformationElement(i).Identifier() == CSmsInformationElement::ESmsIEISpecialSMSMessageIndication)
 {
-LOGGSMU3("CSmsUserData::AddInformationElementL1 category = %d, identifier = %d",category,aIdentifier);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_2, "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);
+OstTraceDefExt3(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_3, "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);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_4, "CSmsUserData::AddInformationElementL4 category = %d, identifier = %d",category,aIdentifier);
 User::Leave(KErrAlreadyExists);
 break;
 }
 case TSmsInformationElementCategories::ECtrlMultipleInstancesAllowed:
 {
-LOGGSMU3("CSmsUserData::AddInformationElementL5 category = %d, identifier = %d",category,aIdentifier);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_5, "CSmsUserData::AddInformationElementL5 category = %d, identifier = %d",category,aIdentifier);
 break;
 }
 case TSmsInformationElementCategories::ECtrlMandatoryInEveryPDUButWithValueSpecificToPDU:
 {
-LOGGSMU3("CSmsUserData::AddInformationElementL6 category = %d, identifier = %d",category,aIdentifier);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_6, "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);
+OstTraceDefExt2(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_UPDATEINFORMATIONELEMENTARRAYL_7, "CSmsUserData::AddInformationElementL8 category = %d, identifier = %d",category,aIdentifier);
 User::Leave(KErrNotSupported);
 break;
 }
 }
 }
 } // CSmsUserData::UpdateInformationElementArrayL
 void CSmsUserData::AddEmsInformationElementL(CEmsInformationElement* aIe)
 	{
-	LOGGSMU1("CSmsUserData::AddEmsInformationElementL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_ADDEMSINFORMATIONELEMENTL_1, "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);
 *  @param aIndex Information element index
 *  @capability None
 */
 EXPORT_C void CSmsUserData::RemoveInformationElement(TInt aIndex)
 	{
-	LOGGSMU1("CSmsUserData::RemoveInformationElement()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_REMOVEINFORMATIONELEMENT_1, "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);
 	} // CSmsUserData::RemoveInformationElement
 TInt CSmsUserData::MaxPackedUDUnitsInBodyRemaining() const
 	{
-	LOGGSMU1("CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_MAXPACKEDUDUNITSINBODYREMAINING_1, "CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");
 	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits();
 	TInt maxPackedUDUnitsInBody=0;
 	if (iDataCodingScheme.TextCompressed()||(iDataCodingScheme.Alphabet()!=TSmsDataCodingScheme::ESmsAlphabet7Bit))
 		{
 	} // CSmsUserData::MaxPackedUDUnitsInBodyRemaining
 TInt CSmsUserData::MaxPackedUDUnitsInBodyRemaining(TUint aIELen) const
 	{
-	LOGGSMU1("CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_MAXPACKEDUDUNITSINBODYREMAINING1_1, "CSmsUserData::MaxPackedUDUnitsInBodyRemaining()");
 	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits(aIELen);
 	TInt maxPackedUDUnitsInBody=0;
 	if (iDataCodingScheme.TextCompressed()||(iDataCodingScheme.Alphabet()!=TSmsDataCodingScheme::ESmsAlphabet7Bit))
 		{
 /**
 *  @capability None
 */
 EXPORT_C TInt CSmsUserData::MaxBodyLengthInChars() const
 	{
-	LOGGSMU1("CSmsUserData::MaxBodyLengthInChars()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_MAXBODYLENGTHINCHARS_1, "CSmsUserData::MaxBodyLengthInChars()");
 	TInt totalheaderlengthinudlunits=TotalHeaderLengthInUDLUnits();
 	TInt maxbodylengthinchars=0;
 	if (iDataCodingScheme.TextCompressed())
 		{
 				{
 				maxbodylengthinchars=(KSmsMaxUserDataSize-totalheaderlengthinudlunits)/2;
 				break;
 				}
 			default:
-			    LOGGSMU1("CSmsUserData::MaxBodyLengthInChars() WARNING! default case has been reached");
+			    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_MAXBODYLENGTHINCHARS_2, "CSmsUserData::MaxBodyLengthInChars() WARNING! default case has been reached");
 break;
 			}
 		}
 	return maxbodylengthinchars;
 	} // CSmsUserData::MaxBodyLengthInChars
 *  @return Unpacked User Data Elements
 *  @capability None
 */
 EXPORT_C TPtrC8 CSmsUserData::Body() const
 	{
-	LOGGSMU1("CSmsUserData::Body()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_BODY_1, "CSmsUserData::Body()");
 	return iBody->Des();
 	} // CSmsUserData::Body
 *  @param aBody Unpacked User Data Elements
 *  @capability None
 */
 EXPORT_C void CSmsUserData::SetBodyL(const TDesC8& aBody)
 	{
-	LOGGSMU1("CSmsUserData::SetBodyL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_SETBODYL_1, "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());
 	} // CSmsUserData::SetBodyL
 void CSmsUserData::AppendBodyL(const TDesC8& aBody)
 	{
-	LOGGSMU1("CSmsUserData::AppendBodyL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_APPENDBODYL_1, "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));
 *
 *  @capability None
 */
 EXPORT_C TBool CSmsUserData::IsSupportedL(TChar aChar)
 	{
-	LOGGSMU1("CSmsUserData::IsSupportedL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_ISSUPPORTEDL_1, "CSmsUserData::IsSupportedL()");
 	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
 	TBool result=converter->IsSupportedL(aChar);
 	CleanupStack::PopAndDestroy();
 *  @capability None
 */
 EXPORT_C TBool CSmsUserData::IsSupportedL(const TDesC& aDes, TInt& aNumberOfUnconvertibleCharacters,
 TInt& aIndexOfFirstUnconvertibleCharacter) const
 	{
-	LOGGSMU1("[1] CSmsUserData::IsSupportedL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_ISSUPPORTEDL1_1, "[1] CSmsUserData::IsSupportedL()");
 	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
 	TBool result=converter->IsSupportedL(aDes, aNumberOfUnconvertibleCharacters,
 			                             aIndexOfFirstUnconvertibleCharacter);
 	CleanupStack::PopAndDestroy();
 										  TInt& aNumberOfUnconvertibleCharacters,
 TInt& aNumberOfDowngradedCharacters,
 TInt& aNumberRequiringAlternativeEncoding,
 TInt& aIndexOfFirstUnconvertibleCharacter) const
 	{
-	LOGGSMU1("[2] CSmsUserData::IsSupportedL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CSMSUSERDATA_ISSUPPORTEDL2_1, "[2] CSmsUserData::IsSupportedL()");
 	CSmsAlphabetConverter* converter=CSmsAlphabetConverter::NewLC(iCharacterSetConverter,iFs,iDataCodingScheme.Alphabet(),IsBinaryData());
 	TBool result=converter->IsSupportedL(aDes, aEncoding,
 			                             aNumberOfUnconvertibleCharacters,
 			                             aNumberOfDowngradedCharacters,
 	} // CSmsUserData::IsSupportedL
 TUint8* CSmsUserData::EncodeL(TUint8* aPtr) const
 	{
-	LOGGSMU1("CSmsUserData::EncodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_ENCODEL_1, "CSmsUserData::EncodeL()");
 	__ASSERT_DEBUG(0<=MaxPackedUDUnitsInBodyRemaining(),Panic(KGsmuPanicUserDataBodyTooLong));
 	// Encode the user data length
 	TInt totalHeaderLengthInUDLUnits=TotalHeaderLengthInUDLUnits();
 	TSmsOctet userDataLength=totalHeaderLengthInUDLUnits+TSmsOctet(BodyLengthInUDLUnits());
 	DecodeL(aPdu, EFalse);
 	}
 void CSmsUserData::DecodeL(TGsmuLex8& aPdu, TBool aAcceptTruncation)
 	{
-	LOGGSMU1("CSmsUserData::DecodeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_DECODEL1_1, "CSmsUserData::DecodeL()");
 	// Reset current data
 	iInformationElementArray.ResetAndDestroy();
 	// Decode the user data
 	TSmsOctet userDataLength;
 } // CSmsUserData::CSmsUserData
 void CSmsUserData::ConstructL()
 	{
-	LOGGSMU1("CSmsUserData::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_CONSTRUCTL_1, "CSmsUserData::ConstructL()");
 	NewBodyL(0);
 	} // CSmsUserData::ConstructL
 *  @return  Pointer to the newly created CSmsUserData object.
 */
 CSmsUserData* CSmsUserData::DuplicateL(TSmsFirstOctet& aFirstOctet,
 									   const TSmsDataCodingScheme& aDataCodingScheme) const
 	{
-	LOGGSMU1("CSmsUserData::DuplicateL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_DUPLICATEL_1, "CSmsUserData::DuplicateL()");
 	CSmsUserData*  userdata = CSmsUserData::NewL(iCharacterSetConverter, iFs,
 	                                             aFirstOctet, aDataCodingScheme);
 	CleanupStack::PushL(userdata);
 	} // CSmsUserData::DuplicateL
 TInt CSmsUserData::HeaderLength() const
 	{
-	LOGGSMU1("CSmsUserData::HeaderLength()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_HEADERLENGTH_1, "CSmsUserData::HeaderLength()");
 	TInt numinformationelements=NumInformationElements();
 	TInt headerlength=0;
 	for (TInt i=0; i<numinformationelements; i++)
 		headerlength+=iInformationElementArray[i]->Length();
 	} // CSmsUserData::HeaderLength
 TInt CSmsUserData::TotalHeaderLengthInUDLUnits() const
 	{
-	LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_TOTALHEADERLENGTHINUDLUNITS_1, "CSmsUserData::TotalHeaderLengthInUDLUnits()");
 	TInt totalheaderlengthinudlunits=0;
 	if (iInformationElementArray.Count()>0)
 		{
 		TInt totalheaderlength=1+HeaderLength();
 					{
 					totalheaderlengthinudlunits=totalheaderlength;
 					break;
 					}
 				default:
-				    LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits() WARNING default case has been reached");
+				    OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_TOTALHEADERLENGTHINUDLUNITS_2, "CSmsUserData::TotalHeaderLengthInUDLUnits() WARNING default case has been reached");
 break;
 				}
 			}
 		}
 	return totalheaderlengthinudlunits;
 	} // CSmsUserData::TotalHeaderLengthInUDLUnits
 TInt CSmsUserData::TotalHeaderLengthInUDLUnits(TInt aIElen) const
 	{
-	LOGGSMU1("CSmsUserData::TotalHeaderLengthInUDLUnits()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_TOTALHEADERLENGTHINUDLUNITS1_1, "CSmsUserData::TotalHeaderLengthInUDLUnits()");
 		TInt totalheaderlengthinudlunits=0;
 		TInt totalheaderlength=aIElen;
 		if (iInformationElementArray.Count()>0)
 	} // CSmsUserData::TotalHeaderLengthInUDLUnits
 TInt CSmsUserData::BodyLengthInUDLUnits() const
 	{
-	LOGGSMU1("CSmsUserData::BodyLengthInUDLUnits()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_BODYLENGTHINUDLUNITS_1, "CSmsUserData::BodyLengthInUDLUnits()");
 	return iBody->Des().Length();
 	} // CSmsUserData::BodyLengthInUDLUnits
 void CSmsUserData::NewBodyL(TInt aLength)
 	{
-	LOGGSMU1("CSmsUserData::NewBodyL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_NEWBODYL_1, "CSmsUserData::NewBodyL()");
 		HBufC8* body=HBufC8::NewL(aLength);
 		delete iBody;
 		iBody=body;
 	} // CSmsUserData::NewBodyL
 TBool CSmsUserData::HeaderPresent() const
 	{
-	LOGGSMU1("CSmsUserData::HeaderPresent()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_HEADERPRESENT_1, "CSmsUserData::HeaderPresent()");
 	return (iFirstOctet&TSmsFirstOctet::ESmsUDHIMask)==TSmsFirstOctet::ESmsUDHIHeaderPresent;
 	} // CSmsUserData::HeaderPresent
 void CSmsUserData::SetHeaderPresent(TBool aHeaderPresent)
 	{
-	LOGGSMU1("CSmsUserData::SetHeaderPresent()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_SETHEADERPRESENT_1, "CSmsUserData::SetHeaderPresent()");
 	iFirstOctet=aHeaderPresent? (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderPresent: (iFirstOctet&(~TSmsFirstOctet::ESmsUDHIMask))|TSmsFirstOctet::ESmsUDHIHeaderNotPresent;
 	} // CSmsUserData::SetHeaderPresent
 TBool CSmsUserData::IsBinaryData() const
 	{
-	LOGGSMU1("CSmsUserData::IsBinaryData()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CSMSUSERDATA_ISBINARYDATA_1, "CSmsUserData::IsBinaryData()");
 	TInt index=0;
 	return (iDataCodingScheme.TextCompressed()) ||
 			((iDataCodingScheme.Alphabet()==TSmsDataCodingScheme::ESmsAlphabet8Bit) &&
 			(InformationElementIndex(CSmsInformationElement::ESmsIEIApplicationPortAddressing8Bit,index) ||
 *
 *  @capability None
 */
 EXPORT_C void TGsmSmsTypeOfAddress::ConvertToETelMM(NMobilePhone::TMobileTON& aTon,NMobilePhone::TMobileNPI& aNpi) const
 {
-LOGGSMU1("TGsmSmsTypeOfAddress::ConvertToETelMM()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, TGSMSMSTYPEOFADDRESS_CONVERTTOETELMM_1, "TGsmSmsTypeOfAddress::ConvertToETelMM()");
 switch (TON())
 {
 		case EGsmSmsTONInternationalNumber:
 {
 *
 *  @capability None
 */
 EXPORT_C void TGsmSmsTypeOfAddress::SetFromETelMM(NMobilePhone::TMobileTON aTon,NMobilePhone::TMobileNPI aNpi)
 {
-LOGGSMU1("TGsmSmsTypeOfAddress::SetFromETelMM()");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, TGSMSMSTYPEOFADDRESS_SETFROMETELMM_1, "TGsmSmsTypeOfAddress::SetFromETelMM()");
 switch (aTon)
 {
 		case NMobilePhone::EInternationalNumber:
 {
 *
 *  @capability None
 */
 EXPORT_C TVoiceMailInfoType CEnhancedVoiceMailBoxInformation::Type() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Type()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_TYPE_1, "CEnhancedVoiceMailBoxInformation::Type()");
 	return iType;
 	} // CEnhancedVoiceMailBoxInformation::Type
 *
 *  @capability None
 */
 EXPORT_C void CEnhancedVoiceMailBoxInformation::SetProfile(TSmsMessageProfileType aProfile)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetProfile()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETPROFILE_1, "CEnhancedVoiceMailBoxInformation::SetProfile()");
 	iProfile = aProfile;
 	} // CEnhancedVoiceMailBoxInformation::SetProfile
 *
 *  @capability None
 */
 EXPORT_C TSmsMessageProfileType CEnhancedVoiceMailBoxInformation::Profile() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Profile()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_PROFILE_1, "CEnhancedVoiceMailBoxInformation::Profile()");
 	return iProfile;
 	} // CEnhancedVoiceMailBoxInformation::Profile
 *
 *  @capability None
 */
 EXPORT_C void CEnhancedVoiceMailBoxInformation::SetStorage(TBool aIsStored)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetStorage()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETSTORAGE_1, "CEnhancedVoiceMailBoxInformation::SetStorage()");
 	iStorage = aIsStored;
 	} // CEnhancedVoiceMailBoxInformation::SetStorage
 *
 *  @capability None
 */
 EXPORT_C TBool CEnhancedVoiceMailBoxInformation::Store() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::Store()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_STORE_1, "CEnhancedVoiceMailBoxInformation::Store()");
 	return iStorage;
 	} // CEnhancedVoiceMailBoxInformation::Store
 *
 *  @capability None
 */
 EXPORT_C void CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity(TBool aIsAlmostFull)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETALMOSTMAXIMUMCAPACITY_1, "CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity()");
 	iAlmostFull = aIsAlmostFull;
 	} // CEnhancedVoiceMailBoxInformation::SetAlmostMaximumCapacity
 *
 *  @capability None
 */
 EXPORT_C TBool CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_ALMOSTMAXIMUMCAPACITY_1, "CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity()");
 	return iAlmostFull;
 	} // CEnhancedVoiceMailBoxInformation::AlmostMaximumCapacity
 *
 *  @capability None
 */
 EXPORT_C void CEnhancedVoiceMailBoxInformation::SetMaximumCapacity(TBool aIsFull)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetMaximumCapacity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETMAXIMUMCAPACITY_1, "CEnhancedVoiceMailBoxInformation::SetMaximumCapacity()");
 	iFull = aIsFull;
 	} // CEnhancedVoiceMailBoxInformation::SetMaximumCapacity
 *
 *  @capability None
 */
 EXPORT_C TBool CEnhancedVoiceMailBoxInformation::MaximumCapacity() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::MaximumCapacity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_MAXIMUMCAPACITY_1, "CEnhancedVoiceMailBoxInformation::MaximumCapacity()");
 	return iFull;
 	} // CEnhancedVoiceMailBoxInformation::MaximumCapacity
 *
 *  @capability None
 */
 EXPORT_C TBool CEnhancedVoiceMailBoxInformation::ExtensionIndicator() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ExtensionIndicator()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_EXTENSIONINDICATOR_1, "CEnhancedVoiceMailBoxInformation::ExtensionIndicator()");
 	return iExtensionIndicator;
 	} // CEnhancedVoiceMailBoxInformation::ExtensionIndicator
 void CEnhancedVoiceMailBoxInformation::NewBufferL(TInt aLength)
 	{
-	LOGGSMU2("CEnhancedVoiceMailBoxInformation::NewBufferL, length = %d",aLength);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_NEWBUFFERL_1, "CEnhancedVoiceMailBoxInformation::NewBufferL, length = %d",aLength);
 	HBufC* buffer=HBufC::NewL(aLength);
 	delete iAccessAddress;
 	iAccessAddress=buffer;
 	iAccessAddress->Des().SetLength(aLength);
 *
 *  @capability None
 */
 EXPORT_C void  CEnhancedVoiceMailBoxInformation::SetAccessAddressL(const TDesC& aAddress)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetAccessAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETACCESSADDRESSL_1, "CEnhancedVoiceMailBoxInformation::SetAccessAddressL()");
 	TInt length=aAddress.Length();
 	NewBufferL(length);
 	iAccessAddress->Des().Copy(aAddress);
 *
 *  @capability None
 */
 EXPORT_C TPtrC CEnhancedVoiceMailBoxInformation::AccessAddress() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::AccessAddress()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_ACCESSADDRESS_1, "CEnhancedVoiceMailBoxInformation::AccessAddress()");
 	TPtrC ptr;
 	if (iAccessAddress)
 	    ptr.Set(iAccessAddress->Des());
 	return ptr;
 *
 *  @capability None
 */
 EXPORT_C void  CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL(const TGsmSmsTelNumber& aParsedAddress)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETPARSEDACCESSADDRESSL_1, "CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL()");
 	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
 	DoSetParsedAddressL(aParsedAddress.iTelNumber);
 	} // CEnhancedVoiceMailBoxInformation::SetParsedAccessAddressL
 *
 *  @capability None
 */
 EXPORT_C void  CEnhancedVoiceMailBoxInformation::ParsedAccessAddress(TGsmSmsTelNumber& aParsedAddress) const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ParsedAccessAddress()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_PARSEDACCESSADDRESS_1, "CEnhancedVoiceMailBoxInformation::ParsedAccessAddress()");
 	aParsedAddress.iTypeOfAddress = iTypeOfAddress;
 	TInt maxparsedlength=aParsedAddress.iTelNumber.MaxLength();
 	} // CEnhancedVoiceMailBoxInformation::ParsedAccessAddress
 void CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL(const TDesC& aAddress)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_DOSETPARSEDADDRESSL_1, "CEnhancedVoiceMailBoxInformation::DoSetParsedAddressL()");
 	TInt length=aAddress.Length();
 	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
 	    (length && (aAddress[0]!='+')))
 		{
 *
 *  @capability None
 */
 EXPORT_C void   CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages(TUint8 aNumber)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_SETNUMBEROFVOICEMESSAGES_1, "CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages()");
 	iNumberOfVoiceMessages=aNumber;
 	} // CEnhancedVoiceMailBoxInformation::SetNumberOfVoiceMessages
 *
 *  @capability None
 */
 EXPORT_C TUint8 CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages() const
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILBOXINFORMATION_NUMBEROFVOICEMESSAGES_1, "CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages()");
 	return iNumberOfVoiceMessages;
 	} // CEnhancedVoiceMailBoxInformation::NumberOfVoiceMessages
 	        ((((TUint8) iStorage)    & EMask1Bit ) << 4) +
 	        ((((TUint8) iAlmostFull) & EMask1Bit ) << 5) +
 	        ((((TUint8) iFull)       & EMask1Bit ) << 6) +
 	         (((TUint8) iExtensionIndicator      ) << 7);
-	LOGGSMU2("CEnhancedVoiceMailBoxInformation::EncodeL 1st byte = %d",*aPtr);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_ENCODEL_1, "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);
 	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);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_DECODEL_1, "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);
 	iTypeOfAddress = decodedAddress->TypeOfAddress();
 	CleanupStack::PopAndDestroy(decodedAddress);
 	iNumberOfVoiceMessages = aVoiceMailInfo.GetL();
-	LOGGSMU2("CEnhancedVoiceMailBoxInformation::DecodeL iNumberOfVoiceMessages = %d", iNumberOfVoiceMessages);
+	OstTraceDef1(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_DECODEL_2, "CEnhancedVoiceMailBoxInformation::DecodeL iNumberOfVoiceMessages = %d", iNumberOfVoiceMessages);
 	} // CEnhancedVoiceMailBoxInformation::DecodeL
 CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_CTOR_1, "CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");
 	// Consider changing this over to a Panic.
 	iType               = EGsmSmsVoiceMailNotification;
 	iOctet1Bit1         = EFalse;
 	iProfile            = EGsmSmsProfileId1;
 	} // CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation
 CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation(TVoiceMailInfoType aTVoiceMailInfoType)
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_CTOR1_1, "CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation()");
 	iType               = aTVoiceMailInfoType;
 	iOctet1Bit1         = EFalse;
 	iProfile            = EGsmSmsProfileId1;
 	iStorage            = EFalse;
 */
 CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation(const CEnhancedVoiceMailBoxInformation&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_CTOR2_1, "CEnhancedVoiceMailBoxInformation::CEnhancedVoiceMailBoxInformation");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 */
 TBool CEnhancedVoiceMailBoxInformation::operator==(const CEnhancedVoiceMailBoxInformation&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailBoxInformation::operator==");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_OPERATOR_1, "CEnhancedVoiceMailBoxInformation::operator==");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 return EFalse;
 BULLSEYE_RESTORE
 }
 */
 void CEnhancedVoiceMailBoxInformation::operator=(const CEnhancedVoiceMailBoxInformation&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailBoxInformation::operator=");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_OPERATOR1_1, "CEnhancedVoiceMailBoxInformation::operator=");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 void CEnhancedVoiceMailBoxInformation::ConstructL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_CONSTRUCTL_1, "CEnhancedVoiceMailBoxInformation::ConstructL()");
 	NewBufferL(0);
 	} // CEnhancedVoiceMailBoxInformation::ConstructL
 CEnhancedVoiceMailBoxInformation::~CEnhancedVoiceMailBoxInformation()
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::~CEnhancedVoiceMailBoxInformation");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_DTOR_1, "CEnhancedVoiceMailBoxInformation::~CEnhancedVoiceMailBoxInformation");
 	delete iAccessAddress;
 	} // CEnhancedVoiceMailBoxInformation::ConstructL
 CEnhancedVoiceMailBoxInformation* CEnhancedVoiceMailBoxInformation::NewL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailBoxInformation::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILBOXINFORMATION_NEWL_1, "CEnhancedVoiceMailBoxInformation::NewL()");
 	CEnhancedVoiceMailBoxInformation* aCEnhancedVoiceMailBoxInformation=new(ELeave) CEnhancedVoiceMailBoxInformation();
 	CleanupStack::PushL(aCEnhancedVoiceMailBoxInformation);
 	aCEnhancedVoiceMailBoxInformation->ConstructL();
 	CleanupStack::Pop(aCEnhancedVoiceMailBoxInformation);
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::SetMessageId(TUint16 aMessageId)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetMessageId()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETMESSAGEID_1, "CVoiceMailNotification::SetMessageId()");
 	iMessageId = aMessageId;
 	} // CVoiceMailNotification::SetMessageId
 *
 *  @capability None
 */
 EXPORT_C TUint16 CVoiceMailNotification::MessageId() const
 	{
-	LOGGSMU1("CVoiceMailNotification::MessageId()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_MESSAGEID_1, "CVoiceMailNotification::MessageId()");
 	return iMessageId;
 	} // CVoiceMailNotification::MessageId
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::SetMessageLength(TUint8 aLength)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetMessageLength()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETMESSAGELENGTH_1, "CVoiceMailNotification::SetMessageLength()");
 	iMessageLength=aLength;
 	} // CVoiceMailNotification::SetMessageLength
 *
 *  @capability None
 */
 EXPORT_C TUint8 CVoiceMailNotification::MessageLength() const
 	{
-	LOGGSMU1("CVoiceMailNotification::MessageLength()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_MESSAGELENGTH_1, "CVoiceMailNotification::MessageLength()");
 	return iMessageLength;
 	} // CVoiceMailNotification::MessageLength
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::SetRetentionDays(TUint8 aDays)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetRetentionDays()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETRETENTIONDAYS_1, "CVoiceMailNotification::SetRetentionDays()");
 	if (aDays > 31)
 	    {
 	    iRetentionDays = 31;
 	    }
 *
 *  @capability None
 */
 EXPORT_C TUint8 CVoiceMailNotification::RetentionDays() const
 	{
-	LOGGSMU1("CVoiceMailNotification::RetentionDays()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_RETENTIONDAYS_1, "CVoiceMailNotification::RetentionDays()");
 	return iRetentionDays;
 	} // CVoiceMailNotification::RetentionDays
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::SetPriorityIndication(TBool aPriority)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetPriorityIndication()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETPRIORITYINDICATION_1, "CVoiceMailNotification::SetPriorityIndication()");
 	iPriorityIndication=aPriority;
 	} // CVoiceMailNotification::SetPriorityIndication
 *
 *  @capability None
 */
 EXPORT_C TBool CVoiceMailNotification::PriorityIndication() const
 	{
-	LOGGSMU1("CVoiceMailNotification::PriorityIndication()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_PRIORITYINDICATION_1, "CVoiceMailNotification::PriorityIndication()");
 	return iPriorityIndication;
 	} // CVoiceMailNotification::PriorityIndication
 *
 *  @capability None
 */
 EXPORT_C TBool CVoiceMailNotification::MessageExtensionIndication() const
 	{
-	LOGGSMU1("CVoiceMailNotification::MessageExtensionIndication()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_MESSAGEEXTENSIONINDICATION_1, "CVoiceMailNotification::MessageExtensionIndication()");
 	return iMessageExtensionIndicator;
 	} // CVoiceMailNotification::MessageExtensionIndication
 void CVoiceMailNotification::NewBufferL(TInt aLength)
 	{
-	LOGGSMU1("CVoiceMailNotification::NewBufferL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_NEWBUFFERL_1, "CVoiceMailNotification::NewBufferL()");
 	HBufC* buffer=HBufC::NewL(aLength);
 	delete iCallingLineIdentity;
 	iCallingLineIdentity=buffer;
 	iCallingLineIdentity->Des().SetLength(aLength);
 *
 *  @capability None
 */
 EXPORT_C void  CVoiceMailNotification::SetCallingLineIdentityL(TDesC& aLineIdentity)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetCallingLineIdentityL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETCALLINGLINEIDENTITYL_1, "CVoiceMailNotification::SetCallingLineIdentityL()");
 	TInt length=aLineIdentity.Length();
 	NewBufferL(length);
 	iCallingLineIdentity->Des().Copy(aLineIdentity);
 *
 *  @capability None
 */
 EXPORT_C TPtrC CVoiceMailNotification::CallingLineIdentity() const
 	{
-	LOGGSMU1("CVoiceMailNotification::CallingLineIdentity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_CALLINGLINEIDENTITY_1, "CVoiceMailNotification::CallingLineIdentity()");
 	TPtrC ptr;
 	if (iCallingLineIdentity)
 	    ptr.Set(iCallingLineIdentity->Des());
 	return ptr;
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::SetParsedCallingLineIdentityL(TGsmSmsTelNumber& aParsedAddress)
 	{
-	LOGGSMU1("CVoiceMailNotification::SetParsedCallingLineIdentityL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_SETPARSEDCALLINGLINEIDENTITYL_1, "CVoiceMailNotification::SetParsedCallingLineIdentityL()");
 	iTypeOfAddress=aParsedAddress.iTypeOfAddress;
 	DoSetParsedAddressL(aParsedAddress.iTelNumber);
 	} // CVoiceMailNotification::SetParsedCallingLineIdentityL
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailNotification::ParsedCallingLineIdentity(TGsmSmsTelNumber& aParsedAddress) const
 	{
-	LOGGSMU1("CVoiceMailNotification::ParsedCallingLineIdentity()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_PARSEDCALLINGLINEIDENTITY_1, "CVoiceMailNotification::ParsedCallingLineIdentity()");
 	aParsedAddress.iTypeOfAddress = iTypeOfAddress;
 	TInt maxparsedlength=aParsedAddress.iTelNumber.MaxLength();
 	} // CVoiceMailNotification::ParsedCallingLineIdentity
 void CVoiceMailNotification::NewExtensionL(TInt aLength)
 	{
-	LOGGSMU1("CVoiceMailNotification::NewExtensionL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_NEWEXTENSIONL_1, "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.
 *
 *
 *  @capability None
 */
 TUint8 CVoiceMailNotification::SizeL(CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
 	{
-	LOGGSMU1("CVoiceMailNotification::SizeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_SIZEL_1, "CVoiceMailNotification::SizeL()");
 	const TUint8 KTotalSizeOfFixedLengthAttributes = 4;
 	TUint8 size = KTotalSizeOfFixedLengthAttributes;
 	// need to find the size of the calling line ID.
 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");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_ENCODEL_1, "CVoiceMailNotification::EncodeL");
 	*aPtr =   (TUint8)  (iMessageId                         >> 8);  // Message Id MSB
 	aPtr++;
 	*aPtr =   (TUint8)   iMessageId;                                // Message Id LSB
 	} // CVoiceMailNotification::EncodeL
 void CVoiceMailNotification::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
 	{
-	LOGGSMU1("CVoiceMailNotification::DecodeL");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_DECODEL_1, "CVoiceMailNotification::DecodeL");
 	iMessageId = (((TUint16) aVoiceMailInfo.GetL()) << 8);
 	iMessageId += ((TUint16) aVoiceMailInfo.GetL());
 	iMessageLength=aVoiceMailInfo.GetL();
 */
 CVoiceMailNotification::CVoiceMailNotification(const CVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailNotification::CVoiceMailNotification");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_CTOR_1, "CVoiceMailNotification::CVoiceMailNotification");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 */
 TBool CVoiceMailNotification::operator==(const CVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailNotification::operator==");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_OPERATOR_1, "CVoiceMailNotification::operator==");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 return EFalse;
 BULLSEYE_RESTORE
 }
 */
 void CVoiceMailNotification::operator=(const CVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailNotification::operator=");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_OPERATOR1_1, "CVoiceMailNotification::operator=");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 CVoiceMailNotification::CVoiceMailNotification()
 	{
-	LOGGSMU1("CVoiceMailNotification::CVoiceMailNotification()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_CTOR1_1, "CVoiceMailNotification::CVoiceMailNotification()");
 	iMessageId                 = 0;
 	iMessageLength             = 0;
 	iRetentionDays             = 0;
 	iOctetN8Bit1               = EFalse;
 *
 *  @capability None
 */
 EXPORT_C CVoiceMailNotification::~CVoiceMailNotification()
 	{
-	LOGGSMU1("CVoiceMailNotification::~CVoiceMailNotification");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_DTOR_1, "CVoiceMailNotification::~CVoiceMailNotification");
 	delete iCallingLineIdentity;
 	delete iExtension;
 	} // CVoiceMailNotification::CVoiceMailNotification
 void CVoiceMailNotification::ConstructL()
 	{
-	LOGGSMU1("CVoiceMailNotification::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_CONSTRUCTL_1, "CVoiceMailNotification::ConstructL()");
 	NewBufferL(0);
 	NewExtensionL(0);
 	} // CVoiceMailNotification::ConstructL
 *
 *  @capability None
 */
 EXPORT_C CVoiceMailNotification* CVoiceMailNotification::NewL()
 	{
-	LOGGSMU1("CVoiceMailNotification::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILNOTIFICATION_NEWL_1, "CVoiceMailNotification::NewL()");
 	CVoiceMailNotification* aCVoiceMailNotification=new(ELeave) CVoiceMailNotification();
 	CleanupStack::PushL(aCVoiceMailNotification);
 	aCVoiceMailNotification->ConstructL();
 	CleanupStack::Pop(aCVoiceMailNotification);
 	} // CVoiceMailNotification::NewL
 void CVoiceMailNotification::DoSetParsedAddressL(const TDesC& aAddress)
 	{
-	LOGGSMU1("CVoiceMailNotification::DoSetParsedAddressL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILNOTIFICATION_DOSETPARSEDADDRESSL_1, "CVoiceMailNotification::DoSetParsedAddressL()");
 	TInt length=aAddress.Length();
 	if ((iTypeOfAddress.TON()==EGsmSmsTONInternationalNumber) &&
 	    (length && (aAddress[0]!='+')))
 		{
 *
 *  @capability None
 */
 EXPORT_C TUint8 CEnhancedVoiceMailNotification::NumberOfVoiceMails()
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::NumberOfVoiceMails()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILNOTIFICATION_NUMBEROFVOICEMAILS_1, "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
 *
 *
 *  @capability None
 */
 EXPORT_C RPointerArray<CVoiceMailNotification>& CEnhancedVoiceMailNotification::GetVoiceMailNotifications()
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::GetVoiceMailNotifications()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILNOTIFICATION_GETVOICEMAILNOTIFICATIONS_1, "CEnhancedVoiceMailNotification::GetVoiceMailNotifications()");
 	return *iNotifications;
 	} // CEnhancedVoiceMailNotification::GetVoiceMailNotifications
 void CEnhancedVoiceMailNotification::NewExtensionL(TInt aLength)
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::NewExtensionL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_NEWEXTENSIONL_1, "CEnhancedVoiceMailNotification::NewExtensionL()");
 	HBufC* buffer=HBufC::NewL(aLength);
 	delete iExtension;
 	iExtension=buffer;
 	iExtension->Des().SetLength(aLength);
 *
 *  @capability None
 */
 EXPORT_C  CEnhancedVoiceMailNotification* CEnhancedVoiceMailNotification::NewL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILNOTIFICATION_NEWL_1, "CEnhancedVoiceMailNotification::NewL()");
 	CEnhancedVoiceMailNotification* aCEnhancedVoiceMailNotification=new(ELeave) CEnhancedVoiceMailNotification();
 	CleanupStack::PushL(aCEnhancedVoiceMailNotification);
 	aCEnhancedVoiceMailNotification->CEnhancedVoiceMailBoxInformation::ConstructL();
 	aCEnhancedVoiceMailNotification->ConstructL();
 */
 CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification(const CEnhancedVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_CTOR1_1, "CEnhancedVoiceMailNotification::CEnhancedVoiceMailNotification");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 */
 TBool CEnhancedVoiceMailNotification::operator==(const CEnhancedVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailNotification::operator==");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_OPERATOR_1, "CEnhancedVoiceMailNotification::operator==");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 return EFalse;
 BULLSEYE_RESTORE
 }
 */
 void CEnhancedVoiceMailNotification::operator=(const CEnhancedVoiceMailNotification&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailNotification::operator=");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_OPERATOR1_1, "CEnhancedVoiceMailNotification::operator=");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 *
 *  @capability None
 */
 EXPORT_C  CEnhancedVoiceMailNotification::~CEnhancedVoiceMailNotification()
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::~CEnhancedVoiceMailNotification");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILNOTIFICATION_DTOR_1, "CEnhancedVoiceMailNotification::~CEnhancedVoiceMailNotification");
 	delete iExtension;
 	iNotifications->ResetAndDestroy();
 	iNotifications->Close();
 	delete iNotifications;
 	} // CEnhancedVoiceMailNotification::operator
 void CEnhancedVoiceMailNotification::ConstructL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_CONSTRUCTL_1, "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");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_ENCODEL_1, "CEnhancedVoiceMailNotification::EncodeL");
 	TUint8* startPtr   = aCurrentPtr;
 	aCurrentPtr = CEnhancedVoiceMailBoxInformation::EncodeL(aCurrentPtr, aCharacterSetConverter, aFs);
 	} // CEnhancedVoiceMailNotification::EncodeL
 void CEnhancedVoiceMailNotification::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
 	{
-	LOGGSMU1("CEnhancedVoiceMailNotification::DecodeL");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILNOTIFICATION_DECODEL_1, "CEnhancedVoiceMailNotification::DecodeL");
 	CEnhancedVoiceMailBoxInformation::DecodeL(aVoiceMailInfo, aCharacterSetConverter, aFs);
 	TUint8 numberOfNotifications = (aVoiceMailInfo.GetL() & KSmsNotificationBitMask);
 *
 *  @capability None
 */
 EXPORT_C void CVoiceMailDeletion::SetMessageId(TUint16 aMessageId)
 	{
-	LOGGSMU1("CVoiceMailDeletion::SetMessageId()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILDELETION_SETMESSAGEID_1, "CVoiceMailDeletion::SetMessageId()");
 	iMessageId=aMessageId;
 	} // CVoiceMailDeletion::SetMessageId
 *
 *  @capability None
 */
 EXPORT_C TUint16 CVoiceMailDeletion::MessageId() const
 	{
-	LOGGSMU1("CVoiceMailDeletion::MessageId()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILDELETION_MESSAGEID_1, "CVoiceMailDeletion::MessageId()");
 	return iMessageId;
 	} // CVoiceMailDeletion::MessageId
 *
 *  @capability None
 */
 EXPORT_C TBool CVoiceMailDeletion::MessageExtensionIndication() const
 	{
-	LOGGSMU1("CVoiceMailDeletion::MessageExtensionIndication()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILDELETION_MESSAGEEXTENSIONINDICATION_1, "CVoiceMailDeletion::MessageExtensionIndication()");
 	return iExtensionIndicator;
 	} // CVoiceMailDeletion::MessageExtensionIndication
 TUint8 CVoiceMailDeletion::SizeL()
 	{
-	LOGGSMU1("CVoiceMailDeletion::SizeL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_SIZEL_1, "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");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_ENCODEL_1, "CVoiceMailDeletion::EncodeL");
 	*aPtr =  (TUint8) (iMessageId >> 8);
 	aPtr++;
 	*aPtr =  (TUint8) iMessageId;
 	aPtr++;
 	} // CVoiceMailDeletion::EncodeL
 void CVoiceMailDeletion::DecodeL(TGsmuLex8& aVoiceMailInfo)
 	{
-	LOGGSMU1("CVoiceMailDeletion::DecodeL");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_DECODEL_1, "CVoiceMailDeletion::DecodeL");
 	iMessageId = (((TUint16) aVoiceMailInfo.GetL()) << 8) +
 	              ((TUint16) aVoiceMailInfo.GetL());
 	iExtensionIndicator =    (aVoiceMailInfo.GetL() >> 7);
 */
 CVoiceMailDeletion::CVoiceMailDeletion(const CVoiceMailDeletion&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailDeletion::CVoiceMailDeletion");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_CTOR1_1, "CVoiceMailDeletion::CVoiceMailDeletion");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 */
 TBool CVoiceMailDeletion::operator==(const CVoiceMailDeletion&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailDeletion::operator==");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_OPERATOR_1, "CVoiceMailDeletion::operator==");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 return EFalse;
 BULLSEYE_RESTORE
 }
 */
 void CVoiceMailDeletion::operator=(const CVoiceMailDeletion&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CVoiceMailDeletion::operator=");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_OPERATOR1_1, "CVoiceMailDeletion::operator=");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 *
 *  @capability None
 */
 EXPORT_C CVoiceMailDeletion::~CVoiceMailDeletion()
 	{
-	LOGGSMU1("CVoiceMailDeletion::~CVoiceMailDeletion");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILDELETION_DTOR_1, "CVoiceMailDeletion::~CVoiceMailDeletion");
 	delete iExtension;
 	} // CVoiceMailDeletion::operator
 void CVoiceMailDeletion::ConstructL()
 	{
-	LOGGSMU1("CVoiceMailDeletion::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_CONSTRUCTL_1, "CVoiceMailDeletion::ConstructL()");
 	NewBufferL(0);
 	} // CVoiceMailDeletion::ConstructL
 void CVoiceMailDeletion::NewBufferL(TInt aLength)
 	{
-	LOGGSMU1("CVoiceMailDeletion::NewBufferL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CVOICEMAILDELETION_NEWBUFFERL_1, "CVoiceMailDeletion::NewBufferL()");
 	HBufC* buffer=HBufC::NewL(aLength);
 	delete iExtension;
 	iExtension=buffer;
 	iExtension->Des().SetLength(aLength);
 *
 *  @capability None
 */
 EXPORT_C CVoiceMailDeletion* CVoiceMailDeletion::NewL()
 	{
-	LOGGSMU1("CVoiceMailDeletion::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CVOICEMAILDELETION_NEWL_1, "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()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_NEWEXTENSIONL_1, "CEnhancedVoiceMailDeleteConfirmations::NewExtensionL()");
 	HBufC* buffer=HBufC::NewL(aLength);
 	delete iExtension;
 	iExtension=buffer;
 	iExtension->Des().SetLength(aLength);
 *
 *  @capability None
 */
 EXPORT_C  CEnhancedVoiceMailDeleteConfirmations::~CEnhancedVoiceMailDeleteConfirmations()
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::~CEnhancedVoiceMailDeleteConfirmations");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILDELETECONFIRMATIONS_DTOR_1, "CEnhancedVoiceMailDeleteConfirmations::~CEnhancedVoiceMailDeleteConfirmations");
 	delete iExtension;
 	iVoiceMailDeletions->ResetAndDestroy();
 	iVoiceMailDeletions->Close();
 	delete iVoiceMailDeletions;
 */
 CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations(const CEnhancedVoiceMailDeleteConfirmations&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_CTOR1_1, "CEnhancedVoiceMailDeleteConfirmations::CEnhancedVoiceMailDeleteConfirmations");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 /**
 */
 TBool CEnhancedVoiceMailDeleteConfirmations::operator==(const CEnhancedVoiceMailDeleteConfirmations&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::operator==");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_OPERATOR_1, "CEnhancedVoiceMailDeleteConfirmations::operator==");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 return EFalse;
 BULLSEYE_RESTORE
 }
 */
 void CEnhancedVoiceMailDeleteConfirmations::operator=(const CEnhancedVoiceMailDeleteConfirmations&)
 {
 // Ignore in code coverage - not intended to be used
 BULLSEYE_OFF
-LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::operator=");
+OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_OPERATOR1_1, "CEnhancedVoiceMailDeleteConfirmations::operator=");
 Panic(KGsmuPanicMethodBodyNotImplemented);
 BULLSEYE_RESTORE
 }
 void CEnhancedVoiceMailDeleteConfirmations::ConstructL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::ConstructL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_CONSTRUCTL_1, "CEnhancedVoiceMailDeleteConfirmations::ConstructL()");
 	NewExtensionL(0);
 	iVoiceMailDeletions = new (ELeave) RPointerArray<CVoiceMailDeletion>(15);
 	} // CEnhancedVoiceMailDeleteConfirmations::ConstructL
 *
 *  @capability None
 */
 EXPORT_C  CEnhancedVoiceMailDeleteConfirmations* CEnhancedVoiceMailDeleteConfirmations::NewL()
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::NewL()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILDELETECONFIRMATIONS_NEWL_1, "CEnhancedVoiceMailDeleteConfirmations::NewL()");
 	CEnhancedVoiceMailDeleteConfirmations* aCEnhancedVoiceMailDeleteConfirmations=new(ELeave) CEnhancedVoiceMailDeleteConfirmations();
 	CleanupStack::PushL(aCEnhancedVoiceMailDeleteConfirmations);
 	aCEnhancedVoiceMailDeleteConfirmations->CEnhancedVoiceMailBoxInformation::ConstructL();
 	aCEnhancedVoiceMailDeleteConfirmations->ConstructL();
 *
 *  @capability None
 */
 EXPORT_C TUint8  CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes()
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILDELETECONFIRMATIONS_NUMBEROFDELETES_1, "CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes()");
 	return iVoiceMailDeletions->Count();
 	} // CEnhancedVoiceMailDeleteConfirmations::NumberOfDeletes
 *
 *  @capability None
 */
 EXPORT_C RPointerArray<CVoiceMailDeletion>& CEnhancedVoiceMailDeleteConfirmations::GetVoiceMailDeletions()
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::GetVoiceMailDeletions()");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_BORDER, CENHANCEDVOICEMAILDELETECONFIRMATIONS_GETVOICEMAILDELETIONS_1, "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");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_ENCODEL_1, "CEnhancedVoiceMailDeleteConfirmations::EncodeL");
 	TUint8* startPtr   = aCurrentPtr;
 	aCurrentPtr = CEnhancedVoiceMailBoxInformation::EncodeL(aCurrentPtr, aCharacterSetConverter, aFs);
 	} // CEnhancedVoiceMailDeleteConfirmations::EncodeL
 void CEnhancedVoiceMailDeleteConfirmations::DecodeL(TGsmuLex8& aVoiceMailInfo, CCnvCharacterSetConverter& aCharacterSetConverter, RFs& aFs)
 	{
-	LOGGSMU1("CEnhancedVoiceMailDeleteConfirmations::DecodeL");
+	OstTraceDef0(OST_TRACE_CATEGORY_DEBUG, TRACE_INTERNALS, CENHANCEDVOICEMAILDELETECONFIRMATIONS_DECODEL_1, "CEnhancedVoiceMailDeleteConfirmations::DecodeL");
 	CEnhancedVoiceMailBoxInformation::DecodeL(aVoiceMailInfo, aCharacterSetConverter, aFs);
 	TUint numberOfVMDeletions = (aVoiceMailInfo.GetL() & KSmsNotificationBitMask);

changeset 42	3adadc800673
parent 20	244d7c5f118e
child 53	12b52b1a573e