diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/server/src/ncdnodeidentifier.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/ncdengine/provider/server/src/ncdnodeidentifier.cpp	Thu Dec 17 08:51:10 2009 +0200
@@ -0,0 +1,844 @@
+/*
+* Copyright (c) 2006-2008 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:   Implements CNcdNodeIdentifier class
+*
+*/
+
+
+#include <e32cmn.h>
+#include <s32strm.h>
+#include <s32mem.h>
+
+#include "ncdnodeidentifier.h"
+#include "ncdproviderdefines.h"
+#include "catalogsutils.h"
+#include "catalogsconstants.h"
+
+// CNcdNodeIdentifier uses different implementation when compiled for the server than
+// in other places
+#ifdef COMPONENT_CATALOGSSERVEREXE 
+
+#include "catalogsrefstring.h"
+#include "catalogsstringmanager.h"
+
+// For memory consumption logging
+#ifdef LOG_MEMORY_USAGE
+TInt64 CNcdNodeIdentifier::iCurrentMemory = 0;
+TInt64 CNcdNodeIdentifier::iMaxMemory = 0;
+TInt CNcdNodeIdentifier::iIdCount = 0;
+TInt CNcdNodeIdentifier::iMaxCount = 0;
+
+    
+void CNcdNodeIdentifier::AddId( const CNcdNodeIdentifier& /*aId*/, TInt64& aMemory )
+    {
+
+    aMemory = 
+/*
+        aId.NodeId().Size() + 
+        aId.NodeNameSpace().Size() +
+        aId.ServerUri().Size() +        */
+        sizeof( CNcdNodeIdentifier ) -
+        sizeof( TInt64 ); // ignore the size of this temporary member
+    
+    iCurrentMemory += aMemory;
+    if ( iCurrentMemory > iMaxMemory ) 
+        {
+        iMaxMemory = iCurrentMemory;
+        }        
+  
+    iIdCount++;
+    if ( iIdCount > iMaxCount ) 
+        {
+        iMaxCount = iIdCount;
+        }    
+    DLTRACE(("Memory: %Ld kB, max: %Ld kB, count: %d, max: %d", 
+        iCurrentMemory >> 10, iMaxMemory >> 10, iIdCount, iMaxCount ));       
+    }
+    
+    
+void CNcdNodeIdentifier::RemoveId( const CNcdNodeIdentifier& /*aId*/, const TInt64& aMemory )
+    {
+    iIdCount--;
+
+   
+    iCurrentMemory -= aMemory;
+    DLTRACE(("Memory: %Ld, max: %Ld, count: %d, max: %d", 
+        iCurrentMemory, iMaxMemory, iIdCount, iMaxCount ));    
+    
+    }
+#endif // LOG_MEMORY_USAGE
+
+
+
+
+CNcdNodeIdentifier::CNcdNodeIdentifier(): CBase()
+    {
+    }
+
+
+CNcdNodeIdentifier::CNcdNodeIdentifier( const CNcdNodeIdentifier& aId ) 
+    : CBase(),
+    iNodeNameSpace( aId.iNodeNameSpace ),
+    iNodeId( aId.iNodeId ), 
+    iServerUri( aId.iServerUri ),
+    iClientUid( aId.iClientUid )    
+    {
+    iNodeNameSpace->AddRef();
+    iNodeId->AddRef();
+    iServerUri->AddRef();
+    }
+
+
+CNcdNodeIdentifier::~CNcdNodeIdentifier()
+    {   
+#ifdef LOG_MEMORY_USAGE
+    if ( iMyMemory ) 
+        {        
+        RemoveId( *this, iMyMemory );
+        }
+#endif    
+    
+    ReleaseStrings();
+    }
+
+
+void CNcdNodeIdentifier::ReleaseStrings()
+    {
+    if ( iNodeNameSpace ) 
+        {
+        CCatalogsStringManager::StringManager().ReleaseString( 
+            NcdProviderDefines::ENcdStringNamespace,        
+            *iNodeNameSpace );
+        iNodeNameSpace = NULL;
+        }
+
+    if ( iNodeId ) 
+        {
+        CCatalogsStringManager::StringManager().ReleaseString( 
+            NcdProviderDefines::ENcdStringNodeId,        
+            *iNodeId );
+        iNodeId = NULL;
+        }
+
+    if ( iServerUri ) 
+        {
+        CCatalogsStringManager::StringManager().ReleaseString( 
+            NcdProviderDefines::ENcdStringServerUri,        
+            *iServerUri );
+        iServerUri = NULL;
+        }
+
+    }
+
+void CNcdNodeIdentifier::ConstructL( const TDesC& aNodeNameSpace,
+                                     const TDesC& aNodeId,
+                                     const TDesC& aServerUri,
+                                     const TUid& aClientUid )
+    {
+    iNodeNameSpace = &CCatalogsStringManager::StringManager().StringL( 
+        NcdProviderDefines::ENcdStringNamespace,
+        aNodeNameSpace );
+        
+    iNodeId = &CCatalogsStringManager::StringManager().StringL( 
+        NcdProviderDefines::ENcdStringNodeId, 
+        aNodeId );
+        
+    iServerUri = &CCatalogsStringManager::StringManager().StringL(
+        NcdProviderDefines::ENcdStringServerUri,
+        aServerUri );
+    
+    iClientUid = aClientUid;    
+
+#ifdef LOG_MEMORY_USAGE
+    AddId( *this, iMyMemory );
+#endif    
+    }
+    
+
+void CNcdNodeIdentifier::ConstructL( const TDesC8& aNodeIdentifierData )
+    {
+    RDesReadStream readStream( aNodeIdentifierData );
+    CleanupClosePushL( readStream );
+    InternalizeL( readStream );
+    CleanupStack::PopAndDestroy( &readStream );
+
+#ifdef LOG_MEMORY_USAGE
+    AddId( *this, iMyMemory );
+#endif    
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL()
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC();
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC()
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( KNullDesC(), KNullDesC(), KNullDesC(), TUid::Null() );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC& aNodeNameSpace,
+                                              const TDesC& aNodeId,
+                                              const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC(
+            aNodeNameSpace,
+            aNodeId,
+            aClientUid );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC& aNodeNameSpace,
+                                               const TDesC& aNodeId,
+                                               const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeNameSpace, aNodeId, KNullDesC(), aClientUid );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC& aNodeNameSpace,
+                                              const TDesC& aNodeId,
+                                              const TDesC& aServerUri,
+                                              const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC(
+            aNodeNameSpace,
+            aNodeId,
+            aServerUri,
+            aClientUid );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC& aNodeNameSpace,
+                                               const TDesC& aNodeId,
+                                               const TDesC& aServerUri,
+                                               const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeNameSpace, aNodeId, aServerUri, aClientUid );
+    return self;
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL(
+    const CNcdNodeIdentifier& aNodeIdentifier )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC( aNodeIdentifier );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC(
+    const CNcdNodeIdentifier& aNodeIdentifier )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier( aNodeIdentifier );
+    CleanupStack::PushL( self );
+    return self;
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC8& aNodeIdentifierData )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC( aNodeIdentifierData );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC8& aNodeIdentifierData )
+    {
+    CNcdNodeIdentifier* self = new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeIdentifierData );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( RReadStream& aReadStream )
+    {
+    CNcdNodeIdentifier* self = NewLC( aReadStream );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( RReadStream& aReadStream )
+    {
+    CNcdNodeIdentifier* self = new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->InternalizeL( aReadStream );
+    return self;        
+    }
+
+
+void CNcdNodeIdentifier::InternalizeL( RReadStream& aReadStream )
+    {
+    HBufC* temp = NULL;
+    InternalizeDesL( temp, aReadStream );    
+
+    
+    // StringL handles the ownership of temp
+    const CCatalogsRefString& nameSpace = 
+        CCatalogsStringManager::StringManager().StringL( 
+            NcdProviderDefines::ENcdStringNamespace,
+            temp );
+    
+    CCatalogsStringManager::StringManager().ReleaseString(
+        NcdProviderDefines::ENcdStringNamespace,
+        iNodeNameSpace );
+    
+    iNodeNameSpace = &nameSpace;
+    
+    temp = NULL;
+    
+    InternalizeDesL( temp, aReadStream );
+    
+    
+    const CCatalogsRefString& nodeId = 
+        CCatalogsStringManager::StringManager().StringL( 
+            NcdProviderDefines::ENcdStringNodeId,
+            temp );
+
+
+    CCatalogsStringManager::StringManager().ReleaseString(
+        NcdProviderDefines::ENcdStringNodeId,
+        iNodeId );
+    
+    iNodeId = &nodeId;
+    
+    temp = NULL;
+    
+    InternalizeDesL( temp, aReadStream );
+    
+    const CCatalogsRefString& serverUri = 
+        CCatalogsStringManager::StringManager().StringL( 
+            NcdProviderDefines::ENcdStringServerUri,
+            temp );    
+
+    CCatalogsStringManager::StringManager().ReleaseString(
+        NcdProviderDefines::ENcdStringServerUri,
+        iServerUri );
+
+    iServerUri = &serverUri;          
+   
+    iClientUid.iUid = aReadStream.ReadInt32L();      
+    }
+
+
+void CNcdNodeIdentifier::ExternalizeL( RWriteStream& aWriteStream ) const
+    {
+    ExternalizeDesL( NodeNameSpace(), aWriteStream );
+    ExternalizeDesL( NodeId(), aWriteStream );
+    ExternalizeDesL( ServerUri(), aWriteStream );
+    aWriteStream.WriteInt32L( iClientUid.iUid );    
+    }
+ 
+        
+const TDesC& CNcdNodeIdentifier::NodeNameSpace() const
+    {
+    DASSERT( iNodeNameSpace );
+    return *iNodeNameSpace;
+    }    
+
+const TDesC& CNcdNodeIdentifier::NodeId() const
+    {
+    DASSERT( iNodeId );
+    return *iNodeId;
+    }
+
+const TDesC& CNcdNodeIdentifier::ServerUri() const
+    {
+    DASSERT( iServerUri );
+    return *iServerUri;
+    }
+
+const TUid& CNcdNodeIdentifier::ClientUid() const
+    {
+    return iClientUid;
+    }
+
+
+HBufC8* CNcdNodeIdentifier::NodeIdentifierDataL() const
+    {
+    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );
+    CleanupStack::PushL( buf );
+    RBufWriteStream stream( *buf );
+    CleanupClosePushL( stream );
+
+    // Get the data of this identifier into the stream which
+    // directs the data into the buffer.
+    ExternalizeL( stream );
+
+    // Now data has been externalized into the buffer.
+    // Create copy of the data and return it.
+    HBufC8* data = buf->Ptr( 0 ).AllocL();
+    CleanupStack::PopAndDestroy( &stream );
+    CleanupStack::PopAndDestroy( buf );
+    return data;
+    }
+    
+
+TBool CNcdNodeIdentifier::ContainsEmptyFields(
+    TBool aCheckNameSpace,
+    TBool aCheckId,
+    TBool aCheckUri,
+    TBool aCheckUid ) const
+    {
+    return ( aCheckNameSpace && NodeNameSpace() == KNullDesC() )
+        || ( aCheckId && NodeId() == KNullDesC() )
+        || ( aCheckUri && ServerUri() == KNullDesC() )
+        || ( ClientUid() == TUid::Null() && aCheckUid );
+    }
+
+
+TBool CNcdNodeIdentifier::Equals( 
+    const CNcdNodeIdentifier& aObject,
+    TBool aCompareNameSpace,
+    TBool aCompareId,
+    TBool aCompareUri,
+    TBool aCompareUid ) const
+    {
+    // Use pointer comparison for strings
+    return ( iNodeNameSpace == aObject.iNodeNameSpace
+                || !aCompareNameSpace ) 
+           && ( iNodeId == aObject.iNodeId
+                || !aCompareId )
+           && ( iServerUri == aObject.iServerUri 
+                || !aCompareUri )
+           && ( ClientUid() == aObject.ClientUid() 
+                || !aCompareUid );
+
+    }
+
+TBool CNcdNodeIdentifier::Equals( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2,
+    TBool aCompareNameSpace,
+    TBool aCompareId,
+    TBool aCompareUri,
+    TBool aCompareUid )
+    {
+    return aObject1.Equals( 
+        aObject2, 
+        aCompareNameSpace, 
+        aCompareId,
+        aCompareUri,
+        aCompareUid );
+    }
+
+
+TInt CNcdNodeIdentifier::Compare( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2 )
+    {
+    // First compare pointers, if they differ compare strings
+    TInt comp = ( aObject1.iNodeId != aObject2.iNodeId );
+    if ( comp ) 
+        {
+        comp = aObject1.NodeId().Compare( aObject2.NodeId() );    
+        }
+    
+    if ( !comp ) 
+        {
+        comp = ( aObject1.iNodeNameSpace != aObject2.iNodeNameSpace );
+        if ( comp ) 
+            {            
+            comp = aObject1.NodeNameSpace().Compare( aObject2.NodeNameSpace() );
+            }
+            
+        if ( !comp ) 
+            {
+            comp = aObject1.ClientUid().iUid - aObject2.ClientUid().iUid;
+            }
+        }
+    return comp;        
+    }
+
+
+TInt CNcdNodeIdentifier::CompareOrderByUid( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2 )
+    {
+    TInt comp = aObject1.ClientUid().iUid - aObject2.ClientUid().iUid;
+        
+    if ( !comp ) 
+        {
+        comp = aObject1.NodeNameSpace().Compare( aObject2.NodeNameSpace() );
+        if ( !comp ) 
+            {
+            comp = aObject1.NodeId().Compare( aObject2.NodeId() );            
+            }
+        }
+    return comp;        
+    }
+
+
+
+void CNcdNodeIdentifier::SetNodeIdL( const TDesC& aNodeId )
+    {    
+    const CCatalogsRefString& id = 
+        CCatalogsStringManager::StringManager().StringL( 
+            NcdProviderDefines::ENcdStringNodeId,
+            aNodeId );
+    
+    CCatalogsStringManager::StringManager().ReleaseString(
+        NcdProviderDefines::ENcdStringNodeId,
+        iNodeId );
+    
+    iNodeId = &id;
+    }
+
+
+
+
+#else // COMPONENT_CATALOGSSERVEREXE ********************************************************
+
+
+
+
+
+
+CNcdNodeIdentifier::CNcdNodeIdentifier(): CBase()
+    {
+    }
+
+CNcdNodeIdentifier::~CNcdNodeIdentifier()
+    {   
+    delete iNodeNameSpace;
+    iNodeNameSpace = NULL;
+    
+    delete iNodeId;
+    iNodeId = NULL;
+
+    delete iServerUri;
+    iServerUri = NULL;
+    }
+
+
+void CNcdNodeIdentifier::ConstructL( const TDesC& aNodeNameSpace,
+                                     const TDesC& aNodeId,
+                                     const TDesC& aServerUri,
+                                     const TUid& aClientUid )
+    {
+    iNodeNameSpace = aNodeNameSpace.AllocL();
+    iNodeId = aNodeId.AllocL();
+    iServerUri = aServerUri.AllocL();
+    iClientUid = aClientUid;    
+    }
+
+void CNcdNodeIdentifier::ConstructL( const TDesC8& aNodeIdentifierData )
+    {
+    RDesReadStream readStream( aNodeIdentifierData );
+    CleanupClosePushL( readStream );
+    InternalizeL( readStream );
+    CleanupStack::PopAndDestroy( &readStream );
+    }
+
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL()
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC();
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC()
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( KNullDesC(), KNullDesC(), KNullDesC(), TUid::Null() );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC& aNodeNameSpace,
+                                              const TDesC& aNodeId,
+                                              const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC(
+            aNodeNameSpace,
+            aNodeId,
+            aClientUid );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC& aNodeNameSpace,
+                                               const TDesC& aNodeId,
+                                               const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeNameSpace, aNodeId, KNullDesC(), aClientUid );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC& aNodeNameSpace,
+                                              const TDesC& aNodeId,
+                                              const TDesC& aServerUri,
+                                              const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC(
+            aNodeNameSpace,
+            aNodeId,
+            aServerUri,
+            aClientUid );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC& aNodeNameSpace,
+                                               const TDesC& aNodeId,
+                                               const TDesC& aServerUri,
+                                               const TUid& aClientUid )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeNameSpace, aNodeId, aServerUri, aClientUid );
+    return self;
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL(
+    const CNcdNodeIdentifier& aNodeIdentifier )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC( aNodeIdentifier );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC(
+    const CNcdNodeIdentifier& aNodeIdentifier )
+    {
+    CNcdNodeIdentifier* self = 
+        new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL(
+        aNodeIdentifier.NodeNameSpace(),
+        aNodeIdentifier.NodeId(),
+        aNodeIdentifier.ServerUri(),
+        aNodeIdentifier.ClientUid() );
+    return self;
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( const TDesC8& aNodeIdentifierData )
+    {
+    CNcdNodeIdentifier* self = 
+        CNcdNodeIdentifier::NewLC( aNodeIdentifierData );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( const TDesC8& aNodeIdentifierData )
+    {
+    CNcdNodeIdentifier* self = new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->ConstructL( aNodeIdentifierData );
+    return self;        
+    }
+
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewL( RReadStream& aReadStream )
+    {
+    CNcdNodeIdentifier* self = NewLC( aReadStream );
+    CleanupStack::Pop( self );
+    return self;        
+    }
+
+CNcdNodeIdentifier* CNcdNodeIdentifier::NewLC( RReadStream& aReadStream )
+    {
+    CNcdNodeIdentifier* self = new( ELeave ) CNcdNodeIdentifier();
+    CleanupStack::PushL( self );
+    self->InternalizeL( aReadStream );
+    return self;        
+    }
+
+
+void CNcdNodeIdentifier::InternalizeL( RReadStream& aReadStream )
+    {    
+    InternalizeDesL( iNodeNameSpace, aReadStream );
+    InternalizeDesL( iNodeId, aReadStream );
+    InternalizeDesL( iServerUri, aReadStream );
+    iClientUid.iUid = aReadStream.ReadInt32L();    
+    }
+
+void CNcdNodeIdentifier::ExternalizeL( RWriteStream& aWriteStream ) const
+    {
+    ExternalizeDesL( *iNodeNameSpace, aWriteStream );
+    ExternalizeDesL( *iNodeId, aWriteStream );
+    ExternalizeDesL( *iServerUri, aWriteStream );
+    aWriteStream.WriteInt32L( iClientUid.iUid );    
+    }
+ 
+        
+const TDesC& CNcdNodeIdentifier::NodeNameSpace() const
+    {
+    return *iNodeNameSpace;
+    }    
+
+const TDesC& CNcdNodeIdentifier::NodeId() const
+    {
+    return *iNodeId;
+    }
+
+const TDesC& CNcdNodeIdentifier::ServerUri() const
+    {
+    return *iServerUri;
+    }
+
+const TUid& CNcdNodeIdentifier::ClientUid() const
+    {
+    return iClientUid;
+    }
+
+
+HBufC8* CNcdNodeIdentifier::NodeIdentifierDataL() const
+    {
+    CBufBase* buf = CBufFlat::NewL( KBufExpandSize );
+    CleanupStack::PushL( buf );
+    RBufWriteStream stream( *buf );
+    CleanupClosePushL( stream );
+
+    // Get the data of this identifier into the stream which
+    // directs the data into the buffer.
+    ExternalizeL( stream );
+
+    // Now data has been externalized into the buffer.
+    // Create copy of the data and return it.
+    HBufC8* data = buf->Ptr( 0 ).AllocL();
+    CleanupStack::PopAndDestroy( &stream );
+    CleanupStack::PopAndDestroy( buf );
+    return data;
+    }
+
+TBool CNcdNodeIdentifier::ContainsEmptyFields(
+    TBool aCheckNameSpace,
+    TBool aCheckId,
+    TBool aCheckUri,
+    TBool aCheckUid ) const
+    {
+    return ( aCheckNameSpace && NodeNameSpace() == KNullDesC() )
+        || ( aCheckId && NodeId() == KNullDesC() )
+        || ( aCheckUri && ServerUri() == KNullDesC() )
+        || ( ClientUid() == TUid::Null() && aCheckUid );
+    }
+
+
+TBool CNcdNodeIdentifier::Equals( 
+    const CNcdNodeIdentifier& aObject,
+    TBool aCompareNameSpace,
+    TBool aCompareId,
+    TBool aCompareUri,
+    TBool aCompareUid ) const
+    {
+    return ( NodeNameSpace() == aObject.NodeNameSpace() 
+                || !aCompareNameSpace ) 
+           && ( NodeId() == aObject.NodeId() 
+                || !aCompareId )
+           // By default aCompareUri is EFalse so this order is a little
+           // bit faster in default cases
+           && ( !aCompareUri || 
+                ServerUri() == aObject.ServerUri() )
+           && ( ClientUid() == aObject.ClientUid() 
+                || !aCompareUid );
+    }
+
+TBool CNcdNodeIdentifier::Equals( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2,
+    TBool aCompareNameSpace,
+    TBool aCompareId,
+    TBool aCompareUri,
+    TBool aCompareUid )
+    {
+    return ( aObject1.NodeNameSpace() == aObject2.NodeNameSpace()
+                || !aCompareNameSpace )
+           && ( aObject1.NodeId() == aObject2.NodeId()
+                || !aCompareId )
+           // By default aCompareUri is EFalse so this order is a little
+           // bit faster in default cases
+           && ( !aCompareUri ||
+                aObject1.ServerUri() == aObject2.ServerUri() )
+           && ( aObject1.ClientUid() == aObject2.ClientUid()
+                || !aCompareUid );
+    }
+
+
+TInt CNcdNodeIdentifier::Compare( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2 )
+    {
+    TInt comp = aObject1.NodeId().Compare( aObject2.NodeId() );    
+    
+    if ( !comp ) 
+        {
+        comp = aObject1.NodeNameSpace().Compare( aObject2.NodeNameSpace() );
+        if ( !comp ) 
+            {
+            comp = aObject1.ClientUid().iUid - aObject2.ClientUid().iUid;
+            }
+        }
+    return comp;        
+    }
+
+
+TInt CNcdNodeIdentifier::CompareOrderByUid( 
+    const CNcdNodeIdentifier& aObject1,
+    const CNcdNodeIdentifier& aObject2 )
+    {
+    TInt comp = aObject1.ClientUid().iUid - aObject2.ClientUid().iUid;
+        
+    if ( !comp ) 
+        {
+        comp = aObject1.NodeNameSpace().Compare( aObject2.NodeNameSpace() );
+        if ( !comp ) 
+            {
+            comp = aObject1.NodeId().Compare( aObject2.NodeId() );            
+            }
+        }
+    return comp;        
+    }
+
+#endif
+