private Csw.V202.XPathQueryableNavigator GetNavigator(ExpressionBuilderParameters parameters) { if (_Navigator == null) { Csw.V202.XPathQueryableNavigator xptn = new Csw.V202.XPathQueryableNavigator(parameters.ElementType); XPathNodeIterator xpni = xptn.Select(_Identifier.Symbol, parameters.NamespaceResolver, true); while (xpni.MoveNext()) { _Navigator = xpni.Current as Csw.V202.XPathQueryableNavigator; } Debug.Assert(_Navigator != null); if (_Navigator == null) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, SR.InvalidPropertyNameExpressionException, _Identifier.Symbol ) ); } } return(_Navigator); }
private XPathTypeNavigator GetNavigator(ExpressionBuilderParameters parameters) { if (_Navigator == null) { XPathTypeNavigator xptn = parameters.CreateNavigator(); XPathNodeIterator xpni = xptn.Select(Untyped.Value, parameters.NamespaceResolver, true); while (xpni.MoveNext()) { _Navigator = xpni.Current as XPathTypeNavigator; } Debug.Assert(_Navigator != null); if (_Navigator == null) { throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, SR.InvalidPropertyNameExpressionException, Untyped.Value ) ); } } return(_Navigator); }
internal LambdaExpression CreateLambda(IQueryable source, XmlNamespaceManager namespaceManager, bool mayRootPathBeImplied, IOperatorImplementationProvider operatorImplementationProvider, Func<Type, IXmlNamespaceResolver, XPathTypeNavigator> navigatorCreator=null) { Expression body=null; ParameterExpression[] parameters=new ParameterExpression[] { Expression.Parameter(source.ElementType) }; if (Untyped.Elements().Any()) { var ebp=new ExpressionBuilderParameters(parameters, source.Provider, source.ElementType, namespaceManager, mayRootPathBeImplied, operatorImplementationProvider, navigatorCreator); Type st=typeof(bool); if (logicOps!=null) body=logicOps.CreateExpression(ebp, st, null); else if (comparisonOps!=null) body=comparisonOps.CreateExpression(ebp, st, null); else if (spatialOps!=null) body=spatialOps.CreateExpression(ebp, st, null); } else if (string.IsNullOrWhiteSpace(Untyped.Value)) body=Expression.Constant(true, typeof(bool)); if (body==null) throw new ArgumentException( string.Format( CultureInfo.InvariantCulture, SR.InvalidFilterDefinitionException, Untyped.Value ) ); return Expression.Lambda(body, parameters); }
protected IEnumerable <Type> GetSubTypes(ExpressionBuilderParameters parameters) { using (IEnumerator <IExpressionBuilder> children = GetEnumerator()) while (children.MoveNext()) { yield return(children.Current.GetExpressionStaticType(parameters)); } }
private Expression CreateStandardExpression(Expression subexpr, ExpressionBuilderParameters parameters, Type subType) { return(Expression.MakeUnary( _FilterElement.OperatorExpressionType, subexpr, null )); }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { if (Value != null) { return(Value.GetType()); } return(typeof(object)); }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func<Expression, ParameterExpression, Expression> operatorCreator) { // We only want literals in this case if (operatorCreator==null) return null; return GetNavigator(parameters) .CreateExpression(parameters.Parameters[0], expectedStaticType, operatorCreator); }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { if (_OptionalNot != null) { return(GetExpressionCreator().CreateExpression(parameters)); } else { return(((IExpressionBuilder)_Primary).CreateExpression(parameters, expectedStaticType, null)); } }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { Expression ret = Expression.Constant(GetValue(_Node, parameters), GetExpressionStaticType(parameters)); if (operatorCreator != null) { ret = operatorCreator(ret, null); } return(ret); }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { // We only want literals in this case if (operatorCreator == null) { return(null); } return(GetNavigator(parameters) .CreateExpression(parameters.Parameters[0], expectedStaticType, operatorCreator)); }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func<Expression, ParameterExpression, Expression> operatorCreator) { if (!_Result.HasValue) { Csw.V202.XPathQueryableNavigator xptn=new Csw.V202.XPathQueryableNavigator(parameters.ElementType); XPathNodeIterator xpni=xptn.Select(_AttributeName.Identifier.Symbol, parameters.NamespaceResolver, true); _Result=xpni.MoveNext(); if (_Negated) _Result=!_Result; } return Expression.Constant(_Result.Value, typeof(bool)); }
public Expression CreateExpression(ExpressionBuilderParameters parameters) { using (IEnumerator <IExpressionBuilder> children = GetEnumerator()) if (children.MoveNext() && (children.Current != null)) { return(CreateStandardExpression( children.Current.CreateExpression(parameters, children.Current.GetExpressionStaticType(parameters), null), parameters, _FilterElement.GetExpressionStaticType(parameters) )); } return(null); }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { if (!_Result.HasValue) { Csw.V202.XPathQueryableNavigator xptn = new Csw.V202.XPathQueryableNavigator(parameters.ElementType); XPathNodeIterator xpni = xptn.Select(_AttributeName.Identifier.Symbol, parameters.NamespaceResolver, true); _Result = xpni.MoveNext(); if (_Negated) { _Result = !_Result; } } return(Expression.Constant(_Result.Value, typeof(bool))); }
protected IEnumerable <object> GetConstants(ExpressionBuilderParameters parameters) { using (IEnumerator <IExpressionBuilder> children = GetEnumerator()) while (children.MoveNext()) { object ret = null; Expression exp = children.Current.CreateExpression(parameters, null, null); if ((exp != null) && (exp.NodeType == LinqExpressionType.Constant)) { ret = ((ConstantExpression)exp).Value; } yield return(ret); } }
public Expression CreateExpression(ExpressionBuilderParameters parameters) { Expression ret=null; foreach (IExpressionCreator c in _Creators) if (ret!=null) ret=Expression.MakeBinary( _Combinator, ret, c.CreateExpression(parameters) ); else ret=c.CreateExpression(parameters); return ret; }
internal LambdaExpression CreateLambda(IQueryable source, XmlNamespaceManager namespaceManager, bool mayRootPathBeImplied, IOperatorImplementationProvider operatorImplementationProvider, Func <Type, IXmlNamespaceResolver, XPathTypeNavigator> navigatorCreator = null) { Expression body = null; ParameterExpression[] parameters = new ParameterExpression[] { Expression.Parameter(source.ElementType) }; if (Untyped.Elements().Any()) { var ebp = new ExpressionBuilderParameters(parameters, source.Provider, source.ElementType, namespaceManager, mayRootPathBeImplied, operatorImplementationProvider, navigatorCreator); Type st = typeof(bool); if (logicOps != null) { body = logicOps.CreateExpression(ebp, st, null); } else if (comparisonOps != null) { body = comparisonOps.CreateExpression(ebp, st, null); } else if (spatialOps != null) { body = spatialOps.CreateExpression(ebp, st, null); } } else if (string.IsNullOrWhiteSpace(Untyped.Value)) { body = Expression.Constant(true, typeof(bool)); } if (body == null) { throw new ArgumentException( string.Format( CultureInfo.InvariantCulture, SR.InvalidFilterDefinitionException, Untyped.Value ) ); } return(Expression.Lambda(body, parameters)); }
public Expression CreateExpression(ExpressionBuilderParameters parameters) { Expression ret = null; foreach (IExpressionCreator c in _Creators) { if (ret != null) { ret = Expression.MakeBinary( _Combinator, ret, c.CreateExpression(parameters) ); } else { ret = c.CreateExpression(parameters); } } return(ret); }
private XPathTypeNavigator GetNavigator(ExpressionBuilderParameters parameters) { if (_Navigator==null) { XPathTypeNavigator xptn=parameters.CreateNavigator(); XPathNodeIterator xpni=xptn.Select(Untyped.Value, parameters.NamespaceResolver, true); while (xpni.MoveNext()) _Navigator=xpni.Current as XPathTypeNavigator; Debug.Assert(_Navigator!=null); if (_Navigator==null) throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, SR.InvalidPropertyNameExpressionException, Untyped.Value ) ); } return _Navigator; }
private Csw.V202.XPathQueryableNavigator GetNavigator(ExpressionBuilderParameters parameters) { if (_Navigator==null) { Csw.V202.XPathQueryableNavigator xptn=new Csw.V202.XPathQueryableNavigator(parameters.ElementType); XPathNodeIterator xpni=xptn.Select(_Identifier.Symbol, parameters.NamespaceResolver, true); while (xpni.MoveNext()) _Navigator=xpni.Current as Csw.V202.XPathQueryableNavigator; Debug.Assert(_Navigator!=null); if (_Navigator==null) throw new InvalidOperationException( string.Format( CultureInfo.CurrentCulture, SR.InvalidPropertyNameExpressionException, _Identifier.Symbol ) ); } return _Navigator; }
internal protected virtual Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { var bop = this as IBinaryOperator; if (bop != null) { Type[] subtypes = bop.expression .Select <expression, Type>(e => ((IExpressionBuilder)e).GetExpressionStaticType(parameters)) .Where <Type>(t => t != null) .ToArray <Type>(); if (subtypes.Length == 0) { return(null); } //TODO: probably needs more checking on other subtypes there... return(subtypes[0]); } return(null); }
private Expression CustomCallback(IEnumerator <IExpressionBuilder> children, LinkedList <Expression> subexpr, IEnumerator types, IEnumerator vals, Expression basexp, ParameterExpression pexp, MethodInfo method, object instance, ExpressionBuilderParameters parameters) { Expression ret = basexp; if (pexp != null) { Expression sub = null; bool hasNext = vals.MoveNext() && types.MoveNext(); if (hasNext) { children.MoveNext(); if (vals.Current == null) { sub = children.Current.CreateExpression(parameters, (Type)types.Current, (e, p) => CustomCallback(children, subexpr, types, vals, e, p, method, instance, parameters)); } else { sub = CustomCallback(children, subexpr, types, vals, Expression.Constant(vals.Current, (Type)types.Current), null, method, instance, parameters); } } else { sub = subexpr.Last.Value; subexpr.RemoveLast(); } ret = CreateCustomExpression(method, instance, new Expression[] { ret, sub }, parameters, (Type)types.Current); if (!hasNext) { subexpr.AddLast(ret); } } return(ret); }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { return GetNavigator(parameters).Type; }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { // Cannot decide at this time return null; }
public Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { return GetNavigator(parameters).Type; }
public Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { return(GetExpressionCreator().CreateExpression(parameters)); }
protected override Expression CreateStandardExpression(IEnumerable <Expression> subexpr, ExpressionBuilderParameters parameters, Type subType) { throw new NotSupportedException("Only custom implementations are supported"); }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { // Cannot decide at this time return(null); }
internal protected override Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func<Expression, ParameterExpression, Expression> operatorCreator) { Expression ret=null; if (expectedStaticType!=null) { object value=Untyped.Value; // Convert the string to the expectedStaticType switch (Type.GetTypeCode(expectedStaticType)) { case TypeCode.Boolean: value=XmlConvert.ToBoolean(Untyped.Value); break; case TypeCode.Byte: value=XmlConvert.ToByte(Untyped.Value); break; case TypeCode.Char: value=XmlConvert.ToChar(Untyped.Value); break; case TypeCode.DateTime: value=XmlConvert.ToDateTime(Untyped.Value, XmlDateTimeSerializationMode.RoundtripKind); break; case TypeCode.Decimal: value=XmlConvert.ToDecimal(Untyped.Value); break; case TypeCode.Double: value=XmlConvert.ToDouble(Untyped.Value); break; case TypeCode.Int16: value=XmlConvert.ToInt16(Untyped.Value); break; case TypeCode.Int32: value=XmlConvert.ToInt32(Untyped.Value); break; case TypeCode.Int64: value=XmlConvert.ToInt64(Untyped.Value); break; case TypeCode.SByte: value=XmlConvert.ToSByte(Untyped.Value); break; case TypeCode.Single: value=XmlConvert.ToSingle(Untyped.Value); break; case TypeCode.String: // We are already there break; case TypeCode.UInt16: value=XmlConvert.ToUInt16(Untyped.Value); break; case TypeCode.UInt32: value=XmlConvert.ToUInt32(Untyped.Value); break; case TypeCode.UInt64: value=XmlConvert.ToUInt64(Untyped.Value); break; default: if (expectedStaticType==typeof(DateTimeOffset)) { value=XmlConvert.ToDateTimeOffset(Untyped.Value); } else // Last resort conversion value=Convert.ChangeType(Untyped.Value, expectedStaticType, CultureInfo.InvariantCulture); break; } ret=Expression.Constant(value, expectedStaticType); } if (ret==null) { Logger.Info(m => m("The literal \"{0}\" will be interpreted as a string by default", Untyped.Value)); ret=Expression.Constant(Untyped.Value); } if (operatorCreator!=null) return operatorCreator(ret, null); return ret; }
protected abstract T GetValue(ParseTreeNode treeNode, ExpressionBuilderParameters parameters);
protected override Expression CreateCustomExpression(MethodInfo method, object instance, IEnumerable <Expression> subexpr, ExpressionBuilderParameters parameters, Type subType) { Expression op = base.CreateCustomExpression(method, instance, subexpr, parameters, subType); Type rt = Nullable.GetUnderlyingType(method.ReturnType) ?? method.ReturnType; return(Expression.MakeBinary( Node._OperatorExpression, op, Expression.Constant(Convert.ChangeType(Node._Tolerance.Value, rt, CultureInfo.InvariantCulture), method.ReturnType) )); }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { return(base.GetExpressionStaticType(parameters) ?? typeof(decimal)); }
Type IExpressionBuilder.GetExpressionStaticType(ExpressionBuilderParameters parameters) { return typeof(bool); }
private Expression StandardCallback(IEnumerator <IExpressionBuilder> children, LinkedList <Expression> subexpr, Expression basexp, ParameterExpression pexp, ExpressionBuilderParameters parameters, Type expectedStaticType) { Expression ret = basexp; if (pexp != null) { Expression sub = null; bool hasNext = children.MoveNext(); if (hasNext) { sub = children.Current.CreateExpression(parameters, expectedStaticType, (e, p) => StandardCallback(children, subexpr, e, p, parameters, expectedStaticType)); } else { sub = subexpr.Last.Value; subexpr.RemoveLast(); } ret = CreateStandardExpression(new Expression[] { ret, sub }, parameters, expectedStaticType); if (!hasNext) { subexpr.AddLast(ret); } } return(ret); }
internal protected virtual Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { return(typeof(T)); }
public virtual Expression CreateExpression(ExpressionBuilderParameters parameters) { Expression ret = null; List <Type> subTypes = GetSubTypes(parameters).ToList <Type>(); Type subtype = subTypes.FirstOrDefault <Type>(t => t != null); subTypes = subTypes.Select <Type, Type>(t => t == null ? subtype : t).ToList <Type>(); // Custom implementation if (parameters.OperatorImplementationProvider != null) { List <object> paramValues = GetConstants(parameters).ToList <object>(); string opname = GetCustomImplementationName(subTypes, paramValues); Type[] types = subTypes.ToArray(); object[] values = paramValues.ToArray(); object instance; MethodInfo method = parameters.OperatorImplementationProvider.GetImplementation(opname, ref types, ref values, out instance); if (method != null) { Debug.Assert(types.Length == values.Length); using (IEnumerator <IExpressionBuilder> children = GetEnumerator()) { IEnumerator v = values.GetEnumerator(); IEnumerator t = types.GetEnumerator(); LinkedList <Expression> subexpr = new LinkedList <Expression>(); while (v.MoveNext() && t.MoveNext()) { children.MoveNext(); if (v.Current == null) { subexpr.AddLast( children.Current.CreateExpression(parameters, (Type)t.Current, (e, p) => CustomCallback(children, subexpr, t, v, e, p, method, instance, parameters)) ); } else { subexpr.AddLast(Expression.Constant(v.Current, (Type)t.Current)); } } if (subexpr.First != subexpr.Last) { ret = CreateCustomExpression(method, instance, subexpr, parameters, subtype); } else { ret = subexpr.First.Value; } } } } // Standard implementation if (ret == null) { using (IEnumerator <IExpressionBuilder> children = GetEnumerator()) { LinkedList <Expression> subexpr = new LinkedList <Expression>(); while (children.MoveNext()) { subexpr.AddLast( children.Current.CreateExpression(parameters, subtype, (e, p) => StandardCallback(children, subexpr, e, p, parameters, subtype)) ); } if (subexpr.First != subexpr.Last) { ret = CreateStandardExpression(subexpr, parameters, subtype); } else { ret = subexpr.First.Value; } } } return(ret); }
Type IExpressionBuilder.GetExpressionStaticType(ExpressionBuilderParameters parameters) { return(GetExpressionStaticType(parameters)); }
internal protected override Expression CreateExpression(ExpressionBuilderParameters parameters, Type expectedStaticType, Func <Expression, ParameterExpression, Expression> operatorCreator) { Expression ret = null; if (expectedStaticType != null) { object value = Untyped.Value; // Convert the string to the expectedStaticType switch (Type.GetTypeCode(expectedStaticType)) { case TypeCode.Boolean: value = XmlConvert.ToBoolean(Untyped.Value); break; case TypeCode.Byte: value = XmlConvert.ToByte(Untyped.Value); break; case TypeCode.Char: value = XmlConvert.ToChar(Untyped.Value); break; case TypeCode.DateTime: value = XmlConvert.ToDateTime(Untyped.Value, XmlDateTimeSerializationMode.RoundtripKind); break; case TypeCode.Decimal: value = XmlConvert.ToDecimal(Untyped.Value); break; case TypeCode.Double: value = XmlConvert.ToDouble(Untyped.Value); break; case TypeCode.Int16: value = XmlConvert.ToInt16(Untyped.Value); break; case TypeCode.Int32: value = XmlConvert.ToInt32(Untyped.Value); break; case TypeCode.Int64: value = XmlConvert.ToInt64(Untyped.Value); break; case TypeCode.SByte: value = XmlConvert.ToSByte(Untyped.Value); break; case TypeCode.Single: value = XmlConvert.ToSingle(Untyped.Value); break; case TypeCode.String: // We are already there break; case TypeCode.UInt16: value = XmlConvert.ToUInt16(Untyped.Value); break; case TypeCode.UInt32: value = XmlConvert.ToUInt32(Untyped.Value); break; case TypeCode.UInt64: value = XmlConvert.ToUInt64(Untyped.Value); break; default: if (expectedStaticType == typeof(DateTimeOffset)) { value = XmlConvert.ToDateTimeOffset(Untyped.Value); } else { // Last resort conversion value = Convert.ChangeType(Untyped.Value, expectedStaticType, CultureInfo.InvariantCulture); } break; } ret = Expression.Constant(value, expectedStaticType); } if (ret == null) { Logger.Info(m => m("The literal \"{0}\" will be interpreted as a string by default", Untyped.Value)); ret = Expression.Constant(Untyped.Value); } if (operatorCreator != null) { return(operatorCreator(ret, null)); } return(ret); }
protected abstract Expression CreateStandardExpression(IEnumerable <Expression> subexpr, ExpressionBuilderParameters parameters, Type subType);
protected override Expression CreateCustomExpression(MethodInfo method, object instance, IEnumerable <Expression> subexpr, ExpressionBuilderParameters parameters, Type subType) { Expression op = base.CreateCustomExpression(method, instance, subexpr, parameters, subType); Type rt = Nullable.GetUnderlyingType(method.ReturnType) ?? method.ReturnType; if (method.ReturnType == typeof(bool)) { return(op); } else { return(Expression.Equal( op, Expression.Constant(Convert.ChangeType(true, rt, CultureInfo.InvariantCulture), method.ReturnType) )); } }
protected virtual Expression CreateCustomExpression(MethodInfo method, object instance, IEnumerable <Expression> subexpr, ExpressionBuilderParameters parameters, Type subType) { Expression op = null; if (instance != null) { op = Expression.Call( Expression.Constant(instance), method, subexpr ); } else { op = Expression.Call( method, subexpr ); } return(op); }
Type IExpressionBuilder.GetExpressionStaticType(ExpressionBuilderParameters parameters) { return(typeof(bool)); }
internal protected override Type GetExpressionStaticType(ExpressionBuilderParameters parameters) { return base.GetExpressionStaticType(parameters) ?? typeof(decimal); }