void CSsmCommandListResourceReaderImpl::CResourcePool::GetCommandListIdsL(RArray<TInt>& aArray) const
{
TInt count = iMappings.Count();
__ASSERT_ALWAYS(count > 0, PanicNow(KPanicCmdResourceReader, ENotInitialized3));
if (aArray.Count() != 0)
{
SSMLOGLEAVE(KErrArgument);
}
aArray.ReserveL(count);
#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE
TInt i = 0;
for(i = 0; i < iMappings.Count() - 1 ; ++i)
{
if(iMappings[i].iCommandListId != iMappings[i+1].iCommandListId)
{
aArray.AppendL(iMappings[i].iCommandListId);
}
}
//append the last element anyway as it is already compared
aArray.AppendL(iMappings[i].iCommandListId);
aArray.Compress();
DEBUGPRINT2(_L("The number of substates in resource files : %d"),iMappings.Count() );
DEBUGPRINT2(_L("The number of substates after filtering duplicates : %d"),aArray.Count());
#else
for(TInt i = 0; i < count; ++i)
{
aArray.AppendL(iMappings[i].iCommandListId);
}
#endif
}
LOCAL_C void MainL()
{
// allocate slots ahead of time to avoid problems with OOM tests.
RepsToReset.ReserveL(KMaxNumRepsToReset);
TheTest.Start(_L("Tests for basic PlatSec"));
BasicPlatsecTestsL();
TheTest.Next(_L("Tests for Transaction PlatSec"));
TransactionPlatsecTestsL();
TheTest.Next(_L("Server persistence test"));
ServerPersistenceTest();
TheTest.End();
TheTest.Close();
RepsToReset.Reset();
}
// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void PosLmLandmarkHandler::GetAllLandmarkIdsL(
CPosLmLocalDbAccess& aDbAccess,
TBool aUseSort,
TBool aSortDescending,
RArray<TPosLmItemId>& aLandmarkIds)
{
aLandmarkIds.Reset();
HBufC* sql = HBufC::NewLC(KPosLmSqlStatementMaxLen);
if (aUseSort)
{
sql->Des().Format(KPosLmSqlSelectOrderByString, &KPosLmLandmarkIdCol,
&KPosLmLandmarkTable, &KPosLmNameCol);
if (aSortDescending)
{
sql->Des().Append(KPosLmSqlDescOrder);
}
}
else
{
sql->Des().Format(KPosLmSqlSelect, &KPosLmLandmarkIdCol,
&KPosLmLandmarkTable);
}
RDbView view;
aDbAccess.PrepareViewLC(CPosLmLocalDbAccess::EUpdatablePreparation, view,
*sql, EDbCompareCollated);
aLandmarkIds.ReserveL( view.CountL() );
while ( view.NextL() )
{
view.GetL();
aLandmarkIds.AppendL( view.ColUint32(1) );
}
CleanupStack::PopAndDestroy(2, sql); //&view
}
/**
@SYMTestCaseID PDS-DBMS-UT-4009
@SYMTestCaseDesc DBMS performance tests.
@SYMTestPriority High
@SYMTestActions The test opens the test database and:
- selects the ids of the tracks to be deleted and collects them into an array;
- deletes the recods with matching track ids from TRACK table;
- deletes the recods with matching track ids from TRACK2 table;
The execution times are printed out.
@SYMTestExpectedResults Test must not fail
@SYMREQ REQ7141
*/
void DeleteTracksL()
{
TheTest.Printf(_L("Record count: %d\r\n"), KTrackRecordCount);
RArray<TInt> tracks;
tracks.ReserveL(KTrackRecordCount);
CleanupClosePushL(tracks);
SelectTracksL(KTrackRecordCount, tracks);
//
_LIT(KDeleteSql, "DELETE FROM tracks WHERE id>=%d AND id<=%d");
TBuf<100> sql;
sql.Format(KDeleteSql, tracks[0], tracks[tracks.Count() - 1]);
TUint32 fc2 = User::FastCounter();
TInt err = TheDatabase.Begin();
TEST2(err, KErrNone);
TUint32 fc = User::FastCounter();
TInt rc = TheDatabase.Execute(sql);
PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
TEST2(rc, KTrackRecordCount);
TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);
sql.Replace(12, 6, _L("TRACKS2"));
fc = User::FastCounter();
rc = TheDatabase.Execute(sql);
PrintFcDiffAsUs(_L("###\"DELETE FROM TRACKS2\",time=%d us\r\n"), CalcTickDiff(fc, User::FastCounter()));
TEST2(rc, KTrackRecordCount);
TheTest.Printf(_L("Deleted record count: %d\r\n"), rc);
err = TheDatabase.Commit();
TEST2(err, KErrNone);
PrintFcDiffAsUs(_L("###Total \"DELETE FROM TRACKS\",time=%d us\r\n"), CalcTickDiff(fc2, User::FastCounter()));
CleanupStack::PopAndDestroy(&tracks);
}
// ------------------------------------------------
// PostProcessL
// ------------------------------------------------
//
void CMdSFindSequence::PostProcessL( CMdCSerializationBuffer& aSerializedResultBuffer )
{
#ifdef _DEBUG
_LIT( KFindFunctionName, "CMdSFindSequence::PostProcessL" );
#endif
// process only on items result
if (!iLastResultModeItems)
{
return;
}
if(iFindOperation && iFindOperation->FindCriteria().IncludesFreetexts() == EFalse )
{
return;
}
if (!iFindOperation)
{
return;
}
RPointerArray<HBufC>& searchFreeText = iFindOperation->QueryFreeText();
// to through every object and check freetext
aSerializedResultBuffer.PositionL( KNoOffset );
const TMdCItems& items = TMdCItems::GetFromBufferL( aSerializedResultBuffer );
const TBool needToSort = searchFreeText.Count() != 0
&& items.iObjects.iPtr.iCount > 1;
RArray<TObjectHitCount> hitCountArray;
CleanupClosePushL( hitCountArray );
TObjectHitCount hitCount;
for( TUint32 i = 0; i < items.iObjects.iPtr.iCount; ++i )
{
aSerializedResultBuffer.PositionL( items.iObjects.iPtr.iOffset
+ i * sizeof(TMdCObject) );
const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedResultBuffer );
// check all objects
// jump to freetext
if ( object.iFreeTexts.iPtr.iCount == 0 )
{
continue;
}
CDesC16ArrayFlat* resultWordBuffer = new(ELeave) CDesC16ArrayFlat( object.iFreeTexts.iPtr.iCount );
CleanupStack::PushL( resultWordBuffer );
// get freetext for object
GetFreeTextForObjectL( *resultWordBuffer, items.iNamespaceDefId, object.iId );
__ASSERT_DEBUG( object.iFreeTexts.iPtr.iCount == resultWordBuffer->Count(), User::Panic( KFindFunctionName, KErrCorrupt) );
if (needToSort)
{
hitCount.iObjectOffset = items.iObjects.iPtr.iOffset + i * sizeof(TMdCObject);
hitCount.iCount = GetFreeTextHitCountL( *resultWordBuffer, searchFreeText );
hitCountArray.AppendL( hitCount );
}
aSerializedResultBuffer.PositionL( object.iFreeTexts.iPtr.iOffset );
for ( TUint32 f = 0; f < object.iFreeTexts.iPtr.iCount; ++f )
{
// insert freeText here
TPtrC16 word = (*resultWordBuffer)[f];
aSerializedResultBuffer.InsertL( word );
}
CleanupStack::PopAndDestroy( resultWordBuffer );
}
if ( needToSort && hitCountArray.Count() > 1 )
{
hitCountArray.Sort( TLinearOrder<TObjectHitCount>( SortValues ) );
RArray<TMdCObject> objectArray;
CleanupClosePushL( objectArray );
objectArray.ReserveL( items.iObjects.iPtr.iCount );
// store objects in array in correct order
for( TInt i = 0; i < items.iObjects.iPtr.iCount; ++i )
{
aSerializedResultBuffer.PositionL( hitCountArray[i].iObjectOffset );
const TMdCObject& object = TMdCObject::GetFromBufferL( aSerializedResultBuffer );
objectArray.AppendL( object );
}
// set them back in serialized buffer
aSerializedResultBuffer.PositionL( items.iObjects.iPtr.iOffset );
for (TInt i = 0; i < items.iObjects.iPtr.iCount; ++i)
{
objectArray[i].SerializeL( aSerializedResultBuffer );
}
CleanupStack::PopAndDestroy( &objectArray );
}
CleanupStack::PopAndDestroy( &hitCountArray );
}
// ---------------------------------------------------------------------------
// SetFilesToPresentL
// ---------------------------------------------------------------------------
//
void CMdSManipulationEngine::SetFilesToPresentL(TUint32 aMediaId, TUint32 aFileCount,
CMdCSerializationBuffer& aUris, CMdCSerializationBuffer& aFileInfos,
CMdCSerializationBuffer& aResults)
{
CMdSSqLiteConnection& connection = MMdSDbConnectionPool::GetDefaultDBL();
RMdSTransaction transaction( connection );
CleanupClosePushL( transaction );
User::LeaveIfError( transaction.Error() );
RArray<TItemId> itemIds;
CleanupClosePushL( itemIds );
itemIds.ReserveL( aFileCount );
RArray<TItemId> notifyItemIds;
CleanupClosePushL( notifyItemIds );
notifyItemIds.ReserveL( aFileCount );
for( TUint32 i = 0; i < aFileCount; i++ )
{
TPtrC16 uri = aUris.ReceivePtr16L();
TPtr16 uriLC( CONST_CAST( TUint16*, uri.Ptr() ), uri.Length(), uri.Length() );
uriLC.LowerCase();
TMdSFileInfo fileInfo;
aFileInfos.ReceiveL(fileInfo.iModifiedTime);
aFileInfos.ReceiveL(fileInfo.iSize);
#ifdef _DEBUG
const TInt64 time = fileInfo.iModifiedTime;
RDebug::Print( _L("CMdSManipulationEngine::SetFilesToPresentL: (%d) uri %S, iSize %u, iModified %Ld"),
i,
&uri,
fileInfo.iSize,
time );
#endif
TFilePresentStates placeHolder;
TBool notPresentState( EFalse );
const TItemId objectId = iManipulate->SearchNotPresentFileL(
aMediaId, uri, fileInfo, placeHolder, notPresentState );
if ( placeHolder != EMdsNotFound )
{
itemIds.Append( objectId );
if( notPresentState )
{
notifyItemIds.Append( objectId );
}
}
aResults.InsertL( (TUint8)placeHolder );
}
iManipulate->SetFilesToPresentL( itemIds );
// only notify about objects in not present state and
// modify and notify relations related to those
if( notifyItemIds.Count() > 0 )
{
iNotifier.NotifyObjectPresent( ETrue, notifyItemIds );
RArray<TItemId> relationIds;
CleanupClosePushL( relationIds );
const TInt itemIdCount = notifyItemIds.Count();
for( TUint32 i = 0; i < itemIdCount; i++ )
{
iManipulate->SetRelationsToPresentL( notifyItemIds[i], relationIds );
}
iNotifier.NotifyRelationPresent( ETrue, relationIds );
CleanupStack::PopAndDestroy( &relationIds );
}
transaction.CommitL();
CleanupStack::PopAndDestroy( ¬ifyItemIds );
CleanupStack::PopAndDestroy( &itemIds );
CleanupStack::PopAndDestroy( &transaction );
}
// ------------------------------------------------
// NotifyRemoved
// ------------------------------------------------
//
void CMdSNotifier::NotifyRemovedL(CMdCSerializationBuffer& aSerializedItemIds,
TBool aItemIsConfidential,
RPointerArray<HBufC>& aRemovedItemUriArray,
CMdSManipulationEngine* aMEngine )
{
aSerializedItemIds.PositionL( KNoOffset );
const TMdCItemIds& itemIds = TMdCItemIds::GetFromBufferL( aSerializedItemIds );
RArray<TItemId> objectIdArray;
CleanupClosePushL( objectIdArray );
RArray<TItemId> eventIdArray;
CleanupClosePushL( eventIdArray );
RArray<TItemId> relationIdArray;
CleanupClosePushL( relationIdArray );
//get removed item IDs
if( itemIds.iObjectIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iObjectIds.iPtr.iOffset );
objectIdArray.ReserveL( itemIds.iObjectIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iObjectIds.iPtr.iCount; i++ )
{
TItemId objectId;
aSerializedItemIds.ReceiveL( objectId );
if ( objectId != KNoId )
{
objectIdArray.Append( objectId );
}
}
}
if( itemIds.iEventIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iEventIds.iPtr.iOffset );
eventIdArray.ReserveL( itemIds.iEventIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iEventIds.iPtr.iCount; i++ )
{
TItemId eventId;
aSerializedItemIds.ReceiveL( eventId );
if ( eventId != KNoId )
{
eventIdArray.Append( eventId );
}
}
}
if( itemIds.iRelationIds.iPtr.iCount > 0 )
{
aSerializedItemIds.PositionL( itemIds.iRelationIds.iPtr.iOffset );
relationIdArray.ReserveL( itemIds.iRelationIds.iPtr.iCount );
for( TUint32 i = 0; i < itemIds.iRelationIds.iPtr.iCount; i++ )
{
TItemId relationId;
aSerializedItemIds.ReceiveL( relationId );
if ( relationId != KNoId )
{
relationIdArray.Append( relationId );
}
}
}
const TInt objectCount( objectIdArray.Count() );
const TInt eventCount( eventIdArray.Count() );
const TInt relationCount( relationIdArray.Count() );
if( objectCount != 0
|| eventCount != 0
|| relationCount != 0 )
{
for( TInt i = iEntries.Count() - 1; i >=0; i-- )
{
TEntry& e = iEntries[i];
// if namespace definition IDs don't match skip listener entry
if( e.NamespaceDefId() != itemIds.iNamespaceDefId )
{
continue;
}
if(aItemIsConfidential && !e.AllowConfidential())
{
continue;
}
RPointerArray<HBufC> uriArray;
CleanupResetAndDestroyPushL( uriArray );
if( e.iType & EObjectNotifyRemove && objectCount > 0 )
{
// collect matching object IDs
RArray<TItemId> matchingObjectIdArray;
CleanupClosePushL( matchingObjectIdArray );
const TBool allMatches = iComparator->MatchObjectIdsL( e.Condition(),
objectIdArray, matchingObjectIdArray );
// check is there any matches
if( allMatches || matchingObjectIdArray.Count() > 0 )
{
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TInt err( KErrNone );
if( allMatches )
{
// all matches so send whole object ID array
TRAP( err, e.TriggerL( EObjectNotifyRemove,
objectIdArray, uriArray ) );
}
else
{
TRAP( err, e.TriggerL( EObjectNotifyRemove,
matchingObjectIdArray, uriArray ) );
}
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
if( allMatches )
{
// all matches so send whole object ID array
TRAP_IGNORE( e.CacheL( EObjectNotifyRemove,
objectIdArray, uriArray ) );
}
else
{
TRAP_IGNORE( e.CacheL( EObjectNotifyRemove,
matchingObjectIdArray, uriArray ) );
}
}
}
CleanupStack::PopAndDestroy( &matchingObjectIdArray );
}
else if( e.iType & EObjectNotifyRemoveWithUri && objectCount > 0 )
{
// collect matching object IDs
RArray<TItemId> matchingObjectIdArray;
CleanupClosePushL( matchingObjectIdArray );
const TBool allMatches = iComparator->MatchObjectIdsL( e.Condition(),
objectIdArray, matchingObjectIdArray );
// check is there any matches
if( allMatches || matchingObjectIdArray.Count() > 0 )
{
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TInt err( KErrNone );
if( allMatches )
{
// all matches so send whole object ID array
TRAP( err, e.TriggerL( EObjectNotifyRemoveWithUri,
objectIdArray, aRemovedItemUriArray ) );
}
else
{
aMEngine->GetObjectUrisByIdsL( objectIdArray, uriArray );
TRAP( err, e.TriggerL( EObjectNotifyRemoveWithUri,
matchingObjectIdArray, uriArray ) );
}
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
if( allMatches )
{
// all matches so send whole object ID array
TRAP_IGNORE( e.CacheL( EObjectNotifyRemoveWithUri,
objectIdArray, aRemovedItemUriArray ) );
}
else
{
aMEngine->GetObjectUrisByIdsL( objectIdArray, uriArray );
TRAP_IGNORE( e.CacheL( EObjectNotifyRemoveWithUri,
matchingObjectIdArray, uriArray ) );
}
}
}
CleanupStack::PopAndDestroy( &matchingObjectIdArray );
}
else if( ( e.iType & EEventNotifyRemove )
&& eventCount > 0 )
{
// event condition can't contain ID conditions,
// so get all IDs
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TRAPD( err, e.TriggerL( EEventNotifyRemove,
eventIdArray, uriArray ) );
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
TRAP_IGNORE( e.CacheL( EEventNotifyRemove,
eventIdArray, uriArray ) );
}
}
else if( ( e.iType & ERelationNotifyRemove )
&& relationCount > 0 )
{
// relation condition can't contain ID conditions,
// so get all IDs
if(e.IsPending())
{
// Match found. Trigger notifier entry.
TRAPD( err, e.TriggerL( ERelationNotifyRemove,
relationIdArray, uriArray ) );
if( err != KErrNone )
{
e.TriggerError( err );
}
}
else
{
TRAP_IGNORE( e.CacheL( ERelationNotifyRemove,
relationIdArray, uriArray ) );
}
}
CleanupStack::PopAndDestroy( &uriArray );
}
}
CleanupStack::PopAndDestroy( 3, &objectIdArray ); // relationIdArray, eventIdArray, objectIdArray
}
