internal static EdmFunction ResolveFunctionOverloads(
IList <EdmFunction> functionsMetadata,
IList <TypeUsage> argTypes,
bool isGroupAggregateFunction,
out bool isAmbiguous)
{
return(FunctionOverloadResolver.ResolveFunctionOverloads <EdmFunction, FunctionParameter>(functionsMetadata, argTypes, (Func <EdmFunction, IList <FunctionParameter> >)(edmFunction => (IList <FunctionParameter>)edmFunction.Parameters), (Func <FunctionParameter, TypeUsage>)(functionParameter => functionParameter.TypeUsage), (Func <FunctionParameter, ParameterMode>)(functionParameter => functionParameter.Mode), (Func <TypeUsage, IEnumerable <TypeUsage> >)(argType => TypeSemantics.FlattenType(argType)), (Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> >)((paramType, argType) => TypeSemantics.FlattenType(paramType)), (Func <TypeUsage, TypeUsage, bool>)((fromType, toType) => TypeSemantics.IsPromotableTo(fromType, toType)), (Func <TypeUsage, TypeUsage, bool>)((fromType, toType) => TypeSemantics.IsStructurallyEqual(fromType, toType)), isGroupAggregateFunction, out isAmbiguous));
}
internal static EdmFunction ResolveFunctionOverloads(
IList <EdmFunction> functionsMetadata,
IList <TypeUsage> argTypes,
bool isGroupAggregateFunction,
out bool isAmbiguous)
{
return(FunctionOverloadResolver.ResolveFunctionOverloads(functionsMetadata, argTypes, new Func <TypeUsage, IEnumerable <TypeUsage> >(SemanticResolver.UntypedNullAwareFlattenArgumentType), new Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> >(SemanticResolver.UntypedNullAwareFlattenParameterType), new Func <TypeUsage, TypeUsage, bool>(SemanticResolver.UntypedNullAwareIsPromotableTo), new Func <TypeUsage, TypeUsage, bool>(SemanticResolver.UntypedNullAwareIsStructurallyEqual), isGroupAggregateFunction, out isAmbiguous));
}
private static bool TryRankFunctionParameters <TFunctionParameterMetadata>(
IList <TypeUsage> argumentList,
IList <TypeUsage> flatArgumentList,
IList <TFunctionParameterMetadata> overloadParamList,
Func <TFunctionParameterMetadata, TypeUsage> getParameterTypeUsage,
Func <TFunctionParameterMetadata, ParameterMode> getParameterMode,
Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> > flattenParameterType,
Func <TypeUsage, TypeUsage, bool> isPromotableTo,
Func <TypeUsage, TypeUsage, bool> isStructurallyEqual,
bool isGroupAggregateFunction,
out int totalRank,
out int[] parameterRanks)
{
totalRank = 0;
parameterRanks = (int[])null;
if (argumentList.Count != overloadParamList.Count)
{
return(false);
}
List <TypeUsage> typeUsageList = new List <TypeUsage>(flatArgumentList.Count);
for (int index = 0; index < overloadParamList.Count; ++index)
{
TypeUsage typeUsage = argumentList[index];
TypeUsage type = getParameterTypeUsage(overloadParamList[index]);
switch (getParameterMode(overloadParamList[index]))
{
case ParameterMode.In:
case ParameterMode.InOut:
if (isGroupAggregateFunction)
{
if (!TypeSemantics.IsCollectionType(type))
{
throw new EntitySqlException(Strings.InvalidArgumentTypeForAggregateFunction);
}
type = TypeHelpers.GetElementTypeUsage(type);
}
if (!isPromotableTo(typeUsage, type))
{
return(false);
}
typeUsageList.AddRange(flattenParameterType(type, typeUsage));
continue;
default:
return(false);
}
}
parameterRanks = new int[typeUsageList.Count];
for (int index = 0; index < parameterRanks.Length; ++index)
{
int promotionRank = FunctionOverloadResolver.GetPromotionRank(flatArgumentList[index], typeUsageList[index], isPromotableTo, isStructurallyEqual);
totalRank += promotionRank;
parameterRanks[index] = promotionRank;
}
return(true);
}
internal static EdmFunction ResolveFunctionOverloads(
IList <EdmFunction> functionsMetadata,
IList <TypeUsage> argTypes,
Func <TypeUsage, IEnumerable <TypeUsage> > flattenArgumentType,
Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> > flattenParameterType,
Func <TypeUsage, TypeUsage, bool> isPromotableTo,
Func <TypeUsage, TypeUsage, bool> isStructurallyEqual,
bool isGroupAggregateFunction,
out bool isAmbiguous)
{
return(FunctionOverloadResolver.ResolveFunctionOverloads <EdmFunction, FunctionParameter>(functionsMetadata, argTypes, (Func <EdmFunction, IList <FunctionParameter> >)(edmFunction => (IList <FunctionParameter>)edmFunction.Parameters), (Func <FunctionParameter, TypeUsage>)(functionParameter => functionParameter.TypeUsage), (Func <FunctionParameter, ParameterMode>)(functionParameter => functionParameter.Mode), flattenArgumentType, flattenParameterType, isPromotableTo, isStructurallyEqual, isGroupAggregateFunction, out isAmbiguous));
}
internal static TFunctionMetadata ResolveFunctionOverloads <TFunctionMetadata, TFunctionParameterMetadata>(
IList <TFunctionMetadata> functionsMetadata,
IList <TypeUsage> argTypes,
Func <TFunctionMetadata, IList <TFunctionParameterMetadata> > getSignatureParams,
Func <TFunctionParameterMetadata, TypeUsage> getParameterTypeUsage,
Func <TFunctionParameterMetadata, ParameterMode> getParameterMode,
bool isGroupAggregateFunction,
out bool isAmbiguous)
where TFunctionMetadata : class
{
return(FunctionOverloadResolver.ResolveFunctionOverloads <TFunctionMetadata, TFunctionParameterMetadata>(functionsMetadata, argTypes, getSignatureParams, getParameterTypeUsage, getParameterMode, new Func <TypeUsage, IEnumerable <TypeUsage> >(SemanticResolver.UntypedNullAwareFlattenArgumentType), new Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> >(SemanticResolver.UntypedNullAwareFlattenParameterType), new Func <TypeUsage, TypeUsage, bool>(SemanticResolver.UntypedNullAwareIsPromotableTo), new Func <TypeUsage, TypeUsage, bool>(SemanticResolver.UntypedNullAwareIsStructurallyEqual), isGroupAggregateFunction, out isAmbiguous));
}
internal static TFunctionMetadata ResolveFunctionOverloads <TFunctionMetadata, TFunctionParameterMetadata>(
IList <TFunctionMetadata> functionsMetadata,
IList <TypeUsage> argTypes,
Func <TFunctionMetadata, IList <TFunctionParameterMetadata> > getSignatureParams,
Func <TFunctionParameterMetadata, TypeUsage> getParameterTypeUsage,
Func <TFunctionParameterMetadata, ParameterMode> getParameterMode,
Func <TypeUsage, IEnumerable <TypeUsage> > flattenArgumentType,
Func <TypeUsage, TypeUsage, IEnumerable <TypeUsage> > flattenParameterType,
Func <TypeUsage, TypeUsage, bool> isPromotableTo,
Func <TypeUsage, TypeUsage, bool> isStructurallyEqual,
bool isGroupAggregateFunction,
out bool isAmbiguous)
where TFunctionMetadata : class
{
List <TypeUsage> typeUsageList = new List <TypeUsage>(argTypes.Count);
foreach (TypeUsage argType in (IEnumerable <TypeUsage>)argTypes)
{
typeUsageList.AddRange(flattenArgumentType(argType));
}
TFunctionMetadata functionMetadata = default(TFunctionMetadata);
isAmbiguous = false;
List <int[]> source = new List <int[]>(functionsMetadata.Count);
int[] bestCandidateRank = (int[])null;
int index1 = 0;
int num = int.MinValue;
for (; index1 < functionsMetadata.Count; ++index1)
{
int totalRank;
int[] parameterRanks;
if (FunctionOverloadResolver.TryRankFunctionParameters <TFunctionParameterMetadata>(argTypes, (IList <TypeUsage>)typeUsageList, getSignatureParams(functionsMetadata[index1]), getParameterTypeUsage, getParameterMode, flattenParameterType, isPromotableTo, isStructurallyEqual, isGroupAggregateFunction, out totalRank, out parameterRanks))
{
if (totalRank == num)
{
isAmbiguous = true;
}
else if (totalRank > num)
{
isAmbiguous = false;
num = totalRank;
functionMetadata = functionsMetadata[index1];
bestCandidateRank = parameterRanks;
}
source.Add(parameterRanks);
}
}
if ((object)functionMetadata != null && !isAmbiguous && (typeUsageList.Count > 1 && source.Count > 1))
{
isAmbiguous = source.Any <int[]>((Func <int[], bool>)(rank =>
{
if (!object.ReferenceEquals((object)bestCandidateRank, (object)rank))
{
for (int index2 = 0; index2 < rank.Length; ++index2)
{
if (bestCandidateRank[index2] < rank[index2])
{
return(true);
}
}
}
return(false);
}));
}
if (!isAmbiguous)
{
return(functionMetadata);
}
return(default(TFunctionMetadata));
}
