/// <summary>
/// Given an IEqualityComparer on TKey, returns an IEqualityComparer on
/// key-value Pairs.
/// </summary>
/// <typeparam name="TKey">TKey of the pairs</typeparam>
/// <typeparam name="TValue">TValue of the apris</typeparam>
/// <param name="keyEqualityComparer">IComparer on TKey</param>
/// <returns>IEqualityComparer for comparing key-value pairs.</returns>
public static IEqualityComparer <KeyValuePair <TKey, TValue> > EqualityComparerKeyValueFromComparerKey <TKey, TValue>(
IEqualityComparer <TKey> keyEqualityComparer)
{
keyEqualityComparer.ShouldNotBeNull("keyEqualityComparer");
return(new KeyValueEqualityComparer <TKey, TValue>(keyEqualityComparer));
}
/// <summary>
/// Creates a new Set. The Equals and GetHashCode method of the passed comparer object
/// will be used to compare items in this set.
/// </summary>
/// <param name="equalityComparer">An instance of IEqualityComparer<T> that will be used to compare items.</param>
public Set(IEqualityComparer <T> equalityComparer)
{
equalityComparer.ShouldNotBeNull("equalityComparer");
_equalityComparer = equalityComparer;
_hash = new Hash <T>(equalityComparer);
}
/// <summary>
/// Creates a new Bag. The Equals and GetHashCode methods of the passed comparison object
/// will be used to compare items in this bag for equality.
/// </summary>
/// <param name="equalityComparer">An instance of IEqualityComparer<T> that will be used to compare items.</param>
public Bag(IEqualityComparer <T> equalityComparer)
{
equalityComparer.ShouldNotBeNull("equalityComparer");
_keyEqualityComparer = equalityComparer;
_equalityComparer = Comparers.EqualityComparerKeyValueFromComparerKey <T, int>(equalityComparer);
_hash = new Hash <KeyValuePair <T, int> >(_equalityComparer);
}
/// <summary>
/// Create a new MultiDictionary. Private constructor, for use by Clone().
/// </summary>
private MultiDictionary(bool allowDuplicateValues, IEqualityComparer <TKey> keyEqualityComparer,
IEqualityComparer <TValue> valueEqualityComparer, IEqualityComparer <KeyAndValues> equalityComparer,
Hash <KeyAndValues> hash)
{
keyEqualityComparer.ShouldNotBeNull("keyEqualityComparer");
valueEqualityComparer.ShouldNotBeNull("valueEqualityComparer");
_allowDuplicateValues = allowDuplicateValues;
_keyEqualityComparer = keyEqualityComparer;
_valueEqualityComparer = valueEqualityComparer;
_equalityComparer = equalityComparer;
_hash = hash;
}
/// <summary>
/// Create a new MultiDictionary. 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="keyEqualityComparer">An IEqualityComparer<TKey> instance that will be used to compare keys.</param>
/// <param name="valueEqualityComparer">An IEqualityComparer<TValue> instance that will be used to compare values.</param>
public MultiDictionary(bool allowDuplicateValues, IEqualityComparer <TKey> keyEqualityComparer,
IEqualityComparer <TValue> valueEqualityComparer)
{
keyEqualityComparer.ShouldNotBeNull("keyEqualityComparer");
valueEqualityComparer.ShouldNotBeNull("valueEqualityComparer");
_allowDuplicateValues = allowDuplicateValues;
_keyEqualityComparer = keyEqualityComparer;
_valueEqualityComparer = valueEqualityComparer;
_equalityComparer = new KeyAndValuesEqualityComparer(keyEqualityComparer);
_hash = new Hash <KeyAndValues>(_equalityComparer);
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="comparer"></param>
public ConcurrentMultiMap(IEqualityComparer <TKey> comparer)
{
comparer.ShouldNotBeNull("comparer");
InnerMap = new ConcurrentDictionary <TKey, ICollection <TValue> >(comparer);
}
public KeyValueEqualityComparer(IEqualityComparer <TKey> keyEqualityComparer)
{
keyEqualityComparer.ShouldNotBeNull("keyEqualityComparer");
_keyEqualityComparer = keyEqualityComparer;
}
public ConcurrentMultiSet(IEqualityComparer <TKey> keyComparer)
{
keyComparer.ShouldNotBeNull("keyComparer");
InnerMap = new ConcurrentDictionary <TKey, ISet <TValue> >(keyComparer);
}
/// <summary>
/// Constructor. Create a new hash table.
/// </summary>
/// <param name="equalityComparer">The comparer to use to compare items. </param>
public Hash(IEqualityComparer <T> equalityComparer)
{
equalityComparer.ShouldNotBeNull("equalityComparer");
_equalityComparer = equalityComparer;
}
