Ejemplo n.º 1
0
 public static FilterProperty Parse(string text)
 {
     using (var properties = text.Split('.').Cast <string>().GetEnumerator())
     {
         properties.MoveNext();
         var property = new FilterProperty(properties.Current);
         while (properties.MoveNext())
         {
             property = new FilterProperty(properties.Current, property);
         }
         return(property);
     }
 }
Ejemplo n.º 2
0
        private MemberExpression GetProperty(FilterProperty property)
        {
            Expression expression = Parameter;
            var        type       = Type;

            foreach (var name in property.GetProperties().Select(info => info.Name))
            {
                var info = type.GetTypeInfo().GetProperty(name);
                if (info == null)
                {
                    throw new InvalidOperationException($"Couldn't determine path '{name}' from type '${type.Name}'.");
                }
                expression = Expression.Property(expression, info);
                type       = info.PropertyType;
            }

            return(expression as MemberExpression);
        }
Ejemplo n.º 3
0
        private FilterExpressionBuilder <T> Contains(MethodInfo method, FilterProperty property, FilterValue value)
        {
            var member     = GetProperty(property);
            var collection = member.Type.Name == typeof(ICollection <>).Name
                ? member.Type
                : member.Type.GetTypeInfo().GetInterface(typeof(ICollection <>).Name);

            if (collection == null)
            {
                throw new InvalidOperationException($"Property '{property}' does not implement '{typeof(ICollection<>)}'.");
            }
            var type     = collection.GetTypeInfo().GetGenericArguments().Single();
            var item     = Expression.Parameter(type);
            var contains = Expression.Lambda(Expression.Call(null, FilterInfo.Contains.MakeGenericMethod(type), member, item), item);
            var call     = Expression.Call(null, method.MakeGenericMethod(type), GetVectorValue(value, type), contains);

            _expressions.Push(call);
            return(this);
        }
Ejemplo n.º 4
0
        public static Filter Parse(string text)
        {
            var or = Or.Match(text);

            if (or.Success)
            {
                return(new LogicalFilter
                       (
                           Parse(or.Groups["Left"].Value),
                           LogicalOperator.Or,
                           Parse(or.Groups["Right"].Value)
                       ));
            }
            var and = And.Match(text);

            if (and.Success)
            {
                return(new LogicalFilter
                       (
                           Parse(and.Groups["Left"].Value),
                           LogicalOperator.And,
                           Parse(and.Groups["Right"].Value)
                       ));
            }
            var predicate = Predicate.Match(text);

            if (predicate.Success)
            {
                return(new PredicateFilter
                       (
                           FilterProperty.Parse(predicate.Groups["Property"].Value),
                           PredicateOperator.Parse(predicate.Groups["Predicate"].Value),
                           FilterValue.Parse(predicate.Groups["Value"].Value)
                       ));
            }
            throw new ArgumentException($"Couldn't parse filter '{text}'.");
        }
Ejemplo n.º 5
0
 public void NotEqual(FilterProperty property, FilterValue value) =>
 _filter.Append($"{property}{PredicateOperatorString.NotEqual}{value}");
Ejemplo n.º 6
0
 public void LessThan(FilterProperty property, FilterValue value) =>
 _filter.Append($"{property}{PredicateOperatorString.LessThan}{value}");
Ejemplo n.º 7
0
 public void Equal(FilterProperty left, FilterValue value) =>
 _filter.Append($"{left}{PredicateOperatorString.Equal}{value}");
Ejemplo n.º 8
0
 public void Any(FilterProperty property, FilterValue value) =>
 _filter.Append($"{property}{PredicateOperatorString.Contains}{value}");
Ejemplo n.º 9
0
 public FilterExpressionBuilder <T> NotEqual(FilterProperty property, FilterValue value) =>
 Predicate(Expression.NotEqual, property, value, () => Expression.Constant(true));
Ejemplo n.º 10
0
 public FilterExpressionBuilder <T> LessThanOrEqual(FilterProperty property, FilterValue value) =>
 Predicate(Expression.LessThanOrEqual, property, value);
Ejemplo n.º 11
0
 public FilterExpressionBuilder <T> GreaterThan(FilterProperty property, FilterValue value) =>
 Predicate(Expression.GreaterThan, property, value);
Ejemplo n.º 12
0
 public FilterExpressionBuilder <T> Any(FilterProperty property, FilterValue value) =>
 Contains(FilterInfo.Any, property, value);
Ejemplo n.º 13
0
 private FilterExpressionBuilder <T> Predicate(Func <Expression, Expression, Expression> factory, FilterProperty property, FilterValue value, Func <Expression> fallback = null) =>
 Predicate(factory, GetProperty(property), value, fallback);
Ejemplo n.º 14
0
 public PredicateFilter(FilterProperty property, PredicateOperator predicate, FilterValue value)
 {
     Property  = property;
     Predicate = predicate;
     Value     = value;
 }
Ejemplo n.º 15
0
 public FilterProperty(string name, FilterProperty caller = null)
 {
     Name   = name;
     Caller = caller;
 }