--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/crashanalysercmd/PerfToolsSharedLibraries/Engine/SymbianUtils/Collections/SymbianSortedListByValue.cs Thu Feb 11 15:50:58 2010 +0200
@@ -0,0 +1,225 @@
+/*
+* 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:
+*
+*/
+using System;
+using System.Collections.Generic;
+
+namespace SymbianUtils.Collections
+{
+ public class SymbianSortedListByValue<TKey, TValue> where TValue : class
+ {
+ #region Constructors
+ public SymbianSortedListByValue( IComparer<TValue> aComparer )
+ : this( 10, aComparer )
+ {
+ }
+
+ public SymbianSortedListByValue( int aGranularity, IComparer<TValue> aComparer )
+ {
+ iList = new List<KeyValuePair<TValue, TKey>>( aGranularity );
+ iComparer = new SymbianSortedListByValueComparer( aComparer );
+ }
+
+ public SymbianSortedListByValue( SymbianSortedListByValue<TKey, TValue> aCollection )
+ {
+ int count = aCollection.Count;
+ //
+ iList = new List<KeyValuePair<TValue, TKey>>( count + 1 );
+ iComparer = new SymbianSortedListByValue<TKey, TValue>.SymbianSortedListByValueComparer( aCollection.iComparer.Comparer );
+ //
+ for ( int i = 0; i < count; i++ )
+ {
+ KeyValuePair<TValue, TKey> entry = aCollection.iList[ i ];
+ Add( entry.Value, entry.Key );
+ }
+ }
+ #endregion
+
+ #region API
+ public bool Contains( TKey aKey )
+ {
+ return iDictionary.ContainsKey( aKey );
+ }
+
+ public void Add( TKey aKey, TValue aValue )
+ {
+ if ( aKey == null )
+ {
+ throw new ArgumentNullException( "aKey cannot be null" );
+ }
+
+ // Add item to dictionary if required
+ if ( !iDictionary.ContainsKey( aKey ) )
+ {
+ iDictionary.Add( aKey, aValue );
+ }
+
+ // Search for item in the list. If it's already present then
+ // this will return the index. Otherwise, it will return a negative
+ // number.
+ // If this index is greater than or equal to the size of the array,
+ // there are no elements larger than value in the array.
+ //
+ // Otherwise, it is the index of the first element that is larger than value.
+ KeyValuePair<TValue, TKey> entry = new KeyValuePair<TValue, TKey>( aValue, aKey );
+ int index = iList.BinarySearch( entry, iComparer );
+ if ( index < 0 )
+ {
+ index = ~index;
+ }
+ iList.Insert( index, entry );
+ }
+
+ public void Remove( Predicate<TValue> aValue )
+ {
+ Predicate<KeyValuePair<TValue, TKey>> matchPredicate = delegate( KeyValuePair<TValue, TKey> aItem )
+ {
+ bool remove = aValue.Invoke( aItem.Key );
+ return remove;
+ };
+
+ RemoveAll( matchPredicate );
+ }
+
+ public void Remove( TValue aValue )
+ {
+ Predicate<KeyValuePair<TValue, TKey>> matchPredicate = delegate( KeyValuePair<TValue, TKey> aItem )
+ {
+ return ( aValue == aItem.Key );
+ };
+
+ RemoveAll( matchPredicate );
+ }
+
+ public void Remove( TKey aKey )
+ {
+ TValue v = null;
+ if ( iDictionary.TryGetValue( aKey, out v ) )
+ {
+ iDictionary.Remove( aKey );
+ Remove( v );
+ }
+ }
+
+ public void Clear()
+ {
+ iList.Clear();
+ iDictionary.Clear();
+ }
+
+ public void RemoveRange( int aStartIndex, int aCount )
+ {
+ List<KeyValuePair<TValue, TKey>> items = iList.GetRange( aStartIndex, aCount );
+ RemoveAll( items );
+ }
+
+ public void Sort( IComparer<TValue> aComparer )
+ {
+ SymbianSortedListByValueComparer comparer = new SymbianSortedListByValueComparer( aComparer );
+ iList.Sort( comparer );
+ iComparer = comparer;
+ }
+ #endregion
+
+ #region Properties
+ public int Count
+ {
+ get { return iList.Count; }
+ }
+
+ public TValue this[ int aIndex ]
+ {
+ get
+ {
+ KeyValuePair< TValue, TKey> ret = iList[ aIndex ];
+ return ret.Key;
+ }
+ }
+
+ public TValue this[ TKey aKey ]
+ {
+ get
+ {
+ TValue ret = null;
+ bool found = iDictionary.TryGetValue( aKey, out ret );
+ return ret;
+ }
+ }
+ #endregion
+
+ #region Internal methods
+ private void RemoveAll( Predicate<KeyValuePair<TValue, TKey>> aPredicate )
+ {
+ List<KeyValuePair<TValue, TKey>> items = iList.FindAll( aPredicate );
+ RemoveAll( items );
+ }
+
+ private void RemoveAll( List<KeyValuePair<TValue, TKey>> aItems )
+ {
+ foreach ( KeyValuePair<TValue, TKey> item in aItems )
+ {
+ // Remove from dictionary
+ TKey key = item.Value;
+ if ( iDictionary.ContainsKey( key ) )
+ {
+ iDictionary.Remove( key );
+ }
+
+ // Remove from list
+ TValue value = item.Key;
+ iList.Remove( item );
+ }
+ }
+ #endregion
+
+ #region Internal classes
+ private class SymbianSortedListByValueComparer : IComparer< KeyValuePair<TValue, TKey> >
+ {
+ #region Constructors
+ public SymbianSortedListByValueComparer( IComparer<TValue> aComparer )
+ {
+ iComparer = aComparer;
+ }
+ #endregion
+
+ #region Properties
+ public IComparer<TValue> Comparer
+ {
+ get { return iComparer; }
+ }
+ #endregion
+
+ #region From IComparer<KeyValuePair<TValue,TKey>>
+ public int Compare( KeyValuePair<TValue, TKey> aLeft, KeyValuePair<TValue, TKey> aRight )
+ {
+ int ret = iComparer.Compare( aLeft.Key, aRight.Key );
+ return ret;
+ }
+ #endregion
+
+ #region Data members
+ private readonly IComparer<TValue> iComparer;
+ #endregion
+ }
+ #endregion
+
+ #region Data members
+ private List< KeyValuePair<TValue, TKey> > iList = null;
+ private Dictionary<TKey, TValue> iDictionary = new Dictionary<TKey, TValue>();
+ private SymbianSortedListByValueComparer iComparer = null;
+ #endregion
+ }
+}