private static Pair <Type, T> ResolveFromLocal <T>(
string soughtName,
ClassProvidedCompileTimeRegistry locals,
Type annotationType,
string objectName,
Func <T, ISet <string> > namesProvider)
where T : Attribute
{
var foundLocal = new List <Pair <Type, T> >();
foreach (var entry in locals.Classes)
{
EPTypeHelper.TraverseAnnotations <T>(
entry.Value.ClassesMayNull,
(clazz, annotation) => {
var t = (T)annotation;
var names = namesProvider.Invoke(t);
foreach (var name in names)
{
if (soughtName.Equals(name))
{
foundLocal.Add(new Pair <Type, T>(clazz, t));
}
}
});
}
if (foundLocal.Count > 1)
{
throw GetDuplicateSingleRow(soughtName, objectName);
}
if (foundLocal.Count == 1)
{
return(foundLocal[0]);
}
return(null);
}
public void Add(IList<Type> classes)
{
this.classes.AddAll(classes);
try {
EPTypeHelper.TraverseAnnotations<ExtensionSingleRowFunctionAttribute>(
classes,
(
clazz,
annotation) => {
if (singleRowFunctionExtensions.IsEmpty()) {
singleRowFunctionExtensions = new Dictionary<string, Pair<Type, ExtensionSingleRowFunctionAttribute>>();
}
if (singleRowFunctionExtensions.ContainsKey(annotation.Name)) {
throw new EPException("The plug-in single-row function '" + annotation.Name + "' occurs multiple times");
}
singleRowFunctionExtensions.Put(annotation.Name, new Pair<Type, ExtensionSingleRowFunctionAttribute>(clazz, annotation));
});
EPTypeHelper.TraverseAnnotations<ExtensionAggregationFunctionAttribute>(
classes,
(
clazz,
annotation) => {
if (aggregationFunctionExtensions.IsEmpty()) {
aggregationFunctionExtensions = new Dictionary<string, Pair<Type, ExtensionAggregationFunctionAttribute>>();
}
if (aggregationFunctionExtensions.ContainsKey(annotation.Name)) {
throw new EPException("The plug-in aggregation function '" + annotation.Name + "' occurs multiple times");
}
aggregationFunctionExtensions.Put(annotation.Name, new Pair<Type, ExtensionAggregationFunctionAttribute>(clazz, annotation));
});
EPTypeHelper.TraverseAnnotations<ExtensionAggregationMultiFunctionAttribute>(
classes,
(
clazz,
annotation) => {
if (aggregationMultiFunctionExtensions.IsEmpty()) {
aggregationMultiFunctionExtensions = new Dictionary<string, Pair<Type, string[]>>();
}
var names = annotation.Names.Split(',');
var namesDeduplicated = new HashSet<string>();
foreach (var nameWithSpaces in names) {
var name = nameWithSpaces.Trim();
namesDeduplicated.Add(name);
}
var namesArray = namesDeduplicated.ToArray();
foreach (var name in namesDeduplicated) {
if (aggregationMultiFunctionExtensions.ContainsKey(name)) {
throw new EPException("The plug-in aggregation multi-function '" + name + "' occurs multiple times");
}
aggregationMultiFunctionExtensions.Put(name, new Pair<Type, string[]>(clazz, namesArray));
}
});
}
catch (EPException ex) {
throw new ExprValidationException(ex.Message, ex);
}
}
private static Pair <Type, T> ResolveFromPath <T>(
string soughtName,
PathRegistry <string, ClassProvided> path,
Type annotationType,
string objectName,
ICollection <string> moduleUses,
ModuleDependenciesCompileTime moduleDependencies,
Func <T, ISet <string> > namesProvider)
where T : Attribute
{
// TBD: Verify that annotationType is derived from T
if (!typeof(T).IsAssignableFrom(annotationType))
{
throw new ArgumentException("cannot assign annotationType from " + typeof(T).FullName);
}
IList <PathFunc <T> > foundPath = new List <PathFunc <T> >();
path.TraverseWithModule((moduleName, classProvided) => {
EPTypeHelper.TraverseAnnotations <T>(
classProvided.ClassesMayNull,
(
clazz,
annotation) => {
var t = annotation;
var names = namesProvider.Invoke(t);
foreach (var name in names)
{
if (soughtName.Equals(name))
{
foundPath.Add(new PathFunc <T>(moduleName, clazz, t));
}
}
});
});
PathFunc <T> foundPathFunc;
if (foundPath.IsEmpty())
{
return(null);
}
else if (foundPath.Count == 1)
{
foundPathFunc = foundPath[0];
}
else
{
if (moduleUses == null || moduleUses.IsEmpty())
{
throw GetDuplicateSingleRow(soughtName, objectName);
}
IList <PathFunc <T> > matchesUses = new List <PathFunc <T> >(2);
foreach (var func in foundPath)
{
if (moduleUses.Contains(func.OptionalModuleName))
{
matchesUses.Add(func);
}
}
if (matchesUses.Count > 1)
{
throw GetDuplicateSingleRow(soughtName, objectName);
}
if (matchesUses.IsEmpty())
{
return(null);
}
foundPathFunc = matchesUses[0];
}
moduleDependencies.AddPathClass(foundPathFunc.Clazz.FullName, foundPathFunc.OptionalModuleName);
return(new Pair <Type, T>(foundPathFunc.Clazz, foundPathFunc.Annotation));
}
