public static IEnumerable <string> GetNameVariations([NotNull] FunctionOverride functionOverride)
{
if (functionOverride.NameType == OverrideNameType.EntryPoint)
{
return(new[] { functionOverride.BaseName });
}
var extensionTrimmer = new OpenGLFunctionExtensionTrimmer();
var dataTypeTrimmer = new OpenGLFunctionDataTypeTrimmer();
var variations = new List <string>();
var currentVariation = functionOverride.BaseName;
variations.Add(currentVariation);
if (OpenGLFunctionExtensionTrimmer.IsRelevant(functionOverride))
{
currentVariation = extensionTrimmer.Trim(functionOverride);
variations.Add(currentVariation);
}
if (dataTypeTrimmer.IsRelevant(currentVariation))
{
variations.Add(dataTypeTrimmer.Trim(currentVariation));
}
return(variations.Distinct().OrderByDescending(v => v.Length));
}
private static FunctionSignature CreateOverriddenFunction
(
[NotNull] FunctionSignature functionBase,
[NotNull] FunctionOverride functionOverride
)
{
var newVersion = functionOverride.NewVersion ?? functionBase.IntroducedIn;
var newReturnType = functionOverride.NewReturnType ?? functionBase.ReturnType;
var newParameters = CreateOverriddenParameters(functionBase, functionOverride);
var newDeprecationReason = functionOverride.ObsoletionReason ?? functionBase.DeprecationReason;
return(new FunctionSignature
(
functionBase.Name,
functionBase.NativeEntrypoint,
functionBase.Categories,
functionBase.Extension,
newVersion,
newReturnType,
newParameters,
functionBase.DeprecatedIn,
newDeprecationReason
));
}
private static IReadOnlyList <ParameterSignature> CreateOverriddenParameters
(
[NotNull] FunctionSignature functionBase,
[NotNull] FunctionOverride functionOverride
)
{
var baseParameters = functionBase.Parameters;
var parametersWithComputedCounts =
new List <(ParameterSignature Parameter, IReadOnlyList <string> ComputedCountParameterNames)>();
var parametersWithValueReferenceCounts =
new List <(ParameterSignature Parameter, string ParameterReferenceName)>();
var resultParameters = new List <ParameterSignature>(baseParameters);
foreach (var overrideParameter in functionOverride.ParameterOverrides)
{
var baseParameter = functionBase.Parameters.FirstOrDefault(p => p.Name == overrideParameter.BaseName);
if (baseParameter is null)
{
throw new InvalidDataException
(
$"Could not find target parameter with name \"{overrideParameter.BaseName}\" to override."
);
}
var overriddenParameter = CreateOverriddenParameter
(
baseParameter,
overrideParameter,
out var hasComputedCount,
out var computedCountParameterNames,
out var hasValueReference,
out var valueReferenceName,
out var valueReferenceExpression
);
if (hasComputedCount)
{
parametersWithComputedCounts.Add((overriddenParameter, computedCountParameterNames));
}
if (hasValueReference)
{
parametersWithValueReferenceCounts.Add((overriddenParameter, valueReferenceName));
// TODO: Pass on the mathematical expression
}
var baseIndex = resultParameters.IndexOf(baseParameter);
resultParameters[baseIndex] = overriddenParameter;
}
ParsingHelpers.ResolveComputedCountSignatures(resultParameters, parametersWithComputedCounts);
ParsingHelpers.ResolveReferenceCountSignatures(resultParameters, parametersWithValueReferenceCounts);
return(resultParameters);
}
private static IEnumerable <FunctionSignature> FindBaseFunctions
(
[NotNull, ItemNotNull] IReadOnlyCollection <FunctionSignature> existingFunctions,
[NotNull] FunctionOverride functionOverride
)
{
// First, build the list of candidate names
var variations = Utilities.GetNameVariations(functionOverride).ToList();
foreach (var variation in variations)
{
var baseFunctionCandidates = existingFunctions.Where
(
f =>
(f.Name == variation || f.NativeEntrypoint == variation) &&
f.Extension == functionOverride.BaseExtension
).ToList();
if (!baseFunctionCandidates.Any())
{
baseFunctionCandidates = existingFunctions
.Where
(
f => f.Name == variation || f.NativeEntrypoint == variation
).ToList();
}
baseFunctionCandidates = baseFunctionCandidates.Where
(
f => functionOverride.ParameterOverrides.All(po => f.Parameters.Any(p => p.Name == po.BaseName))
).ToList();
// If we have a set of candidates at this point, we've found the most specific set of functions that are
// applicable.
if (baseFunctionCandidates.Any())
{
return(baseFunctionCandidates);
}
}
// If we've reached this point, we couldn't find any targets. Let's gather as much information for the end
// developer as possible.
foreach (var variation in variations)
{
var noFunctionsWithThatName = existingFunctions.All(f => f.Name != variation);
if (noFunctionsWithThatName)
{
throw new InvalidDataException
(
$"No base function found for the override with the name \"{functionOverride.BaseName}\" when " +
$"considering the variation \"{variation}\". " +
"Specify another name."
);
}
var parameterNames = new List <string>();
var functionsWithThatName = existingFunctions.Where(f => f.Name == variation).ToList();
foreach (var functionWithThatName in functionsWithThatName)
{
var parameterNamesNotFound = functionOverride.ParameterOverrides
.Where
(
po => functionWithThatName.Parameters.All(p => p.Name != po.BaseName)
).Select(po => po.BaseName);
parameterNames.AddRange(parameterNamesNotFound);
}
if (parameterNames.Any())
{
throw new InvalidDataException
(
$"No base function found for the override with the name \"{functionOverride.BaseName}\" when " +
$"considering the variation \"{variation}\" that had the following parameters: " +
$"({string.Join(", ", parameterNames.ToArray())})" +
"Specify other parameter names."
);
}
}
throw new InvalidDataException("No base function found for override.");
}
