private static void VerifyCtor_IEqualityComparer(NameValueCollection nameValueCollection, IEqualityComparer equalityComparer, int newCount)
{
Assert.Equal(0, nameValueCollection.Count);
Assert.Equal(0, nameValueCollection.Keys.Count);
Assert.Equal(0, nameValueCollection.AllKeys.Length);
Assert.False(((ICollection)nameValueCollection).IsSynchronized);
string[] values = new string[newCount];
for (int i = 0; i < newCount; i++)
{
string value = "Value_" + i;
nameValueCollection.Add("Name_" + i, value);
values[i] = value;
}
if (equalityComparer?.GetType() == typeof(IdiotComparer))
{
Assert.Equal(1, nameValueCollection.Count);
string expectedValues = string.Join(",", values);
Assert.Equal(expectedValues, nameValueCollection["Name_1"]);
Assert.Equal(expectedValues, nameValueCollection["any-name"]);
nameValueCollection.Remove("any-name");
Assert.Equal(0, nameValueCollection.Count);
}
else
{
Assert.Equal(newCount, nameValueCollection.Count);
nameValueCollection.Remove("any-name");
Assert.Equal(newCount, nameValueCollection.Count);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="type">Type.</param>
/// <param name="typeId">Type ID.</param>
/// <param name="typeName">Type name.</param>
/// <param name="userType">User type flag.</param>
/// <param name="nameMapper">Name converter.</param>
/// <param name="idMapper">Mapper.</param>
/// <param name="serializer">Serializer.</param>
/// <param name="keepDeserialized">Whether to cache deserialized value in IBinaryObject</param>
/// <param name="affKeyFieldName">Affinity field key name.</param>
/// <param name="isEnum">Enum flag.</param>
/// <param name="comparer">Equality comparer.</param>
public BinaryFullTypeDescriptor(
Type type,
int typeId,
string typeName,
bool userType,
IBinaryNameMapper nameMapper,
IBinaryIdMapper idMapper,
IBinarySerializerInternal serializer,
bool keepDeserialized,
string affKeyFieldName,
bool isEnum,
IEqualityComparer <IBinaryObject> comparer)
{
_type = type;
_typeId = typeId;
_typeName = typeName;
_userType = userType;
_nameMapper = nameMapper;
_idMapper = idMapper;
_serializer = serializer;
_keepDeserialized = keepDeserialized;
_affKeyFieldName = affKeyFieldName;
_isEnum = isEnum;
_equalityComparer = comparer as IBinaryEqualityComparer;
if (comparer != null && _equalityComparer == null)
{
throw new IgniteException(string.Format("Unsupported IEqualityComparer<IBinaryObject> " +
"implementation: {0}. Only predefined implementations " +
"are supported.", comparer.GetType()));
}
}
private void test <T>(IEqualityComparer <T> comparer)
{
var param = Expression.Parameter(typeof(IEqualityComparer <T>));
var call = Expression.Call(param, comparer.GetType().GetMethod("Equals"), Expression.Constant("abc"), Expression.Constant("ABC"));
var func = Expression.Lambda(call, param).Compile();
var result = func.DynamicInvoke(comparer);
}
/// <summary>
/// Configures the equality comparer for this value object type.
/// </summary>
/// <typeparam name="T">The value object type.</typeparam>
/// <param name="equalityComparer">The equality comparer.</param>
public void ConfigureEqualityComparer <T>(IEqualityComparer <T> equalityComparer)
{
Guard.Against.Null(() => equalityComparer);
var equalityComparerType = typeof(IEqualityComparer <>).MakeGenericType(this.RuntimeType);
if (!equalityComparerType.IsAssignableFrom(equalityComparer.GetType()))
{
throw new BusinessException(
string.Format(
CultureInfo.InvariantCulture,
"Invalid equality comparer. The specified equality comparer of type '{0}' does not match the required type of '{1}'.",
equalityComparer.GetType(),
equalityComparerType));
}
this.EqualityComparer = equalityComparer;
}
private static string GetComparerName <T>(IEqualityComparer <T> comparer)
{
string comparerStr = comparer.ToString();
if (comparerStr == comparer.GetType().ToString())
{
comparerStr = comparer.GetType().Name;
}
comparerStr = AssertUtility.FormatArgument(comparerStr);
if (comparer == EqualityComparer <T> .Default)
{
comparerStr += " (default)";
}
return(comparerStr);
}
private bool GetComparerExpression(Expression arg, out Expression comparerExpression)
{
if (_comparer != null)
{
var equalsInfo = GetComparerEqualsMethodInfo(_comparer.GetType());
comparerExpression = Expression.Call(Expression.Constant(_comparer), equalsInfo,
arg, Expression.Constant(_expected, typeof(T)));
return(true);
}
comparerExpression = null;
return(false);
}
/// <summary>
/// Evaluates type that is compared.
/// </summary>
/// <typeparam name="T">type of comparer.</typeparam>
public static Type GetCompareType <T>(IEqualityComparer <T> comparer)
{
comparer.NotNull(nameof(comparer));
// evaluate type of a comparer
// due to covariant restriction typeof(T) is not valid
return(comparer
.GetType()
.GetMethods()
.First(x => x.Name == nameof(comparer.GetHashCode))
.GetParameters()
.First()
.ParameterType);
}
internal static TDestination CreateLikenessProxy <TSource, TDestination>(TSource source, IEqualityComparer comparer, IEnumerable <MemberInfo> members)
{
ProxyType proxyType = ProxyGenerator.FindCompatibleConstructor <TDestination>(source, members.ToArray());
TypeBuilder builder = ProxyGenerator.BuildType <TDestination>(BuildModule(BuildAssembly(assemblyName)));
FieldBuilder equals = ProxyGenerator.BuildFieldComparer(builder, comparer.GetType());
ProxyGenerator.BuildConstructors <TDestination>(proxyType.Constructor, builder, equals);
ProxyGenerator.BuildMethodEquals(builder, BuildFieldEqualsHasBeenCalled(builder), equals);
ProxyGenerator.BuildMethodGetHashCode <TDestination>(builder);
var destination = (TDestination)Activator.CreateInstance(
builder.CreateTypeInfo().AsType(),
proxyType.Parameters.Concat(new[] { comparer }).ToArray());
ProxyGenerator.Map(source, destination);
return(destination);
}
internal override Pair <MethodInfo, Expression[]> GetOperator()
{
Type sourceType = this.m_keySelector.Parameters[0].Type;
MethodInfo operation = TypeSystem.FindStaticMethod(
typeof(Microsoft.Research.DryadLinq.HpcLinqQueryable), "HashPartition",
new Type[] { typeof(IQueryable <>).MakeGenericType(sourceType),
m_keySelector.GetType(),
m_comparer.GetType(),
typeof(int) },
new Type[] { sourceType, typeof(TKey) });
Expression[] arguments = new Expression[] {
m_keySelector,
Expression.Constant(this.m_comparer, typeof(IEqualityComparer <TKey>)),
Expression.Constant(this.Count)
};
return(new Pair <MethodInfo, Expression[]>(operation, arguments));
}
static void TestComparerSerialization <TCompared>(IEqualityComparer <TCompared> equalityComparer, string internalTypeName = null)
{
var bf = new BinaryFormatter();
var s = new MemoryStream();
var dict = new HashSet <TCompared>(equalityComparer);
Assert.Same(equalityComparer, dict.Comparer);
bf.Serialize(s, dict);
s.Position = 0;
dict = (HashSet <TCompared>)bf.Deserialize(s);
if (internalTypeName == null)
{
Assert.IsType(equalityComparer.GetType(), dict.Comparer);
}
else
{
Assert.Equal(internalTypeName, dict.Comparer.GetType().ToString());
}
Assert.True(equalityComparer.Equals(dict.Comparer));
}
private static void TestComparerSerialization <T>(IEqualityComparer <T> equalityComparer, string internalTypeName = null)
{
var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
var s = new MemoryStream();
var dict = new LinkedDictionary <T, T>(equalityComparer);
Assert.Same(equalityComparer, dict.EqualityComparer);
bf.Serialize(s, dict);
s.Position = 0;
dict = (LinkedDictionary <T, T>)bf.Deserialize(s);
if (internalTypeName == null)
{
Assert.IsType(equalityComparer.GetType(), dict.EqualityComparer);
}
else
{
Assert.Equal(internalTypeName, dict.EqualityComparer.GetType().ToString());
}
Assert.True(equalityComparer.Equals(dict.EqualityComparer));
}
/// <summary>
/// Returns a set containing all the types in <paramref name="ns" />
/// with the specified comparer. This function uses the type of
/// <paramref name="comparer" /> to determine which factory method
/// should be used.
///
/// If <paramref name="ns" /> is a set with the same comparer as
/// <paramref name="comparer"/>, it may be returned without
/// modification.
/// </summary>
/// <param name="ns">The namespaces to contain in the set.</param>
/// <param name="comparer">The comparer to use for the set.</param>
/// <exception name="InvalidOperationException"><paramref
/// name="comparer" /> is not an instance of <see cref="ObjectComparer"
/// /> or <see cref="UnionComparer" />.</exception>
public static IAnalysisSet Create(IEnumerable <AnalysisProxy> ns, IEqualityComparer <AnalysisProxy> comparer)
{
var set = ns as IAnalysisSet;
if (set == null)
{
UnionComparer uc;
if (comparer is ObjectComparer)
{
return(ns == null?Create() : Create(ns));
}
else if ((uc = comparer as UnionComparer) != null)
{
return(ns == null?CreateUnion(uc) : CreateUnion(ns, uc));
}
}
else if (comparer == set.Comparer)
{
return(set);
}
else if (comparer != null && comparer.GetType() == set.Comparer.GetType())
{
return(set);
}
else if (comparer is ObjectComparer)
{
return(Create(set));
}
else if (comparer is UnionComparer)
{
bool dummy;
return(set.AsUnion((UnionComparer)comparer, out dummy));
}
throw new InvalidOperationException(string.Format("cannot use {0} as a comparer", comparer));
}
public ICacheTable <TKey> GetOrCreateTable <TKey>(string tableName, out bool createdNew, IEqualityComparer <TKey> keyComparer = null)
{
if (tableName.IsNullOrWhiteSpace())
{
throw new PileCacheException(StringConsts.ARGUMENT_ERROR + "GetTable(tableName=null|empty)");
}
ensureRunning("GetOrCreateTable");
LocalCacheTable <TKey> result;
var tbl = m_Tables[tableName];
if (tbl != null)
{
result = tbl as LocalCacheTable <TKey>;
if (result == null)
{
throw new PileCacheException(StringConsts.PILE_CACHE_TBL_KEYTYPE_MISMATCH_ERROR.Args(tableName,
tbl.GetType().DisplayNameWithExpandedGenericArgs(),
typeof(LocalCacheTable <TKey>).DisplayNameWithExpandedGenericArgs()));
}
if (keyComparer != null && result.KeyComparer != keyComparer)
{
throw new PileCacheException(StringConsts.PILE_CACHE_TBL_KEYCOMPARER_MISMATCH_ERROR.Args(tableName,
result.KeyComparer != null ? result.KeyComparer.GetType().FullName : StringConsts.NULL_STRING,
keyComparer != null ? keyComparer.GetType().FullName : StringConsts.NULL_STRING));
}
createdNew = false;
return(result);
}
lock (m_TablesLock)
{
tbl = m_Tables[tableName];
if (tbl != null)
{
result = tbl as LocalCacheTable <TKey>;
if (result == null)
{
throw new PileCacheException(StringConsts.PILE_CACHE_TBL_KEYTYPE_MISMATCH_ERROR.Args(tableName,
tbl.GetType().DisplayNameWithExpandedGenericArgs(),
typeof(LocalCacheTable <TKey>).DisplayNameWithExpandedGenericArgs()));
}
if (keyComparer != null && result.KeyComparer != keyComparer)
{
throw new PileCacheException(StringConsts.PILE_CACHE_TBL_KEYCOMPARER_MISMATCH_ERROR.Args(tableName,
result.KeyComparer != null ? result.KeyComparer.GetType().FullName : StringConsts.NULL_STRING,
keyComparer != null ? keyComparer.GetType().FullName : StringConsts.NULL_STRING));
}
createdNew = false;
return(result);
}
result = new LocalCacheTable <TKey>(this, tableName, keyComparer, m_TableOptions[tableName] ?? m_DefaultTableOptions);
m_Tables.Register(result);
createdNew = true;
return(result);
}
}
public LookupDelegate <TKey, TValue> CompileDynamicLookupFunction <TKey, TValue>(IEnumerable <KeyValuePair <TKey, TValue> > keyValuePairs, IEqualityComparer <TKey> keyComparer)
{
// ReSharper disable once PossibleMultipleEnumeration
keyValuePairs.MustNotBeNull();
keyComparer.MustNotBeNull();
var keyType = typeof(TKey);
var keyExpression = Expression.Parameter(keyType, "key");
var valueExpression = Expression.Parameter(typeof(TValue).MakeByRefType(), "value");
var keyComparerExpression = Expression.Constant(keyComparer);
var getHashCodeMethodInfo = keyComparer.GetType().GetRuntimeMethod(nameof(IEqualityComparer <TKey> .GetHashCode), new[] { keyType });
var equalsMethodInfo = keyComparer.GetType().GetRuntimeMethod(nameof(IEqualityComparer <TKey> .Equals), new[] { keyType, keyType });
var hashCodeExpression = Expression.Variable(typeof(int), "hashCode");
var resultExpression = Expression.Variable(typeof(bool), "result");
var trueExpression = Expression.Constant(true);
// ReSharper disable once PossibleMultipleEnumeration
var switchCases = keyValuePairs
.GroupBy(kvp => keyComparer.GetHashCode(kvp.Key))
.Select(hashCodeGroup =>
{
Expression caseBody;
if (hashCodeGroup.Count() == 1)
{
var keyValuePair = hashCodeGroup.First();
EnsureKeyIsNotNull(keyValuePair);
caseBody = Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression));
}
else
{
Expression lastIfStatement = null;
foreach (var keyValuePair in hashCodeGroup)
{
EnsureKeyIsNotNull(keyValuePair);
if (lastIfStatement == null)
{
lastIfStatement = Expression.IfThen(Expression.Call(keyComparerExpression, equalsMethodInfo, keyExpression, Expression.Constant(keyValuePair.Key)),
Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression)));
}
else
{
lastIfStatement = Expression.IfThenElse(Expression.Call(keyComparerExpression, equalsMethodInfo, keyExpression, Expression.Constant(keyValuePair.Key)),
Expression.Block(Expression.Assign(valueExpression, Expression.Constant(keyValuePair.Value)),
Expression.Assign(resultExpression, trueExpression)),
lastIfStatement);
}
}
caseBody = lastIfStatement;
}
return(Expression.SwitchCase(caseBody,
Expression.Constant(hashCodeGroup.Key)));
})
.ToArray();
var body = Expression.Block(new[] { hashCodeExpression, resultExpression },
Expression.Assign(hashCodeExpression, Expression.Call(keyComparerExpression, getHashCodeMethodInfo, keyExpression)),
Expression.Assign(resultExpression, Expression.Constant(false)),
Expression.Switch(typeof(void), hashCodeExpression, Expression.Assign(valueExpression, Expression.Constant(default(TValue), typeof(TValue))), null, switchCases),
resultExpression);
return(Expression.Lambda <LookupDelegate <TKey, TValue> >(body, keyExpression, valueExpression).Compile());
}
