diff -r 000000000000 -r ba25891c3a9e ncdengine/provider/server/src/ncdnodefactory.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/ncdengine/provider/server/src/ncdnodefactory.cpp Thu Dec 17 08:51:10 2009 +0200 @@ -0,0 +1,1350 @@ +/* +* Copyright (c) 2006 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 CNcdNodeFactory class +* +*/ + + +#include "ncdnodefactory.h" +#include "ncdnodeidentifier.h" +#include "ncdnodeidentifiereditor.h" +#include "ncdnodemanager.h" +#include "ncdnodedbmanager.h" +#include "ncdnodeimpl.h" +#include "ncdnodeitem.h" +#include "ncdnodefolder.h" +#include "ncdrootnode.h" +#include "ncdsearchrootnode.h" +#include "ncdsearchnodeitem.h" +#include "ncdsearchnodefolder.h" +#include "ncdnodetransparentfolder.h" +#include "ncdbundlefolder.h" +#include "ncdnodesupplier.h" +#include "ncdnodemetadataimpl.h" +#include "ncdnodeitemmetadata.h" +#include "ncdnodefoldermetadata.h" +#include "catalogsdebug.h" +#include "ncdsearchnodebundle.h" + + +CNcdNodeFactory* CNcdNodeFactory::NewL( CNcdNodeManager& aNodeManager ) + { + CNcdNodeFactory* self = + CNcdNodeFactory::NewLC( aNodeManager ); + CleanupStack::Pop( self ); + return self; + } + +CNcdNodeFactory* CNcdNodeFactory::NewLC( CNcdNodeManager& aNodeManager ) + { + CNcdNodeFactory* self = + new( ELeave ) CNcdNodeFactory( aNodeManager ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + + + +CNcdNodeFactory::CNcdNodeFactory( CNcdNodeManager& aNodeManager ) +: CBase(), + iNodeManager( aNodeManager ) + { + } + + +void CNcdNodeFactory::ConstructL() + { + // These values have to be set. + } + + +CNcdNodeFactory::~CNcdNodeFactory() + { + DLTRACEIN(("")); + + // Delete member variables that are owned by this class object here. + + DLTRACEOUT(("")); + } + + + +// --------------------------------------------------------------------------- +// Functions to check the node types and node purposes +// --------------------------------------------------------------------------- + +CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( const TDesC8& aNodeData ) + { + DLTRACEIN(("")); + + // Check the class ids and return the correct value according to that. + + // Reads the class id from the stream + if ( aNodeData.Length() == 0 ) + { + DLINFO(("Node data was empty.")); + DASSERT( EFalse ); + User::Leave( KErrArgument ); + } + + DLINFO(("Create stream from db data length: %d", aNodeData.Length())); + RDesReadStream stream( aNodeData ); + CleanupClosePushL( stream ); + + // Read the class id from the stream + NcdNodeClassIds::TNcdNodeClassId classId = + static_cast( stream.ReadInt32L() ); + + CleanupStack::PopAndDestroy( &stream ); + + TNcdNodeType type( NodeTypeL( classId ) ); + + DLTRACEOUT(("")); + + return type; + } + + +CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( const CNcdNode& aNode ) + { + DLTRACEIN(("")); + + TNcdNodeType type( NodeTypeL( aNode.ClassId() ) ); + + DLTRACEOUT(("")); + + return type; + } + + +CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::NodeTypeL( NcdNodeClassIds::TNcdNodeClassId aClassId ) + { + // Check the class ids and return the correct value according to that. + // Use switch case instead of if-else. + + TNcdNodeType type( ENcdNodeItem ); + + switch( aClassId ) + { + case NcdNodeClassIds::ENcdItemNodeClassId: + DLTRACE(("Item node")); + type = ENcdNodeItem; + break; + + case NcdNodeClassIds::ENcdSearchItemNodeClassId: + DLTRACE(("Search item")); + type = ENcdNodeItem; + break; + + case NcdNodeClassIds::ENcdFolderNodeClassId: + DLTRACE(("Folder node")); + type = ENcdNodeFolder; + break; + + case NcdNodeClassIds::ENcdTransparentFolderNodeClassId: + DLTRACE(("Transparent folder")); + type = ENcdNodeFolder; + break; + + case NcdNodeClassIds::ENcdSearchFolderNodeClassId: + DLTRACE(("Search folder")); + type = ENcdNodeFolder; + break; + + case NcdNodeClassIds::ENcdBundleFolderNodeClassId: + DLTRACE(("Bundle folder")); + type = ENcdNodeFolder; + break; + + case NcdNodeClassIds::ENcdRootNodeClassId: + DLTRACE(("Root node")); + type = ENcdNodeRoot; + break; + + case NcdNodeClassIds::ENcdSearchRootNodeClassId: + DLTRACE(("Search root node")); + type = ENcdNodeRoot; + break; + + case NcdNodeClassIds::ENcdSupplierNodeClassId: + DLTRACE(("Supplier node")); + type = ENcdNodeSupplier; + break; + + case NcdNodeClassIds::ENcdSearchBundleNodeClassId: + DLTRACE(("Search bundle folder")); + type = ENcdNodeSearchBundle; + break; + + default: + DLERROR(("Unknown class id")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + + return type; + } + + +CNcdNodeFactory::TNcdNodePurpose CNcdNodeFactory::NodePurposeL( const CNcdNode& aNode ) + { + DLTRACEIN(("")); + + TNcdNodePurpose purpose( NodePurposeL( aNode.ClassId() ) ); + + DLTRACEOUT(("")); + + return purpose; + } + + +CNcdNodeFactory::TNcdNodePurpose CNcdNodeFactory::NodePurposeL( NcdNodeClassIds::TNcdNodeClassId aClassId ) + { + // Check the class ids and return the correct value according to that. + // Use switch case instead of if-else. + + TNcdNodePurpose purpose( ENcdNormalNode ); + + switch( aClassId ) + { + case NcdNodeClassIds::ENcdItemNodeClassId: + DLTRACE(("Item node")); + purpose = ENcdNormalNode; + break; + + case NcdNodeClassIds::ENcdSearchItemNodeClassId: + DLTRACE(("Search item")); + purpose = ENcdSearchNode; + break; + + case NcdNodeClassIds::ENcdFolderNodeClassId: + DLTRACE(("Folder node")); + purpose = ENcdNormalNode; + break; + + case NcdNodeClassIds::ENcdTransparentFolderNodeClassId: + DLTRACE(("Transparent folder")); + purpose = ENcdTransparentNode; + break; + + case NcdNodeClassIds::ENcdSearchFolderNodeClassId: + DLTRACE(("Search folder")); + purpose = ENcdSearchNode; + break; + + case NcdNodeClassIds::ENcdBundleFolderNodeClassId: + DLTRACE(("Bundle folder")); + purpose = ENcdBundleNode; + break; + + case NcdNodeClassIds::ENcdRootNodeClassId: + DLTRACE(("Root node")); + purpose = ENcdNormalNode; + break; + + case NcdNodeClassIds::ENcdSearchRootNodeClassId: + DLTRACE(("Search root node")); + purpose = ENcdSearchNode; + break; + + case NcdNodeClassIds::ENcdSupplierNodeClassId: + DLTRACE(("Supplier node")); + purpose = ENcdNormalNode; + break; + + case NcdNodeClassIds::ENcdSearchBundleNodeClassId: + DLTRACE(("Search bundle folder")); + purpose = ENcdSearchNode; + break; + + default: + DLERROR(("Unknown class id")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + + return purpose; + } + + + +// --------------------------------------------------------------------------- +// Functions to find out the node class id +// --------------------------------------------------------------------------- + +NcdNodeClassIds::TNcdNodeClassId CNcdNodeFactory::NodeClassIdL( CNcdNodeFactory::TNcdNodeType aNodeType, + CNcdNodeFactory::TNcdNodePurpose aNodePurpose ) + { + + NcdNodeClassIds::TNcdNodeClassId classId( NcdNodeClassIds::ENcdNullObjectClassId ); + + // Check if the node is item, folder or root + switch( aNodeType ) + { + case ENcdNodeItem: + { + // The node is item. + // Check what kind of item. + switch( aNodePurpose ) + { + case ENcdNormalNode: + DLTRACE(("Normal item node class id")); + classId = NcdNodeClassIds::ENcdItemNodeClassId; + break; + + case ENcdChildOfTransparentNode: + DLTRACE(("Transparent child item class id")); + classId = NcdNodeClassIds::ENcdItemNodeClassId; + break; + + case ENcdSearchNode: + DLTRACE(("Search item class id")); + classId = NcdNodeClassIds::ENcdSearchItemNodeClassId; + break; + + default: + DLERROR(("Unknown node item purpose")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + } + break; + + case ENcdNodeFolder: + { + // The node is folder. + // Check what kind of folder. + switch( aNodePurpose ) + { + case ENcdNormalNode: + DLTRACE(("Normal folder class id")); + classId = NcdNodeClassIds::ENcdFolderNodeClassId; + break; + + case ENcdChildOfTransparentNode: + DLTRACE(("Transparent child folder class id")); + classId = NcdNodeClassIds::ENcdFolderNodeClassId; + break; + + case ENcdSearchNode: + DLTRACE(("Search folder class id")); + classId = NcdNodeClassIds::ENcdSearchFolderNodeClassId; + break; + + case ENcdBundleNode: + DLTRACE(("Bundle folder class id")); + classId = NcdNodeClassIds::ENcdBundleFolderNodeClassId; + break; + + case ENcdTransparentNode: + DLTRACE(("Transparent folder class id")); + classId = NcdNodeClassIds::ENcdTransparentFolderNodeClassId; + break; + + default: + DLERROR(("Unknown node folder purpose")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + } + break; + + case ENcdNodeRoot: + { + switch( aNodePurpose ) + { + case ENcdNormalNode: + DLTRACE(("Root class id")); + classId = NcdNodeClassIds::ENcdRootNodeClassId; + break; + + case ENcdSearchNode: + DLTRACE(("Search root as normal folder class id")); + // Notice that the search root is actually normal search folder. + // Should this be changed when the id functions properly? + classId = NcdNodeClassIds::ENcdSearchRootNodeClassId; + break; + + default: + DLERROR(("Unknown node root purpose")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + } + break; + + case ENcdNodeSupplier: + { + // The supplier class id will always be the same. + classId = NcdNodeClassIds::ENcdSupplierNodeClassId; + } + break; + + case ENcdNodeSearchBundle: + { + // The search bundle class id will always be the same. + classId = NcdNodeClassIds::ENcdSearchBundleNodeClassId; + } + break; + + default: + DLERROR(("Unknown node type")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + }; + + return classId; + } + + + +// --------------------------------------------------------------------------- +// Functions to create node objects +// --------------------------------------------------------------------------- + +CNcdNodeItem* CNcdNodeFactory::CreateNodeItemL( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + CNcdNodeItem* item( CreateNodeItemLC( aParentIdentifier, + aMetaDataIdentifier, + aClassId ) ); + if ( item != NULL ) + { + CleanupStack::Pop( item ); + } + + DLTRACEOUT(("")); + + return item; + } + + +CNcdNodeItem* CNcdNodeFactory::CreateNodeItemLC( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + + CNcdNodeIdentifier* identifier = + NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentIdentifier, aMetaDataIdentifier ); + + + // First check if the node can be created as an item. + CNcdNodeItem* item( CreateNodeItemLC( *identifier, + aClassId ) ); + + CleanupStack::PopAndDestroy( identifier ); + + DLTRACEOUT(("")); + + return item; + } + + +CNcdNodeItem* CNcdNodeFactory::CreateNodeItemL( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + CNcdNodeItem* item( CreateNodeItemLC( aNodeIdentifier, + aClassId) ); + + if ( item != NULL ) + { + CleanupStack::Pop( item ); + } + + DLTRACEOUT(("")); + + return item; + } + + +CNcdNodeItem* CNcdNodeFactory::CreateNodeItemLC( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNodeItem* item( NULL ); + + // Create object according to the class type + switch( aClassId ) + { + case NcdNodeClassIds::ENcdItemNodeClassId: + DLINFO(("Item node")); + item = CNcdNodeItem::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdSearchItemNodeClassId: + DLINFO(("Search item node")); + item = CNcdSearchNodeItem::NewLC( NodeManager(), aNodeIdentifier ); + break; + + default: + DLERROR(("Unknown node item class id. Return NULL")); + // Do not insert assert here because CreateNodeL(C) function uses this + // function among other create functions to create nodes. + item = NULL; + break; + } + + DLTRACEOUT(("")); + + return item; + } + + + +CNcdNodeFolder* CNcdNodeFactory::CreateNodeFolderL( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + CNcdNodeFolder* folder( CreateNodeFolderLC( aParentIdentifier, + aMetaDataIdentifier, + aClassId) ); + if ( folder != NULL ) + { + CleanupStack::Pop( folder ); + } + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeFolder* CNcdNodeFactory::CreateNodeFolderLC( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + + CNcdNodeIdentifier* identifier = + NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentIdentifier, aMetaDataIdentifier ); + + + // First check if the node can be created as an item. + CNcdNodeFolder* folder( CreateNodeFolderLC( *identifier, + aClassId ) ); + + CleanupStack::PopAndDestroy( identifier ); + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeFolder* CNcdNodeFactory::CreateNodeFolderL( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNodeFolder* folder( CreateNodeFolderLC( aNodeIdentifier, aClassId ) ); + + if ( folder != NULL ) + { + CleanupStack::Pop( folder ); + } + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeFolder* CNcdNodeFactory::CreateNodeFolderLC( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNodeFolder* folder( NULL ); + + // Create object according to the class type + switch( aClassId ) + { + case NcdNodeClassIds::ENcdFolderNodeClassId: + DLINFO(("Folder node")); + folder = CNcdNodeFolder::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdTransparentFolderNodeClassId: + DLINFO(("Transparent folder node")); + folder = CNcdNodeTransparentFolder::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdSearchFolderNodeClassId: + DLINFO(("Search folder node")); + folder = CNcdSearchNodeFolder::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdRootNodeClassId: + DLINFO(("Root node")); + folder = CNcdRootNode::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdBundleFolderNodeClassId: + DLINFO(("Bundle folder")); + folder = CNcdBundleFolder::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdSearchRootNodeClassId: + DLINFO(("Search root node from db")); + folder = CNcdSearchRootNode::NewLC( NodeManager(), aNodeIdentifier ); + break; + + case NcdNodeClassIds::ENcdSearchBundleNodeClassId: + DLINFO(("Search bundle folder")); + folder = CNcdSearchNodeBundle::NewLC( NodeManager(), aNodeIdentifier ); + break; + + default: + DLERROR(("Unknown folder node class id. Return NULL")); + // Do not insert assert here because CreateNodeL(C) function uses this + // function among other create function to create nodes. + folder = NULL; + break; + } + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeSupplier* CNcdNodeFactory::CreateNodeSupplierL( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNodeSupplier* node( CreateNodeSupplierLC( aNodeIdentifier, aClassId ) ); + + if ( node != NULL ) + { + CleanupStack::Pop( node ); + } + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNodeSupplier* CNcdNodeFactory::CreateNodeSupplierLC( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNodeSupplier* node( NULL ); + + // Create object according to the class type + switch( aClassId ) + { + case NcdNodeClassIds::ENcdSupplierNodeClassId: + DLINFO(("Supplier node")); + node = CNcdNodeSupplier::NewLC( NodeManager(), aNodeIdentifier ); + break; + + default: + DLERROR(("Unknown supplier node class id. Return NULL")); + // Do not insert assert here because CreateNodeL(C) function uses this + // function among other create function to create nodes. + node = NULL; + break; + } + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeL( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNode* node( CreateNodeLC( aParentIdentifier, aMetaDataIdentifier, aClassId ) ); + + if ( node != NULL ) + { + CleanupStack::Pop( node ); + } + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeLC( const CNcdNodeIdentifier& aParentIdentifier, + const CNcdNodeIdentifier& aMetaDataIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + + CNcdNodeIdentifier* identifier = + NcdNodeIdentifierEditor::CreateNodeIdentifierLC( aParentIdentifier, aMetaDataIdentifier ); + + + // First check if the node can be created as an item. + CNcdNode* node( CreateNodeL( *identifier, aClassId ) ); + + CleanupStack::PopAndDestroy( identifier ); + + CleanupStack::PushL( node ); + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeL( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + CNcdNode* node( CreateNodeLC( aNodeIdentifier, aClassId ) ); + + if ( node != NULL ) + { + CleanupStack::Pop( node ); + } + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeLC( const CNcdNodeIdentifier& aNodeIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the node, + // but does not internalize its data from anywhere. + + // First check if the node can be created as an item. + CNcdNode* node( CreateNodeItemLC( aNodeIdentifier, + aClassId ) ); + + + if ( node == NULL ) + { + // Node was not an item. So, create a folder. + node = CreateNodeFolderLC( aNodeIdentifier, + aClassId ); + } + + if ( node == NULL ) + { + // Node was none of above. So, try to create node supplier. + node = CreateNodeSupplierLC( aNodeIdentifier, aClassId ); + } + + DLINFO(("Node should have been created")); + if ( node == NULL ) + { + DLERROR(("Null node")) + DASSERT( EFalse ); + User::Leave( KErrNotFound ); + } + + DLTRACEOUT(("")); + + return node; + } + + + +CNcdNode* CNcdNodeFactory::CreateNodeL( const CNcdNodeIdentifier& aNodeIdentifier, + RReadStream& aStream ) const + { + DLTRACEIN(("")); + + // Creates the node + // and internalizes its data from given stream. + CNcdNode* node( CreateNodeLC( aNodeIdentifier, aStream ) ); + + if ( node != NULL ) + { + CleanupStack::Pop( node ); + } + + DLTRACEOUT(("")); + + return node; + } + +CNcdNode* CNcdNodeFactory::CreateNodeLC( const CNcdNodeIdentifier& aNodeIdentifier, + RReadStream& aStream ) const + { + DLTRACEIN(("")); + + // Creates the node + // and internalizes its data from given stream. + CNcdNode* node( NULL ); + + // The first four bits (TInt32) should describe the class type of the data. + // This data type is used to create the right class and the stream data + // after that will be used to initialize the class object. + NcdNodeClassIds::TNcdNodeClassId classId = + static_cast( aStream.ReadInt32L() ); + + DLINFO(("classId: %d", classId )); + + // Creates the corresponding node + node = CreateNodeLC( aNodeIdentifier, classId ); + + // Internalizes the node from the stream + node->InternalizeL( aStream ); + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeL( const CNcdNodeIdentifier& aNodeIdentifier, + const TDesC8& aData ) const + { + DLTRACEIN(("")); + + CNcdNode* node( NULL ); + + // Reads the class id from the stream + if ( aData.Length() == 0 ) + { + DLINFO(("Node data was empty.")); + DASSERT( EFalse ); + User::Leave( KErrArgument ); + } + + DLINFO(("Create stream from data length: %d", aData.Length())); + RDesReadStream stream( aData ); + CleanupClosePushL( stream ); + + node = CreateNodeL( aNodeIdentifier, stream ); + + CleanupStack::PopAndDestroy( &stream ); + + DLTRACEOUT(("")); + + return node; + } + + +CNcdNode* CNcdNodeFactory::CreateNodeLC( const CNcdNodeIdentifier& aNodeIdentifier, + const TDesC8& aData ) const + { + DLTRACEIN(("")); + + // Creates the node + // and internalizes its data from given data. + CNcdNode* node( CreateNodeL( aNodeIdentifier, aData ) ); + + if ( node != NULL ) + { + CleanupStack::PushL( node ); + } + + DLTRACEOUT(("")); + + return node; + } + + +void CNcdNodeFactory::InternalizeNodeL( CNcdNode& aNode, const TDesC8& aData ) + { + DLTRACEIN(("")); + + // Reads the class id from the stream + if ( aData.Length() == 0 ) + { + DLINFO(("Node data was empty.")); + DASSERT( EFalse ); + User::Leave( KErrArgument ); + } + + DLINFO(("Create stream from data length: %d", aData.Length())); + RDesReadStream stream( aData ); + CleanupClosePushL( stream ); + + // The first four bits (TInt32) should describe the class type of the data. + // This data type is used to create the right class and the stream data + // after that will be used to initialize the class object. + NcdNodeClassIds::TNcdNodeClassId classId = + static_cast( stream.ReadInt32L() ); + if ( aNode.ClassId() != classId ) + { + User::Leave( KErrArgument ); + DASSERT( EFalse ); + } + + aNode.InternalizeL( stream ); + CleanupStack::PopAndDestroy( &stream ); + } + + +// --------------------------------------------------------------------------- +// Functions to get metadata type info +// --------------------------------------------------------------------------- + + +CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::MetaDataTypeL( const CNcdNodeMetaData& aNode ) + { + DLTRACEIN(("")); + + TNcdNodeType type( MetaDataTypeL( aNode.ClassId() ) ); + + DLTRACEOUT(("")); + + return type; + } + + +CNcdNodeFactory::TNcdNodeType CNcdNodeFactory::MetaDataTypeL( NcdNodeClassIds::TNcdNodeClassId aClassId ) + { + DLTRACEIN(("")); + + // Check the class ids and return the correct value according to that. + // Use switch case instead of if-else. + + TNcdNodeType type( ENcdNodeItem ); + + switch( aClassId ) + { + case NcdNodeClassIds::ENcdItemNodeMetaDataClassId: + DLINFO(("Item metadata")); + type = ENcdNodeItem; + break; + + case NcdNodeClassIds::ENcdFolderNodeMetaDataClassId: + DLINFO(("Folder metadata")); + type = ENcdNodeFolder; + break; + + case NcdNodeClassIds::ENcdSupplierNodeMetaDataClassId: + DLINFO(("Folder metadata")); + type = ENcdNodeSupplier; + break; + + default: + DLERROR(("Unknown class id")); + // For debuggin purpose + DASSERT( EFalse ); + User::Leave( KErrUnknown ); + break; + } + + DLTRACEOUT(("")); + + return type; + } + + + +// --------------------------------------------------------------------------- +// Functions to find out the metadata class id +// --------------------------------------------------------------------------- + +NcdNodeClassIds::TNcdNodeClassId CNcdNodeFactory::MetaDataClassId( CNcdNodeFactory::TNcdNodeType aNodeType ) + { + DLTRACEIN(("")); + + NcdNodeClassIds::TNcdNodeClassId classId( NcdNodeClassIds::ENcdNullObjectClassId ); + + // Check if the node is item, folder or root + switch( aNodeType ) + { + case ENcdNodeItem: + DLINFO(("Item metadata")); + classId = NcdNodeClassIds::ENcdItemNodeMetaDataClassId; + break; + + case ENcdNodeFolder: + DLINFO(("Folder metadata")); + classId = NcdNodeClassIds::ENcdFolderNodeMetaDataClassId; + break; + + case ENcdNodeSupplier: + DLINFO(("Supplier metadata")); + classId = NcdNodeClassIds::ENcdSupplierNodeMetaDataClassId; + break; + + default: + DLERROR(("Unknown node type")); + // For debuggin purpose + DASSERT( EFalse ); + _LIT( KCategory, "Unknown node type" ); + User::Panic( KCategory, KErrUnknown ); + break; + }; + + DLTRACEOUT(("")); + + return classId; + } + + + +// --------------------------------------------------------------------------- +// Functions to create metadata objects +// --------------------------------------------------------------------------- + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataL( const CNcdNodeIdentifier& aIdentifier, + TNcdNodeType aMetaType ) const + { + DLTRACEIN(("")); + + CNcdNodeMetaData* metaData( CreateMetaDataLC( aIdentifier, aMetaType ) ); + + if ( metaData != NULL ) + { + CleanupStack::Pop( metaData ); + } + + DLTRACEOUT(("")); + + return metaData; + } + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + TNcdNodeType aMetaType ) const + { + DLTRACEIN(("")); + + CNcdNodeMetaData* metaData( NULL ); + + switch( aMetaType ) + { + case ENcdNodeItem: + metaData = + CreateMetaDataLC( aIdentifier, + NcdNodeClassIds::ENcdItemNodeMetaDataClassId ); + break; + + case ENcdNodeFolder: + metaData = + CreateMetaDataLC( aIdentifier, + NcdNodeClassIds::ENcdFolderNodeMetaDataClassId ); + break; + + default: + DLERROR(("Unknown metadata class id.")); + DASSERT( EFalse ); + User::Leave( KErrArgument ); + break; + } + + DASSERT( metaData ); + + DLTRACEOUT(("")); + return metaData; + } + + +CNcdNodeItemMetaData* CNcdNodeFactory::CreateItemMetaDataL( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + CNcdNodeItemMetaData* item( CreateItemMetaDataLC( aIdentifier, aClassId ) ); + + if ( item != NULL ) + { + CleanupStack::Pop( item ); + } + + DLTRACEOUT(("")); + + return item; + } + + +CNcdNodeItemMetaData* CNcdNodeFactory::CreateItemMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the metadata, + // but does not internalize its data from anywhere. + CNcdNodeItemMetaData* item( NULL ); + + // Create object according to the class type + switch( aClassId ) + { + case NcdNodeClassIds::ENcdItemNodeMetaDataClassId: + DLINFO(("Item meta")); + item = CNcdNodeItemMetaData::NewLC( aIdentifier, NodeManager() ); + break; + + default: + DLERROR(("Unknown metadata item class id. Return NULL")); + // Do not insert assert here because CreateMetaDataL(C) function uses this + // function and CreateMetadataFolderL(C) function to create nodes. + item = NULL; + break; + } + + DLTRACEOUT(("")); + + return item; + } + + +CNcdNodeFolderMetaData* CNcdNodeFactory::CreateFolderMetaDataL( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the metadata, + // but does not internalize its data from anywhere. + CNcdNodeFolderMetaData* folder( CreateFolderMetaDataLC( aIdentifier, aClassId ) ); + + if ( folder != NULL ) + { + CleanupStack::Pop( folder ); + } + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeFolderMetaData* CNcdNodeFactory::CreateFolderMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the metadata, + // but does not internalize its data from anywhere. + CNcdNodeFolderMetaData* folder( NULL ); + + // Create object according to the class type + switch( aClassId ) + { + case NcdNodeClassIds::ENcdFolderNodeMetaDataClassId: + DLINFO(("Folder meta")); + folder = CNcdNodeFolderMetaData::NewLC( aIdentifier, NodeManager() ); + break; + + default: + DLERROR(("Unknown folder metadata class id. Return NULL")); + // Do not insert assert here because CreateMetaDataL(C) function uses this + // function and CreateFolderMetaDataL(C) function to create nodes. + folder = NULL; + break; + } + + DLTRACEOUT(("")); + + return folder; + } + + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataL( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the metadata, + // but does not internalize its data from anywhere. + CNcdNodeMetaData* metadata( CreateMetaDataLC( aIdentifier, aClassId ) ); + + if ( metadata != NULL ) + { + CleanupStack::Pop( metadata ); + } + + DLTRACEOUT(("")); + + return metadata; + } + + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + NcdNodeClassIds::TNcdNodeClassId aClassId ) const + { + DLTRACEIN(("")); + + // Creates the metadata, + // but does not internalize its data from anywhere. + + // First check if the metadata can be created as an item. + CNcdNodeMetaData* metadata( CreateItemMetaDataLC( aIdentifier, + aClassId ) ); + + + if ( metadata == NULL ) + { + // Node was not an item. So, create a folder. + metadata = CreateFolderMetaDataLC( aIdentifier, + aClassId ); + } + + DLTRACEOUT(("")); + + return metadata; + } + + + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataL( const CNcdNodeIdentifier& aIdentifier, + RReadStream& aStream ) const + { + DLTRACEIN(("")); + + // Creates the metadata + // and internalizes its data from given stream. + CNcdNodeMetaData* metadata( CreateMetaDataLC( aIdentifier, aStream ) ); + + if ( metadata != NULL ) + { + CleanupStack::Pop( metadata ); + } + + DLTRACEOUT(("")); + + return metadata; + } + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + RReadStream& aStream ) const + { + DLTRACEIN(("")); + + // Creates the metadata + // and internalizes its data from given stream. + CNcdNodeMetaData* metadata( NULL ); + + // The first four bits (TInt32) should describe the class type of the data. + // This data type is used to create the right class and the stream data + // after that will be used to initialize the class object. + NcdNodeClassIds::TNcdNodeClassId classId = + static_cast( aStream.ReadInt32L() ); + + DLINFO(("classId: %d", classId )); + + // Creates the corresponding node + metadata = CreateMetaDataLC( aIdentifier, classId ); + + // Internalizes the metadata from the stream + metadata->InternalizeL( aStream ); + + DLTRACEOUT(("")); + + return metadata; + } + + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataL( const CNcdNodeIdentifier& aIdentifier, + const TDesC8& aData ) const + { + DLTRACEIN(("")); + + CNcdNodeMetaData* metadata( NULL ); + + // Reads the class id from the stream + DASSERT( aData.Length() ); + + DLINFO(("Create stream from data length: %d", aData.Length())); + RDesReadStream stream( aData ); + CleanupClosePushL( stream ); + + metadata = CreateMetaDataL( aIdentifier, stream ); + + CleanupStack::PopAndDestroy( &stream ); + + DLTRACEOUT(("")); + + return metadata; + } + + +CNcdNodeMetaData* CNcdNodeFactory::CreateMetaDataLC( const CNcdNodeIdentifier& aIdentifier, + const TDesC8& aData ) const + { + DLTRACEIN(("")); + + // Creates the metadata + // and internalizes its data from given data. + CNcdNodeMetaData* metadata( CreateMetaDataL( aIdentifier, aData ) ); + + if ( metadata != NULL ) + { + CleanupStack::PushL( metadata ); + } + + DLTRACEOUT(("")); + + return metadata; + } + + + +// --------------------------------------------------------------------------- +// Protected functions +// --------------------------------------------------------------------------- + +CNcdNodeManager& CNcdNodeFactory::NodeManager() const + { + return iNodeManager; + } +