--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/syncmlfw/common/syncagent/src/nsmlstatuscontainer.cpp	Thu Dec 17 09:07:52 2009 +0200
@@ -0,0 +1,634 @@
+/*
+* Copyright (c) 2002 Nokia Corporation and/or its subsidiary(-ies). 
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:  Client's Status command buffering
+*
+*/
+
+
+
+//#include "nsmlcliagdefines.h"
+#include "NSmlStatusContainer.h"
+#include "nsmlcliagconstants.h"
+#include "nsmlerror.h"
+#include "smlmetinfdtd.h"
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CNSmlStatusContainer
+// Constructor, nothing special in here.
+// ---------------------------------------------------------
+//
+CNSmlStatusContainer::CNSmlStatusContainer()
+	{
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::ConstructL()
+// Two-way construction. Constructor may leave in EPOC.
+// ---------------------------------------------------------
+//
+void CNSmlStatusContainer::ConstructL(TBool aClearText)
+	{
+	iClearText = aClearText;
+	iStatusArray = new( ELeave ) CArrayFixFlat<TStatusData>(KNSmlStatusArrayGranularity);
+	iArrayInd = -1;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::~CNSmlStatusContainer()
+// Destructor
+// ---------------------------------------------------------
+//
+
+CNSmlStatusContainer::~CNSmlStatusContainer()
+	{
+	delete iMsgRef;
+	if ( !iStatusArray )
+		{
+		return;
+		}
+	TInt arrayCount = iStatusArray->Count();
+	for ( TInt i = 0; i < arrayCount ; i++ )
+		{
+		FreeResources( i );
+		}
+	delete iStatusArray; 
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::NewL()
+// Creates new instance of CNSmlStatusContainer. 
+// Does not leave instance pointer to CleanupStack.
+// ---------------------------------------------------------
+//
+CNSmlStatusContainer* CNSmlStatusContainer::NewL( TBool aClearText)
+	{
+	CNSmlStatusContainer* self = CNSmlStatusContainer::NewLC(aClearText);
+	CleanupStack::Pop();
+	return( self );
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::NewLC()
+// Creates new instance of CNSmlStatusContainer 
+// Leaves instance pointer to CleanupStack.
+// ---------------------------------------------------------
+//
+CNSmlStatusContainer* CNSmlStatusContainer::NewLC(TBool aClearText)
+	{
+	CNSmlStatusContainer* self = new (ELeave) CNSmlStatusContainer();
+	CleanupStack::PushL( self );
+	self->ConstructL(aClearText);
+	return( self );
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::InitMsgRefL
+// Creates new empty Status element and adds it to the array
+// ---------------------------------------------------------
+//
+void CNSmlStatusContainer::InitMsgRefL( const SmlPcdata_t* aMsgRef )
+	{
+	delete iMsgRef;
+	iMsgRef = NULL;
+	CopyPcdataL( aMsgRef, iMsgRef );
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CreateNewStatusElementL()
+// Creates new empty Status element and adds it to the array
+// ---------------------------------------------------------
+//
+EXPORT_C TInt CNSmlStatusContainer::CreateNewStatusElementL()
+	{
+	TStatusData statusData;
+	statusData.status = NULL;
+	statusData.noResponse = EFalse;
+	statusData.wasWritten = EFalse;
+	statusData.atomicOrSequenceID = 0;
+	statusData.performedInAtomic = EFalse;
+	statusData.statusIsFixed = EFalse;
+	iStatusArray->AppendL( statusData );
+	TInt i = iStatusArray->Count() - 1;
+	(*iStatusArray)[i].status = new( ELeave ) SmlStatus_t;
+	(*iStatusArray)[i].status->elementType = SML_PE_STATUS;
+	CopyPcdataL( iMsgRef, (*iStatusArray)[i].status->msgRef );
+	return iStatusArray->Count();
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetCmdIDL()
+// Sets CmdID element
+// ---------------------------------------------------------
+//
+void CNSmlStatusContainer::SetCmdIDL( TInt aEntryID, const SmlPcdata_t* aCmdID )
+	{
+	delete (*iStatusArray)[aEntryID-1].status->cmdID;
+	(*iStatusArray)[aEntryID-1].status->cmdID = NULL;
+	CopyPcdataL( aCmdID, (*iStatusArray)[aEntryID-1].status->cmdID );
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetMsgRefL()
+// Sets MsgRef element
+// ---------------------------------------------------------
+//
+void CNSmlStatusContainer::SetMsgRefL( TInt aEntryID, const SmlPcdata_t* aMsgRef )
+	{
+	delete (*iStatusArray)[aEntryID-1].status->msgRef;
+	(*iStatusArray)[aEntryID-1].status->msgRef = NULL;
+	CopyPcdataL( aMsgRef, (*iStatusArray)[aEntryID-1].status->msgRef );
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetCmdRefL()
+// Sets CmdRef element
+// ---------------------------------------------------------
+//
+EXPORT_C void CNSmlStatusContainer::SetCmdRefL( TInt aEntryID, const SmlPcdata_t* aCmdRef )
+	{
+	delete (*iStatusArray)[aEntryID-1].status->cmdRef;
+	(*iStatusArray)[aEntryID-1].status->cmdRef = NULL;
+	CopyPcdataL( aCmdRef, (*iStatusArray)[aEntryID-1].status->cmdRef );
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetCmdL()
+// Sets CmdRef element
+// ---------------------------------------------------------
+//
+EXPORT_C void CNSmlStatusContainer::SetCmdL( TInt aEntryID, const TDesC8& aCmd )
+	{
+	delete (*iStatusArray)[aEntryID-1].status->cmd;
+	(*iStatusArray)[aEntryID-1].status->cmd = NULL;
+	CreatePcdataL( (*iStatusArray)[aEntryID-1].status->cmd, aCmd );
+	}
+	
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetStatusCodeL()
+// Sets Status code to Data element 
+// Created element is not pushed to Cleanup stack
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetStatusCodeL( TInt aEntryID, TInt aStatusCode, TBool aFixStatus )
+	{
+	//status code in data element
+	if ( !(*iStatusArray)[aEntryID-1].statusIsFixed )
+		{
+		HBufC8* statusCode = HBufC8::NewLC( KNSmlAgentStatusCodeLength );	
+		statusCode->Des().Num( aStatusCode );
+		if ( !(*iStatusArray)[aEntryID-1].status->data )
+			{
+			CreatePcdataL( (*iStatusArray)[aEntryID-1].status->data, *statusCode );
+			}
+		else
+			{
+			// Don't overwrite status 213 with 200, otherwise replace 
+			// existing status
+			TInt existingStatus( TNSmlError::ESmlStatusOK );
+			TBool ok = StatusCodeVal ( (*iStatusArray)[aEntryID-1].status->data, existingStatus );
+			if ( !( ok &&  existingStatus == TNSmlError::ESmlStatusItemAccepted &&
+			        aStatusCode == TNSmlError::ESmlStatusOK ) )
+		        {
+    			delete (*iStatusArray)[aEntryID-1].status->data;
+	    		(*iStatusArray)[aEntryID-1].status->data = NULL;
+		    	CreatePcdataL( (*iStatusArray)[aEntryID-1].status->data, *statusCode ); 			        
+			    }
+			}
+		if ( aFixStatus)
+			{
+			(*iStatusArray)[aEntryID-1].statusIsFixed = ETrue;
+			}
+		}
+	CleanupStack::PopAndDestroy(); //statusCode
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetChalL()
+// Creates Chal element 
+// ---------------------------------------------------------
+void CNSmlStatusContainer::SetChalL( TInt aEntryID, const TDesC8& aNonce )
+	{
+	(*iStatusArray)[aEntryID-1].status->chal = new( ELeave ) SmlChal_t;
+	SmlMetInfMetInf_t* metInf = new( ELeave ) SmlMetInfMetInf_t;
+	CleanupStack::PushL( metInf );
+	CreatePcdataL( metInf->type, KNSmlAgentAuthMD5 );
+	CreatePcdataL( metInf->format, KNSmlAgentBase64Format );
+	CreatePcdataL( metInf->nextnonce, aNonce );
+	(*iStatusArray)[aEntryID-1].status->chal->meta = new( ELeave ) SmlPcdata_t; 
+	(*iStatusArray)[aEntryID-1].status->chal->meta->length = 0;
+	(*iStatusArray)[aEntryID-1].status->chal->meta->content = ( TAny* ) metInf;
+	CleanupStack::Pop(); //metInf
+	(*iStatusArray)[aEntryID-1].status->chal->meta->contentType = SML_PCDATA_EXTENSION;
+	(*iStatusArray)[aEntryID-1].status->chal->meta->extension = SML_EXT_METINF;
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetNoResponse
+// Sets NoResponse flag 
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetNoResponse( TInt aEntryID, TBool aNoResponse )
+	{
+	(*iStatusArray)[aEntryID-1].noResponse = aNoResponse;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetAtomicOrSequenceId
+// Sets Atomic or Sequence Id  
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetAtomicOrSequenceId( TInt aEntryID, TInt aAtomicOrSequenceID )
+	{
+	(*iStatusArray)[aEntryID-1].atomicOrSequenceID = aAtomicOrSequenceID;
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetPerformedInAtomic
+// Mark an item be performed inside Atomic 
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetPerformedInAtomic( TInt aEntryID )
+	{
+	(*iStatusArray)[aEntryID-1].performedInAtomic = ETrue;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetStatusCodeToAtomicOrSequenceCmdL
+// Change status code for Atomic command 
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetStatusCodeToAtomicOrSequenceCmdL( TInt aAtomicOrSequenceID, TInt aStatusCode, const TDesC8& aCmd )
+	{
+	TInt arrayCount = iStatusArray->Count();
+	for ( TInt i = 0; i < arrayCount; i++ )
+		{
+		if ( (*iStatusArray)[i].atomicOrSequenceID == aAtomicOrSequenceID )
+			{
+			if ( (*iStatusArray)[i].status->cmd )
+				{
+				if ( (*iStatusArray)[i].status->cmd->content )
+					{
+					TPtrC8 cmd( (TUint8*) (*iStatusArray)[i].status->cmd->content, (*iStatusArray)[i].status->cmd->length );
+					if ( cmd == aCmd )
+						{
+						SetStatusCodeL( i + 1, aStatusCode );
+						break;
+						}
+					}
+				}
+			}
+		}
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::SetStatusCodesInAtomicL
+// Change status code to all items in Atomic or to items which 
+// have been already performed
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::SetStatusCodesInAtomicL( TInt aAtomicID, TInt aStatusCode, TBool aOnlyForPerformed )
+	{
+	TInt arrayCount = iStatusArray->Count();
+	for ( TInt i = 0; i < arrayCount; i++ )
+		{
+		if ( !(*iStatusArray)[i].atomicOrSequenceID == aAtomicID )
+			{
+			continue;
+			}
+		if ( (!aOnlyForPerformed) || ( aOnlyForPerformed && (*iStatusArray)[i].performedInAtomic ) )
+			{
+			SetStatusCodeL( i + 1, aStatusCode );
+			}
+		}
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::AddTargetRefL
+// Adds TargetRef element
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::AddTargetRefL( TInt aEntryID, const SmlTarget_t* aTarget )
+	{
+	if ( !aTarget )
+		{
+		return;
+		}
+	if ( !aTarget->locURI )
+		{
+		return;
+		}
+	if ( !aTarget->locURI->content )
+		{
+		return;
+		}
+	SmlTargetRefList_t** targetRefList;
+	targetRefList = &(*iStatusArray)[aEntryID-1].status->targetRefList;
+	while( *targetRefList )
+		{
+		targetRefList = &(*targetRefList)->next;
+		} 
+	*targetRefList = new( ELeave ) SmlTargetRefList_t;
+	CreateTargetRefL( aTarget, (*targetRefList)->targetRef ); 
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::AddSourceRefL
+// Adds SourceRef element
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::AddSourceRefL( TInt aEntryID, const SmlSource_t* aSource )
+	{
+	if ( !aSource )
+		{
+		return;
+		}
+	if ( !aSource->locURI )
+		{
+		return;
+		}
+	if ( !aSource->locURI->content )
+		{
+		return;
+		}
+	SmlSourceRefList_t** sourceRefList;
+	sourceRefList = &(*iStatusArray)[aEntryID-1].status->sourceRefList;
+	while ( *sourceRefList )
+		{
+		sourceRefList = &(*sourceRefList)->next;
+		} 
+	*sourceRefList = new( ELeave ) SmlSourceRefList_t;
+	CreateSourceRefL( aSource, (*sourceRefList)->sourceRef ); 
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::AddItemDataL
+// Adds Item/Data element 
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::AddItemDataL (TInt aEntryID, const SmlPcdata_t* aData )
+	{
+	SmlItemList_t* newItemList = new( ELeave ) SmlItemList_t;
+	CleanupStack::PushL( newItemList );
+	newItemList->item = new( ELeave ) SmlItem_t;
+	CopyPcdataL( aData, newItemList->item->data );
+	SmlItemList_t** itemList;
+	itemList = &(*iStatusArray)[aEntryID-1].status->itemList;
+	while ( *itemList )
+		{
+		itemList = &(*itemList)->next;
+		}
+	*itemList = newItemList;
+	CleanupStack::Pop(); //newItemList
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::RemoveWritten()
+// Marks Status command written in outgoing XML document  
+// ---------------------------------------------------------
+void CNSmlStatusContainer::RemoveWritten( TInt aEntryID )
+	{
+	(*iStatusArray)[aEntryID-1].wasWritten = ETrue;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::Begin
+// Sets index for reading to starting value 
+// ---------------------------------------------------------
+EXPORT_C void CNSmlStatusContainer::Begin()
+	{
+	iArrayInd = -1;
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::NextStatusElement()
+// Returns pointer to the next Status element 
+// ---------------------------------------------------------
+EXPORT_C TBool CNSmlStatusContainer::NextStatusElement( SmlStatus_t*& aStatus, TBool aOnlyIfResponse )
+	{
+	TBool moreElements( ETrue );
+	while ( moreElements )
+		{
+		iArrayInd++;
+		if ( iArrayInd > iStatusArray->Count() - 1 )
+			{
+			RemoveAllWrittenOnes();
+			iArrayInd = -1;
+			moreElements = EFalse;
+			}
+		else
+			{
+			if ( aOnlyIfResponse && (*iStatusArray)[iArrayInd].noResponse )
+				{
+				}
+			else 
+			if ( !(*iStatusArray)[iArrayInd].wasWritten )
+				{
+				aStatus = (*iStatusArray)[iArrayInd].status;
+				return ETrue;
+				}
+			}
+		}
+	return moreElements;
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CurrentEntryID()
+// Returns current status ID 
+// ---------------------------------------------------------
+TInt CNSmlStatusContainer::CurrentEntryID() const
+	{
+	return( iArrayInd + 1);
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::LastEntryID()
+// Returns last status ID 
+// ---------------------------------------------------------
+EXPORT_C TInt CNSmlStatusContainer::LastEntryID() const
+	{
+	return iStatusArray->Count();
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::AnyOtherThanSyncHdrStatus()
+// 
+// ---------------------------------------------------------
+TBool CNSmlStatusContainer::AnyOtherThanOkSyncHdrStatus() const
+	{
+	TBool statusPresents = EFalse;
+	TInt arrayCount = iStatusArray->Count();
+	for ( TInt i = 0; i < arrayCount; i++ )
+		{
+		if ( !(*iStatusArray)[i].noResponse )
+			{
+			if ( (*iStatusArray)[i].status->cmd )
+				{
+				if ( (*iStatusArray)[i].status->cmd->content )
+					{
+					TPtrC8 cmd( (TUint8*) (*iStatusArray)[i].status->cmd->content, (*iStatusArray)[i].status->cmd->length );
+					if ( cmd == KNSmlAgentSyncHdr )
+						{
+						if ( (*iStatusArray)[i].status->data )
+							{
+							if ( (*iStatusArray)[i].status->data->content )
+								{
+								TPtrC8 statusCode( (TUint8*) (*iStatusArray)[i].status->data->content, (*iStatusArray)[i].status->data->length );
+								TLex8 lexicalValue( statusCode );
+								TInt statusCodeNum;
+								if ( lexicalValue.Val( statusCodeNum ) != KErrNone )
+									{
+									if ( statusCodeNum != TNSmlError::ESmlStatusOK &&
+										 statusCodeNum != TNSmlError::ESmlStatusAuthenticationAccepted )
+										{
+										statusPresents = ETrue;
+										break;
+										}
+									}
+								}
+							}
+						}
+					else
+						{
+						statusPresents = ETrue;
+						break;
+						}
+					}
+				}
+			}
+		}	
+	return statusPresents;
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CreatePcdataL()
+// Creates Pcdata 
+// Created element is not pushed to Cleanup stack
+// ---------------------------------------------------------
+void CNSmlStatusContainer::CreatePcdataL( SmlPcdata_t*& aPcdata, const TDesC8& aContent ) const
+	{
+	aPcdata = new( ELeave ) SmlPcdata_t;
+	aPcdata->SetDataL( aContent );
+	aPcdata->contentType = SML_PCDATA_OPAQUE;   
+	aPcdata->extension = SML_EXT_UNDEFINED; 
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CopyPcdataL()
+// Deep copy to Pcdata element
+// Copied element is not pushed to Cleanup stack
+// ---------------------------------------------------------
+//
+void CNSmlStatusContainer::CopyPcdataL( const SmlPcdata_t* aFromPcdata, SmlPcdata_t*& aToPcdata ) const
+	{
+	aToPcdata = NULL;
+	if ( aFromPcdata )
+		{
+		SmlPcdata_t* newPcdata = new( ELeave ) SmlPcdata_t;
+		CleanupStack::PushL( newPcdata );
+		newPcdata->length = aFromPcdata->length;
+		if (iClearText)
+			{
+			newPcdata->contentType = SML_PCDATA_STRING;
+			}
+		else
+			{
+			newPcdata->contentType = SML_PCDATA_OPAQUE;
+			}   
+		newPcdata->extension = SML_EXT_UNDEFINED; 
+		if ( aFromPcdata->content )
+			{
+			if ( aFromPcdata->contentType == SML_PCDATA_EXTENSION && aFromPcdata->extension == SML_EXT_METINF )
+				{
+				newPcdata->contentType = SML_PCDATA_EXTENSION;
+				newPcdata->extension = aFromPcdata->extension;
+				newPcdata->length = 0;
+				CopyMetInfL( aFromPcdata->content, newPcdata->content );
+				}
+			else
+				{
+				newPcdata->content = User::AllocL( 	newPcdata->length );
+				TPtr8 fromPtr ( (TUint8*) aFromPcdata->content, aFromPcdata->length );
+				fromPtr.SetLength( fromPtr.MaxLength() );
+				TPtr8 toPtr ( (TUint8*) newPcdata->content, newPcdata->length );
+				toPtr.SetLength( toPtr.MaxLength() );
+				toPtr = fromPtr;
+				}
+			}	
+		CleanupStack::Pop();  //newPcdata 
+		aToPcdata = newPcdata;
+		}
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CopyMetInfL()
+// Deep copy to Meta Info
+// ---------------------------------------------------------
+void CNSmlStatusContainer::CopyMetInfL ( const void* aFromMetInf, void*& aToMetInf ) const
+	{
+	if ( aFromMetInf )
+		{
+		SmlMetInfMetInf_t* fromMetInf = (SmlMetInfMetInf_t*) aFromMetInf;
+		SmlMetInfMetInf_t* toMetInf = new( ELeave ) SmlMetInfMetInf_t;
+		if ( fromMetInf->anchor )
+			{
+			toMetInf->anchor = new( ELeave ) SmlMetInfAnchor_t;
+			CopyPcdataL( fromMetInf->anchor->next, toMetInf->anchor->next );
+			}
+		aToMetInf = toMetInf;
+		}
+	}
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CreateTargetOrSourceRefL()
+// Creates TargetRef or SourceRef element
+// ---------------------------------------------------------
+void CNSmlStatusContainer::CreateSourceRefL( const SmlSource_t* aSource, SmlPcdata_t*& aSourceRef ) const
+	{
+	CopyPcdataL( aSource->locURI, aSourceRef );
+	}
+
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::CreateTargetOrSourceRefL()
+// Creates TargetRef or SourceRef element
+// ---------------------------------------------------------
+void CNSmlStatusContainer::CreateTargetRefL( const SmlTarget_t* aTarget, SmlPcdata_t*& aTargetRef ) const
+	{
+	CopyPcdataL( aTarget->locURI, aTargetRef );
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::RemoveAllWrittenOnes()
+// Removes all written Status elements 
+// ---------------------------------------------------------
+void CNSmlStatusContainer::RemoveAllWrittenOnes()
+	{
+	for ( TInt i = iStatusArray->Count() - 1; i >= 0; i--)
+		{
+		if ( (*iStatusArray)[i].wasWritten )
+			{
+			FreeResources( i );
+			iStatusArray->Delete( i );
+			}
+		}
+	iStatusArray->Compress();
+	iArrayInd = -1;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::FreeResources()
+// Frees resources of an item
+// ---------------------------------------------------------
+void CNSmlStatusContainer::FreeResources( TInt aI )
+	{
+	delete (*iStatusArray)[aI].status;
+	}
+
+// ---------------------------------------------------------
+// CNSmlStatusContainer::StatusCodeVal()
+// Converts status code to integer value
+// ---------------------------------------------------------
+TBool CNSmlStatusContainer::StatusCodeVal ( SmlPcdata_t*& aStatusCodeData, TInt& aVal ) const
+    {
+    TBool ret(EFalse);
+	if ( aStatusCodeData->content )
+	    {
+	    TPtrC8 statusCode( (TUint8*) aStatusCodeData->content, aStatusCodeData->length );
+	    TLex8 lexicalValue( statusCode );
+	    TInt statusCodeNum( TNSmlError::ESmlStatusOK );
+        if ( lexicalValue.Val( statusCodeNum ) == KErrNone )
+		    {
+		    ret = ETrue;
+		    aVal = statusCodeNum;
+			}
+		else
+		    {
+		    aVal = 0;
+		    }
+	    }
+	return ret;
+    }
+    
+