--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/perfsrv/memspy/Engine/Source/Helpers/MemSpyEngineHelperECom.cpp Mon Sep 06 15:00:47 2010 +0300
@@ -0,0 +1,813 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+*
+*/
+
+#include <memspy/engine/memspyenginehelperecom.h>
+
+// System includes
+#include <charconv.h>
+
+// User includes
+#include <memspy/engine/memspyengine.h>
+#include <memspy/engine/memspyengineutils.h>
+#include <memspy/engine/memspyenginehelperfilesystem.h>
+
+// Literal constants
+_LIT8( KMemSpyEComXmlFileMimeType, "text/xml" );
+_LIT8( KMemSpyXmlSpec_MasterSection, "memspy_ecom_sections" );
+_LIT8( KMemSpyXmlSpec_ChildSectionCategory, "category" );
+_LIT8( KMemSpyXmlSpec_ChildSectionCategory_Attribute_Name, "name" );
+_LIT8( KMemSpyXmlSpec_ChildSectionInterface, "interface" );
+_LIT8( KMemSpyXmlSpec_ChildSectionInterface_Name, "name" );
+_LIT8( KMemSpyXmlSpec_ChildSectionInterface_Uid, "uid" );
+_LIT8( KMemSpyXmlSpec_HexPrefix, "0x" );
+
+
+
+
+
+CMemSpyEngineHelperECom::CMemSpyEngineHelperECom( CMemSpyEngine& aEngine )
+: iEngine( aEngine )
+ {
+ }
+
+
+CMemSpyEngineHelperECom::~CMemSpyEngineHelperECom()
+ {
+ iCategories.ResetAndDestroy();
+ iCategories.Close();
+ //
+ delete iParser;
+ delete iConverter;
+ //
+ iEComSession.Close();
+ REComSession::FinalClose();
+ }
+
+
+void CMemSpyEngineHelperECom::ConstructL()
+ {
+ TRAPD( err, ConstructInternalL() );
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructL() - error: %d", err );
+ err = err;
+ }
+
+
+void CMemSpyEngineHelperECom::ConstructInternalL()
+ {
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - START" );
+ iEComSession = REComSession::OpenL();
+
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - creating parser..." );
+ iParser = CParser::NewL( KMemSpyEComXmlFileMimeType, *this );
+
+ // We only convert from UTF-8 to UTF-16
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - creating charconv object..." );
+ iConverter = CCnvCharacterSetConverter::NewL();
+ if ( iConverter->PrepareToConvertToOrFromL( KCharacterSetIdentifierUtf8, iEngine.FsSession() ) == CCnvCharacterSetConverter::ENotAvailable )
+ {
+ User::Leave(KErrNotFound);
+ }
+
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - reading xml..." );
+ ConstructFromFileL();
+
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructInternalL() - END" );
+ }
+
+
+void CMemSpyEngineHelperECom::ConstructFromFileL()
+ {
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - START" );
+
+ // Locate the source file
+ TRAPD( err,
+ HBufC* fileName = FindEComXmlFileNameLC();
+ ParseL( *fileName );
+ CleanupStack::PopAndDestroy( fileName );
+ );
+ err = err;
+
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - parse error: %d", err );
+
+ delete iConverter;
+ iConverter = NULL;
+
+ // Build captions
+ const TInt categoryCount = iCategories.Count();
+ for( TInt i=0; i<categoryCount; i++ )
+ {
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - building caption: %d", i );
+
+ CMemSpyEngineEComCategory* cat = iCategories[ i ];
+ cat->BuildCaptionL();
+ }
+
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ConstructFromFileL() - END" );
+ }
+
+
+CMemSpyEngineHelperECom* CMemSpyEngineHelperECom::NewL( CMemSpyEngine& aEngine )
+ {
+ CMemSpyEngineHelperECom* self = new(ELeave) CMemSpyEngineHelperECom( aEngine );
+ CleanupStack::PushL( self );
+ self->ConstructL();
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+
+REComSession& CMemSpyEngineHelperECom::EComSession()
+ {
+ return iEComSession;
+ }
+
+
+EXPORT_C CMemSpyEngineEComCategory& CMemSpyEngineHelperECom::At( TInt aIndex )
+ {
+ return *iCategories[ aIndex ];
+ }
+
+
+EXPORT_C TInt CMemSpyEngineHelperECom::IndexOf( const CMemSpyEngineEComCategory& aEntry )
+ {
+ const TInt index = iCategories.Find( &aEntry );
+ return index;
+ }
+
+
+EXPORT_C TInt CMemSpyEngineHelperECom::MdcaCount() const
+ {
+ return iCategories.Count();
+ }
+
+
+EXPORT_C TPtrC CMemSpyEngineHelperECom::MdcaPoint( TInt aIndex ) const
+ {
+ CMemSpyEngineEComCategory* category = iCategories[ aIndex ];
+ return category->Caption();
+ }
+
+
+HBufC* CMemSpyEngineHelperECom::FindEComXmlFileNameLC()
+ {
+ RFs& fsSession = iEngine.FsSession();
+ //
+ TFileName* fileName = new(ELeave) TFileName();
+ CleanupStack::PushL( fileName );
+ //
+ fsSession.PrivatePath( *fileName );
+ //
+ TFindFile findFile( fsSession );
+ User::LeaveIfError( findFile.FindByPath( KMemSpyEComInterfaceIdFileName, fileName ) );
+ //
+ HBufC* ret = findFile.File().AllocL();
+ CleanupStack::PopAndDestroy( fileName );
+ CleanupStack::PushL( ret );
+ return ret;
+ }
+
+
+void CMemSpyEngineHelperECom::ConvertL( const TDesC8& aInput, TDes16& aOutput )
+ {
+ const TInt error = iConverter->ConvertToUnicode( aOutput, aInput, iCharconvConverterState );
+ User::LeaveIfError( error );
+ }
+
+
+void CMemSpyEngineHelperECom::ParseL( const TDesC& aFileName )
+ {
+ Xml::ParseL( *iParser, iEngine.FsSession(), aFileName );
+ //
+ const TInt error = iParserErrorCode;
+ //RDebug::Printf( "CMemSpyEngineHelperECom::ParseL() - iParserErrorCode: %d", iParserErrorCode );
+ iParserErrorCode = KErrNone;
+ //
+ User::LeaveIfError( error );
+ }
+
+
+void CMemSpyEngineHelperECom::OnChildSectionCategoryL( const RAttributeArray& aAttributes )
+ {
+ TBuf<128> name;
+ TBool gotName = EFalse;
+ //
+ const TInt count = aAttributes.Count();
+ for( TInt i=0; i<count; i++ )
+ {
+ const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() );
+ const TPtrC8 value( aAttributes[ i ].Value().DesC() );
+ //
+ if ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionCategory_Attribute_Name ) == 0 )
+ {
+ if ( gotName )
+ {
+ User::LeaveIfError( KErrCorrupt );
+ }
+ else
+ {
+ ConvertL( value, name );
+ gotName = ETrue;
+ }
+ }
+ }
+ //
+ if ( gotName )
+ {
+ // Make a new category
+ //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionCategoryL() - creating category: %S"), &name );
+
+ CMemSpyEngineEComCategory* category = CMemSpyEngineEComCategory::NewLC( *this, name );
+ iCategories.AppendL( category );
+ CleanupStack::Pop( category );
+
+ //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionCategoryL() - created category: %S"), &name );
+ }
+ else
+ {
+ User::Leave( KErrCorrupt );
+ }
+ }
+
+
+void CMemSpyEngineHelperECom::OnChildSectionInterfaceL( const RAttributeArray& aAttributes )
+ {
+ TUid uid = KNullUid;
+ TBuf<128> name;
+ TBool gotName = EFalse;
+ TBool gotUid = EFalse;
+ //
+ const TInt count = aAttributes.Count();
+ for( TInt i=0; i<count; i++ )
+ {
+ const TPtrC8 attrib( aAttributes[ i ].Attribute().LocalName().DesC() );
+ const TPtrC8 value( aAttributes[ i ].Value().DesC() );
+ //
+ if ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionInterface_Name ) == 0 )
+ {
+ if ( gotName )
+ {
+ User::LeaveIfError( KErrCorrupt );
+ }
+ else
+ {
+ ConvertL( value, name );
+ gotName = ETrue;
+ }
+ }
+ else if ( attrib.CompareF( KMemSpyXmlSpec_ChildSectionInterface_Uid ) == 0 )
+ {
+ if ( gotUid )
+ {
+ User::LeaveIfError( KErrCorrupt );
+ }
+ else
+ {
+ if ( value.Length() >= 8 )
+ {
+ TRadix radix = EDecimal;
+ TPtrC8 pValue( value );
+ //
+ if ( value.Length() == 10 && value.Left( 2 ) == KMemSpyXmlSpec_HexPrefix )
+ {
+ pValue.Set( value.Mid( 2 ) );
+ radix = EHex;
+ }
+ //
+ TUint32 uidVal = 0;
+ TLex8 lexer( pValue );
+ const TInt err = lexer.Val( uidVal, radix );
+ User::LeaveIfError( err );
+ uid.iUid = uidVal;
+ gotUid = ETrue;
+ }
+ }
+ }
+ }
+ //
+ const TInt catCount = iCategories.Count();
+ if ( gotName && gotUid && catCount > 0 )
+ {
+ //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionInterfaceL() - creating interface for %S [0x%08x]"), &name, uid.iUid );
+
+ CMemSpyEngineEComCategory* category = iCategories[ catCount - 1 ];
+ TRAPD( err, category->CreateInterfaceL( name, uid ) );
+ err = err;
+ //RDebug::Print( _L("CMemSpyEngineHelperECom::OnChildSectionInterfaceL() - error: %d, for %S [0x%08x]"), err, &name, uid.iUid );
+ }
+ else
+ {
+ User::Leave( KErrCorrupt );
+ }
+ }
+
+
+void CMemSpyEngineHelperECom::OnStartDocumentL( const RDocumentParameters& /*aDocParam*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnEndDocumentL( TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnStartElementL( const RTagInfo& aElement, const RAttributeArray& aAttributes, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ //
+ TInt err = KErrNone;
+ const TPtrC8 name( aElement.LocalName().DesC() );
+ //
+ if ( name.CompareF( KMemSpyXmlSpec_MasterSection ) == 0 )
+ {
+ iSeenMasterSection = ETrue;
+ }
+ else if ( iSeenMasterSection )
+ {
+ if ( name.CompareF( KMemSpyXmlSpec_ChildSectionCategory ) == 0 )
+ {
+ OnChildSectionCategoryL( aAttributes );
+ }
+ else if ( name.CompareF( KMemSpyXmlSpec_ChildSectionInterface ) == 0 )
+ {
+ OnChildSectionInterfaceL( aAttributes );
+ }
+ }
+ //
+ User::LeaveIfError( err );
+ }
+
+
+void CMemSpyEngineHelperECom::OnEndElementL( const RTagInfo& /*aElement*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnContentL( const TDesC8& /*aBytes*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnStartPrefixMappingL( const RString& /*aPrefix*/, const RString& /*aUri*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnEndPrefixMappingL( const RString& /*aPrefix*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnIgnorableWhiteSpaceL( const TDesC8& /*aBytes*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnSkippedEntityL( const RString& /*aName*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnProcessingInstructionL( const TDesC8& /*aTarget*/, const TDesC8& /*aData*/, TInt aErrorCode )
+ {
+ User::LeaveIfError( aErrorCode );
+ }
+
+
+void CMemSpyEngineHelperECom::OnError( TInt aErrorCode )
+ {
+ iParserErrorCode = aErrorCode;
+ }
+
+
+TAny* CMemSpyEngineHelperECom::GetExtendedInterface( const TInt32 /*aUid*/ )
+ {
+ return NULL;
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineEComCategory::CMemSpyEngineEComCategory( CMemSpyEngineHelperECom& aHelper )
+: iHelper( aHelper )
+ {
+ }
+
+
+CMemSpyEngineEComCategory::~CMemSpyEngineEComCategory()
+ {
+ delete iCaption;
+ delete iName;
+ iInterfaces.ResetAndDestroy();
+ iInterfaces.Close();
+ }
+
+
+void CMemSpyEngineEComCategory::ConstructL( const TDesC& aName )
+ {
+ iName = aName.AllocL();
+ iCaption = aName.AllocL(); // Replace later on
+ }
+
+
+CMemSpyEngineEComCategory* CMemSpyEngineEComCategory::NewLC( CMemSpyEngineHelperECom& aHelper, const TDesC& aName )
+ {
+ CMemSpyEngineEComCategory* self = new(ELeave) CMemSpyEngineEComCategory( aHelper );
+ CleanupStack::PushL( self );
+ self->ConstructL( aName );
+ return self;
+ }
+
+
+EXPORT_C CMemSpyEngineEComInterface& CMemSpyEngineEComCategory::At( TInt aIndex )
+ {
+ return *iInterfaces[ aIndex ];
+ }
+
+
+EXPORT_C TInt CMemSpyEngineEComCategory::IndexOf( const CMemSpyEngineEComInterface& aEntry )
+ {
+ const TInt index = iInterfaces.Find( &aEntry );
+ return index;
+ }
+
+
+EXPORT_C TInt CMemSpyEngineEComCategory::MdcaCount() const
+ {
+ return iInterfaces.Count();
+ }
+
+
+EXPORT_C TPtrC CMemSpyEngineEComCategory::MdcaPoint( TInt aIndex ) const
+ {
+ CMemSpyEngineEComInterface* iface = iInterfaces[ aIndex ];
+ return iface->Caption();
+ }
+
+
+void CMemSpyEngineEComCategory::CreateInterfaceL( const TDesC& aName, TUid aUid )
+ {
+ CMemSpyEngineEComInterface* iface = CMemSpyEngineEComInterface::NewLC( *this, aName, aUid );
+ iInterfaces.AppendL( iface );
+ CleanupStack::Pop( iface );
+ }
+
+
+void CMemSpyEngineEComCategory::BuildCaptionL()
+ {
+ delete iCaption;
+ iCaption = NULL;
+
+ _LIT( KCaptionFormat, "\t%S\t\t%d interface" );
+ iCaption = HBufC::NewL( 256 );
+ TPtr pCaption( iCaption->Des() );
+ pCaption.Format( KCaptionFormat, iName, iInterfaces.Count() );
+ if ( iInterfaces.Count() > 1 )
+ {
+ pCaption.Append( 's' );
+ }
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineEComInterface::CMemSpyEngineEComInterface( CMemSpyEngineEComCategory& aCategory, TUid aUid )
+: iUid( aUid ), iCategory( aCategory )
+ {
+ }
+
+
+CMemSpyEngineEComInterface::~CMemSpyEngineEComInterface()
+ {
+ delete iCaption;
+ delete iName;
+ iImplementations.ResetAndDestroy();
+ iImplementations.Close();
+ }
+
+
+void CMemSpyEngineEComInterface::ConstructL( const TDesC& aName )
+ {
+ iName = aName.AllocL();
+
+ // Get implementation information for this interface...
+ RImplInfoPtrArray infoArray;
+ CleanupResetAndDestroyPushL( infoArray );
+ REComSession::ListImplementationsL( iUid, infoArray );
+
+ // Make implementation objects for each impl that exists.
+ const TInt count = infoArray.Count();
+ for( TInt i=count-1; i>=0; i-- )
+ {
+ CImplementationInformation* info = infoArray[ i ];
+
+ // Get info
+ CMemSpyEngineEComImplementation* impl = CMemSpyEngineEComImplementation::NewLC( *this, info );
+
+ // Now owned by impl
+ infoArray.Remove( i );
+
+ // Add to container
+ iImplementations.AppendL( impl );
+ CleanupStack::Pop( impl );
+ }
+
+ // Tidy up
+ CleanupStack::PopAndDestroy( &infoArray );
+
+ // Build caption
+ _LIT( KCaptionFormat, "\t%S\t\t[0x%08x] [%d impl]" );
+ iCaption = HBufC::NewL( 256 );
+ TPtr pCaption( iCaption->Des() );
+ pCaption.Format( KCaptionFormat, iName, iUid.iUid, count );
+ }
+
+
+CMemSpyEngineEComInterface* CMemSpyEngineEComInterface::NewLC( CMemSpyEngineEComCategory& aCategory, const TDesC& aName, TUid aUid )
+ {
+ CMemSpyEngineEComInterface* self = new(ELeave) CMemSpyEngineEComInterface( aCategory, aUid );
+ CleanupStack::PushL( self );
+ self->ConstructL( aName );
+ return self;
+ }
+
+
+EXPORT_C CMemSpyEngineEComImplementation& CMemSpyEngineEComInterface::At( TInt aIndex )
+ {
+ return *iImplementations[ aIndex ];
+ }
+
+
+EXPORT_C TInt CMemSpyEngineEComInterface::IndexOf( const CMemSpyEngineEComImplementation& aEntry )
+ {
+ const TInt index = iImplementations.Find( &aEntry );
+ return index;
+ }
+
+
+EXPORT_C TInt CMemSpyEngineEComInterface::MdcaCount() const
+ {
+ return iImplementations.Count();
+ }
+
+
+EXPORT_C TPtrC CMemSpyEngineEComInterface::MdcaPoint( TInt aIndex ) const
+ {
+ CMemSpyEngineEComImplementation* impl = iImplementations[ aIndex ];
+ return impl->Caption();
+ }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+CMemSpyEngineEComImplementation::CMemSpyEngineEComImplementation( CMemSpyEngineEComInterface& aInterface )
+: iInterface( aInterface )
+ {
+ }
+
+
+CMemSpyEngineEComImplementation::~CMemSpyEngineEComImplementation()
+ {
+ delete iCaption;
+ delete iName;
+ delete iInfoText;
+ delete iInfo;
+ }
+
+
+void CMemSpyEngineEComImplementation::ConstructL( CImplementationInformation* aInfo )
+ {
+ iInfoText = new(ELeave) CDesCArrayFlat( 10 );
+ TBuf< 256 > temp;
+
+ // Make items.
+ if ( aInfo->DisplayName().Length() )
+ {
+ _LIT( KNameFormat, "0x%08x - %S" );
+ temp.Format( KNameFormat, aInfo->ImplementationUid().iUid, &aInfo->DisplayName() );
+ }
+ else
+ {
+ _LIT( KNameFormat, "0x%08x" );
+ temp.Format( KNameFormat, aInfo->ImplementationUid().iUid );
+ }
+ iName = temp.AllocL();
+
+ _LIT( KItem1, "\tImpl. Uid\t\t0x%08x" );
+ temp.Format( KItem1, aInfo->ImplementationUid().iUid );
+ iInfoText->AppendL( temp );
+
+ if ( aInfo->DisplayName().Length() )
+ {
+ _LIT( KItem2, "\tDisplay Name\t\t%S" );
+ temp.Format( KItem2, &aInfo->DisplayName() );
+ }
+ else
+ {
+ _LIT( KItem2, "\tDisplay Name\t\t[Undefined]" );
+ temp.Copy( KItem2 );
+ }
+ iInfoText->AppendL( temp );
+
+ _LIT( KItem3, "\tVersion\t\t%d" );
+ temp.Format( KItem3, aInfo->Version() );
+ iInfoText->AppendL( temp );
+
+ HBufC* opaqueData = CopyAndCropLC( aInfo->OpaqueData() );
+ if ( opaqueData->Length() )
+ {
+ _LIT( KItem4, "\tOpaque Data\t\t%S" );
+ temp.Format( KItem4, opaqueData );
+ }
+ else
+ {
+ _LIT( KItem4, "\tOpaque Data\t\t[Undefined]" );
+ temp.Copy( KItem4 );
+ }
+ iInfoText->AppendL( temp );
+ CleanupStack::PopAndDestroy( opaqueData );
+
+ HBufC* dataType = CopyAndCropLC( aInfo->DataType() );
+ if ( opaqueData->Length() )
+ {
+ _LIT( KItem5, "\tData Type\t\t%S" );
+ temp.Format( KItem5, dataType );
+ }
+ else
+ {
+ _LIT( KItem5, "\tData Type\t\t[Undefined]" );
+ temp.Copy( KItem5 );
+ }
+ iInfoText->AppendL( temp );
+ CleanupStack::PopAndDestroy( dataType );
+
+ _LIT( KItem6, "\tDrive\t\t%S" );
+ TBuf< 10 > drive;
+ const TDriveNumber driveNumber = static_cast< TDriveNumber >( static_cast< TInt >( aInfo->Drive() ) );
+ CMemSpyEngineHelperFileSystem::GetDriveNumberText( driveNumber, drive );
+ temp.Format( KItem6, &drive );
+ iInfoText->AppendL( temp );
+
+ if ( aInfo->Disabled() )
+ {
+ iInfoText->AppendL( _L("\tIs Disabled\t\tYes") );
+ }
+ else
+ {
+ iInfoText->AppendL( _L("\tIs Disabled\t\tNo") );
+ }
+
+ if ( aInfo->RomOnly() )
+ {
+ iInfoText->AppendL( _L("\tROM-Only\t\tYes") );
+ }
+ else
+ {
+ iInfoText->AppendL( _L("\tROM-Only\t\tNo") );
+ }
+
+ if ( aInfo->RomBased() )
+ {
+ iInfoText->AppendL( _L("\tROM-Based\t\tYes") );
+ }
+ else
+ {
+ iInfoText->AppendL( _L("\tROM-Based\t\tNo") );
+ }
+
+ // Make caption
+ if ( aInfo->DisplayName().Length() )
+ {
+ _LIT( KCaptionFormat, "\t0x%08x\t\t%S" );
+ temp.Format( KCaptionFormat, aInfo->ImplementationUid().iUid, &aInfo->DisplayName() );
+ }
+ else
+ {
+ _LIT( KCaptionFormat, "\t0x%08x\t\t[Name Undefined]" );
+ temp.Format( KCaptionFormat, aInfo->ImplementationUid().iUid );
+ }
+ iCaption = temp.AllocL();
+
+ // Must do this last
+ iInfo = aInfo;
+ }
+
+
+CMemSpyEngineEComImplementation* CMemSpyEngineEComImplementation::NewLC( CMemSpyEngineEComInterface& aInterface, CImplementationInformation* aInfo )
+ {
+ CMemSpyEngineEComImplementation* self = new(ELeave) CMemSpyEngineEComImplementation( aInterface );
+ CleanupStack::PushL( self );
+ self->ConstructL( aInfo );
+ return self;
+ }
+
+
+HBufC* CMemSpyEngineEComImplementation::CopyAndCropLC( const TDesC8& aText )
+ {
+ const TInt KMaxEComDataLength = 200; // Any longer and we'll crop it...
+ //
+ HBufC* data = HBufC::NewLC( aText.Length() );
+ data->Des().Copy( aText );
+ //
+ if ( data->Length() > KMaxEComDataLength )
+ {
+ data->Des().SetLength( KMaxEComDataLength );
+ }
+ //
+ return data;
+ }
+
+
+EXPORT_C TInt CMemSpyEngineEComImplementation::MdcaCount() const
+ {
+ return iInfoText->MdcaCount();
+ }
+
+
+EXPORT_C TPtrC CMemSpyEngineEComImplementation::MdcaPoint( TInt aIndex ) const
+ {
+ return iInfoText->MdcaPoint( aIndex );
+ }
+
+
+