public PairComparer(IComparer <TKey> keyComparer, IComparer <TValue> valueComparer) { keyComparer.ShouldNotBeNull("keyComparer"); valueComparer.ShouldNotBeNull("valueComparer"); _keyComparer = keyComparer; _valueComparer = valueComparer; }
/// <summary> /// Given an IComparer on TKey and TValue, returns an IComparer on /// key-value Pairs of TKey and TValue, comparing first keys, then values. /// </summary> /// <typeparam name="TKey">TKey of the pairs</typeparam> /// <typeparam name="TValue">TValue of the apris</typeparam> /// <param name="keyComparer">IComparer on TKey</param> /// <param name="valueComparer">IComparer on TValue</param> /// <returns>IComparer for comparing key-value pairs.</returns> public static IComparer <KeyValuePair <TKey, TValue> > ComparerPairFromKeyValueComparers <TKey, TValue>(IComparer <TKey> keyComparer, IComparer <TValue> valueComparer) { keyComparer.ShouldNotBeNull("keyComparer"); valueComparer.ShouldNotBeNull("valueComparer"); return(new PairComparer <TKey, TValue>(keyComparer, valueComparer)); }
/// <summary> /// Create a new OrderedMultiDictionary. If duplicate values /// are allowed, multiple copies of the same value can be associated with the same key. For example, the key "foo" /// could have "a", "a", and "b" associated with it. If duplicate values are not allowed, only one copies of a given value can /// be associated with the same key, although different keys can have the same value. For example, the key "foo" could /// have "a" and "b" associated with it, which key "bar" has values "b" and "c" associated with it. /// </summary> /// <param name="allowDuplicateValues">Can the same value be associated with a key multiple times?</param> /// <param name="keyComparer">An IComparer<TKey> instance that will be used to compare keys.</param> /// <param name="valueComparer">An IComparer<TValue> instance that will be used to compare values.</param> public OrderedMultiDictionary(bool allowDuplicateValues, IComparer <TKey> keyComparer, IComparer <TValue> valueComparer) { keyComparer.ShouldNotBeNull("keyComparer"); valueComparer.ShouldNotBeNull("valueComparer"); _allowDuplicateValues = allowDuplicateValues; _keyComparer = keyComparer; _valueComparer = valueComparer; _comparer = Comparers.ComparerPairFromKeyValueComparers(keyComparer, valueComparer); _tree = new RedBlackTree <KeyValuePair <TKey, TValue> >(_comparer); }
/// <summary> /// Creates a new OrderedDictionary. The Compare method of the passed comparison object /// will be used to compare keys in this dictionary. /// </summary> /// <remarks> /// The GetHashCode and Equals methods of the provided IComparer<TKey> will never /// be called, and need not be implemented.</remarks> /// <param name="comparer">An instance of IComparer<TKey> that will be used to compare keys.</param> public OrderedDictionary(IComparer <TKey> comparer) : this(null, comparer, Comparers.ComparerKeyValueFromComparerKey <TKey, TValue>(comparer)) { comparer.ShouldNotBeNull("comparer"); }
/// <summary> /// <para>Creates a new OrderedDictionary. The Compare method of the passed comparison object /// will be used to compare keys in this dictionary.</para> /// <para>A collection and keys and values (typically another dictionary) is used to initialized the /// contents of the dictionary.</para> /// </summary> /// <remarks> /// The GetHashCode and Equals methods of the provided IComparer<TKey> will never /// be called, and need not be implemented.</remarks> /// <param name="keysAndValues">A collection of keys and values whose contents are used to initialized the dictionary.</param> /// <param name="comparer">An instance of IComparer<TKey> that will be used to compare keys.</param> public OrderedDictionary(IEnumerable <KeyValuePair <TKey, TValue> > keysAndValues, IComparer <TKey> comparer) : this(keysAndValues, comparer, Comparers.ComparerKeyValueFromComparerKey <TKey, TValue>(comparer)) { comparer.ShouldNotBeNull("comparer"); }
public KeyValueComparer(IComparer <TKey> keyComparer) { keyComparer.ShouldNotBeNull("keyComparer"); _keyComparer = keyComparer; }
/// <summary> /// Given an IComparer on TKey, returns an IComparer on /// key-value Pairs. /// </summary> /// <typeparam name="TKey">TKey of the pairs</typeparam> /// <typeparam name="TValue">TValue of the apris</typeparam> /// <param name="keyComparer">IComparer on TKey</param> /// <returns>IComparer for comparing key-value pairs.</returns> public static IComparer <KeyValuePair <TKey, TValue> > ComparerKeyValueFromComparerKey <TKey, TValue>(IComparer <TKey> keyComparer) { keyComparer.ShouldNotBeNull("keyComparer"); return(new KeyValueComparer <TKey, TValue>(keyComparer)); }