/// <summary>
/// Checks if all filters are compatible with the function and also supported.
/// </summary>
/// <param name="function"></param>
/// <param name="filters"></param>
private static void ValidateFilters(IFunction function, IVariableFilter[] filters)
{
//TODO: get some use for it..does little or nothing now.. and move up to function
var argumentFiltered = new bool[function.Arguments.Count];
var componentFiltered = new bool[function.Components.Count];
for (int i = 0; i < filters.Length; i++)
{
IVariableFilter filter = filters[i];
int argumentIndex = function.Arguments.IndexOf(filter.Variable);
int componentIndex = function.Components.IndexOf(filter.Variable);
if (argumentIndex >= 0 && argumentFiltered[argumentIndex])
{
// throw new NotSupportedException("Only one filter per argument can be specified for now");
}
if (componentIndex >= 0 && componentFiltered[componentIndex])
{
// throw new NotSupportedException("Only one filter per component can be specified for now");
}
if (argumentIndex >= 0)
{
argumentFiltered[argumentIndex] = true;
}
if (componentIndex >= 0)
{
componentFiltered[componentIndex] = true;
}
}
}
public virtual IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return((IVariableFilter)Clone());
}
if (filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("filter", "Filters are incompatible");
}
if (!(filter is VariableValueFilter <T>))
{
throw new NotImplementedException("Currently only filter of the same type can be intersected");
}
var f = (VariableValueFilter <T>)filter;
IList <T> newValues = new List <T>();
foreach (var value in values)
{
if (f.Values.Contains(value))
{
newValues.Add(value);
}
}
return(new VariableValueFilter <T>(variable, newValues));
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return((IVariableFilter)Clone());
}
throw new NotImplementedException();
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return (IVariableFilter) Clone();
}
throw new NotImplementedException();
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter != null && filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("Filters are incompatible");
}
return(new ComponentFilter(variable));
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter != null && filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("Filters are incompatible");
}
return new ComponentFilter(variable);
}
public static IVariableFilter Intersect(this IEnumerable <IVariableFilter> filters)
{
IVariableFilter intersectedFilter = null;
foreach (var filter in filters)
{
intersectedFilter = filter.Intersect(intersectedFilter);
}
return(intersectedFilter);
}
public VariableFiltersBuilder <T> WithFilter(IVariableFilter <T> filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
_filters.Add(filter);
return(this);
}
public VariableInfo WithFilter(IVariableFilter filter)
{
if (filter == null)
{
throw new ArgumentNullException(nameof(filter));
}
(_filters ?? (_filters = new List <IVariableFilter>())).Add(filter);
return(this);
}
protected virtual IVariableFilter[] CreateArgumentFilters(object[] argumentValues)
{
if (argumentValues.Length > Arguments.Count)
{
throw new ArgumentOutOfRangeException("argumentValues",
"Number of argument values is greater than number of arguments");
}
var filters = new IVariableFilter[argumentValues.Length];
for (int i = 0; i < argumentValues.Length; i++)
{
filters[i] = Arguments[i].CreateValueFilter(argumentValues[i]);
}
return(filters);
}
public static IVariableFilter Intersect(this IEnumerable <IVariableFilter> filters)
{
var filterList = filters.ToList();
if (filterList.Count == 1)
{
return(filterList[0]);
}
IVariableFilter intersectedFilter = null;
foreach (var filter in filterList)
{
intersectedFilter = filter.Intersect(intersectedFilter);
}
return(intersectedFilter);
}
private int[] GetArgumentIndexes(IVariableFilter variableFilter)
{
int[] indexes;
if (variableFilter is IVariableValueFilter)
{
indexes = GetVariableValueFilterIndexes((IVariableValueFilter)variableFilter).ToArray();
}
else if (variableFilter is VariableIndexRangeFilter)
{
indexes = GetVariableIndexRangesFilterIndexes((VariableIndexRangeFilter)variableFilter);
}
else
{
indexes = GetVariableIndexRangesFilterIndexes((VariableIndexRangesFilter)variableFilter);
}
return(indexes);
}
/// <summary>
/// Combines compatible filters.
/// </summary>
/// <param name="allFilters"></param>
/// <returns></returns>
private List <IVariableFilter> CombineCompatibleFilters(IEnumerable <IVariableFilter> allFilters)
{
var uniqueFilters = new List <IVariableFilter>();
foreach (var filter in allFilters)
{
IVariableFilter f2 = filter;
if (!uniqueFilters.Any(f => f.GetType() == f2.GetType() && f.Variable == f2.Variable))
// check if it is not added already
{
//for every type of filter and for every variable we only need one filter.
var compatibleFilters =
allFilters.Where(f => f.GetType() == f2.GetType() && f.Variable == f2.Variable);
uniqueFilters.Add(compatibleFilters.Intersect());
}
}
return(uniqueFilters);
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return(this);
}
if (filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("Filters are incompatible");
}
if (!(filter is VariableReduceFilter))
{
throw new NotImplementedException("Currently only filter of the same type can be intersected");
}
//two reduce filters are equal to one. No need to reduce double
return(this);
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return this;
}
if (filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("Filters are incompatible");
}
if (!(filter is VariableReduceFilter))
{
throw new NotImplementedException("Currently only filter of the same type can be intersected");
}
//two reduce filters are equal to one. No need to reduce double
return this;
}
public IVariableFilter Intersect(IVariableFilter filter)
{
if (filter == null)
{
return((IVariableFilter)Clone());
}
if (filter.Variable != variable)
{
throw new ArgumentOutOfRangeException("filter", "Filters are incompatible");
}
if (!(filter is VariableIndexRangeFilter))
{
throw new NotImplementedException("Currently only filter of the same type can be intersected");
}
VariableIndexRangeFilter f = (VariableIndexRangeFilter)filter;
//Create that a range that both filters cover. Could result in minIndex > maxIndex
return(new VariableIndexRangeFilter(variable, Math.Max(f.minIndex, minIndex), Math.Min(f.maxIndex, maxIndex)));
}
public static VariableFiltersBuilder <T> WithInvertedFilter <T>(this VariableFiltersBuilder <T> @this, IVariableFilter <T> filter)
{
return(@this.WithFilter(new InvertFilter <T>(filter)));
}
public InvertFilter(IVariableFilter filter)
{
_filter = filter ?? throw new ArgumentNullException(nameof(filter));
}
public static VariableInfo WithInvertedFilter(this VariableInfo @this, IVariableFilter filter)
{
return(@this.WithFilter(new InvertFilter(filter)));
}
