internal static TypeEqual TypeEqual(TypeBinaryExpression expression) { return new TypeEqual() { Expression = Serialize(expression.Expression), TypeOperand = TypeRef.Serialize(expression.TypeOperand), }.Apply(n => n.Type = TypeRef.Serialize(expression.Type)); }
/// <summary> /// Constructor with an <see cref="TypeBinaryExpression"/> and an <see cref="ExpressionConverter"/>. /// </summary> /// <param name="expression">The original, not serializable <see cref="Expression"/>.</param> /// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param> public SerializableTypeBinaryExpression(TypeBinaryExpression expression, ExpressionConverter expConverter) : base(expression, expConverter) { Expression = expression.Expression.MakeSerializable(expConverter); #if !NETFX_CORE TypeOperand = InterLinqTypeSystem.Instance.GetInterLinqVersionOf<InterLinqType>(expression.TypeOperand); #else TypeOperand = InterLinqTypeSystem.Instance.GetInterLinqVersionOf<InterLinqType>(expression.TypeOperand.GetTypeInfo()); #endif }
static Node ParseExpression(TypeBinaryExpression e) { switch (e.NodeType) { case ExpressionType.TypeIs: return new BinaryNode { Left = Parse(e.Expression), Operator = "is", Right = new ConstantNode() { Text = NameOfType(e.TypeOperand) }, Value = GetValue(e) }; default: throw new NotImplementedException(string.Format(CultureInfo.CurrentCulture, "Can't handle TypeBinaryExpression of type {0}", e.NodeType)); } }
/// <summary> /// Visits a TypeBinaryExpression. /// </summary> /// <param name="node">The TypeBinaryExpression.</param> /// <returns>The TypeBinaryExpression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { _sb.Append("("); Visit(node.Expression); _sb.Append(" is "); _sb.Append(FriendlyTypeName(node.TypeOperand)); _sb.Append(")"); return node; }
protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { Expression expr = Visit(b.Expression); return UpdateTypeIs(b, expr, b.TypeOperand); }
protected override Expression VisitTypeBinaryExpression(TypeBinaryExpression expression) { return expression; }
internal override Expression VisitTypeIs(TypeBinaryExpression b) { if (ClientType.CheckElementTypeIsEntity(b.Expression.Type) || IsCollectionProducingExpression(b.Expression)) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjection(this.type, b.ToString())); } return base.VisitTypeIs(b); }
protected virtual System.Linq.Expressions.Expression VisitTypeIs(TypeBinaryExpression b) { System.Linq.Expressions.Expression expr = Visit(b.Expression); if(expr != b.Expression) { return System.Linq.Expressions.Expression.TypeIs(expr, b.TypeOperand); } return b; }
protected internal virtual new Expression VisitTypeBinary(TypeBinaryExpression node) { return(default(Expression)); }
/// <summary> /// Serializes an TypeBinaryExpression to a string /// </summary> /// <param name="b">TypeBinaryExpression to serialize</param> /// <returns>serialized expression</returns> internal override Expression VisitTypeIs(TypeBinaryExpression b) { this.builder.Append(UriHelper.ISOF); this.builder.Append(UriHelper.LEFTPAREN); if (!this.IsImplicitInputReference(b.Expression)) { this.Visit(b.Expression); this.builder.Append(UriHelper.COMMA); this.builder.Append(UriHelper.SPACE); } this.builder.Append(UriHelper.QUOTE); this.builder.Append(UriHelper.GetTypeNameForUri(b.TypeOperand, this.context)); this.builder.Append(UriHelper.QUOTE); this.builder.Append(UriHelper.RIGHTPAREN); return b; }
protected override Expression VisitTypeBinary(TypeBinaryExpression node) { var expr = Visit(node.Expression); return(Push(node, new XAttribute(nameof(node.TypeOperand), node.TypeOperand), new XElement(nameof(node.Expression), expr))); }
protected virtual bool VisitTypeIs(TypeBinaryExpression b, TypeBinaryExpression b2) { return(b.TypeOperand == b2.TypeOperand && Visit(b.Expression, b2.Expression)); }
protected virtual Expression VisitTypeBinary(TypeBinaryExpression node) { var expression = this.Visit(node.Expression); return(UpdateTypeBinary(node, expression, node.TypeOperand)); }
protected override string VisitTypeBinary(TypeBinaryExpression node) => GetType(node.TypeOperand);
protected internal virtual new Expression VisitTypeBinary(TypeBinaryExpression node) { Contract.Requires(node != null); return(default(Expression)); }
protected virtual Expression VisitTypeBinary(TypeBinaryExpression node) { throw new NotImplementedException(); }
private HqlTreeNode VisitTypeBinaryExpression(TypeBinaryExpression expression) { return _hqlTreeBuilder.Equality( _hqlTreeBuilder.Dot(Visit(expression.Expression).AsExpression(), _hqlTreeBuilder.Class()), _hqlTreeBuilder.Ident(expression.TypeOperand.FullName)); }
protected internal override Expression VisitTypeBinary(TypeBinaryExpression node) { Expressions.Add(node); return(base.VisitTypeBinary(node)); }
protected virtual bool CompareTypeIs(TypeBinaryExpression a, TypeBinaryExpression b) { return a.TypeOperand == b.TypeOperand && this.Compare(a.Expression, b.Expression); }
public TypeBinaryExpressionProxy(TypeBinaryExpression node) { ArgumentNullException.ThrowIfNull(node); _node = node; }
protected TypeBinaryExpression UpdateTypeIs(TypeBinaryExpression binary, Expression expression, Type typeOperand) { if (expression != binary.Expression || typeOperand != binary.TypeOperand) { return Expression.TypeIs(expression, typeOperand); } return binary; }
private Expression Convert(LinqExp.TypeBinaryExpression linqTypeBinary) => Expression.TypeIs(ConvertExp(linqTypeBinary.Expression), linqTypeBinary.TypeOperand);
/// <summary> /// Visits a TypeBinaryExpression. /// </summary> /// <param name="node">The TypeBinaryExpression.</param> /// <returns>The TypeBinaryExpression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { throw new NotImplementedException(); }
protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { var expr = this.Visit(b.Expression); return(expr != b.Expression ? Expression.TypeIs(expr, b.TypeOperand) : b); }
protected override Expression VisitTypeIs(TypeBinaryExpression b) => InvokeEvent(TypeIsVisited, b, base.VisitTypeIs);
/// <summary> /// If the result of a TypeBinaryExpression is known statically, this /// returns the result, otherwise it returns null, meaning we'll need /// to perform the IsInst instruction at runtime. /// /// The result of this function must be equivalent to IsInst, or /// null. /// </summary> internal static AnalyzeTypeIsResult AnalyzeTypeIs(TypeBinaryExpression typeIs) { return(AnalyzeTypeIs(typeIs.Expression, typeIs.TypeOperand)); }
private IMongoQuery BuildTypeIsQuery(TypeBinaryExpression typeBinaryExpression) { var nominalType = typeBinaryExpression.Expression.Type; var actualType = typeBinaryExpression.TypeOperand; var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(nominalType); var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType); if (discriminator == null) { return new QueryDocument(); // matches everything } if (discriminator.IsBsonArray) { discriminator = discriminator.AsBsonArray[discriminator.AsBsonArray.Count - 1]; } return Query.EQ(discriminatorConvention.ElementName, discriminator); }
public TypeBinaryExpressionProxy(TypeBinaryExpression node) { ContractUtils.RequiresNotNull(node, nameof(node)); _node = node; }
protected override Expression VisitTypeBinaryExpression(TypeBinaryExpression expression) => expression;
/// <inheritdoc /> protected override Expression VisitTypeIs(TypeBinaryExpression b) => Expression.TypeIs(Visit(b.Expression), b.TypeOperand);
internal override Expression VisitTypeIs(TypeBinaryExpression b) { throw new NotSupportedException(Strings.ALinq_TypeBinaryNotSupported); }
public TypeBinaryExpressionProxy(TypeBinaryExpression node) { _node = node; }
/// <summary> /// Constructor with an <see cref="TypeBinaryExpression"/> and an <see cref="ExpressionConverter"/>. /// </summary> /// <param name="expression">The original, not serializable <see cref="Expression"/>.</param> /// <param name="expConverter">The <see cref="ExpressionConverter"/> to convert contained <see cref="Expression">Expressions</see>.</param> public SerializableTypeBinaryExpression(TypeBinaryExpression expression, ExpressionConverter expConverter) : base(expression, expConverter) { Expression = expression.Expression.MakeSerializable(expConverter); TypeOperand = InterLinqTypeSystem.Instance.GetInterLinqVersionOf<InterLinqType>(expression.TypeOperand); }
protected virtual void VisitTypeIs(TypeBinaryExpression type) { Visit(type.Expression); }
/// <summary> /// TypeBinaryExpression visit method /// </summary> /// <param name="b">The TypeBinaryExpression expression to visit</param> /// <returns>The visited TypeBinaryExpression expression </returns> internal override Expression VisitTypeIs(TypeBinaryExpression b) { writer.WriteStartElement(XmlTypeIs); writer.WriteElementString(XmlTypeName, b.TypeOperand.ToString()); writer.WriteEndElement(); return b; }
/// <summary> /// Visits the children of the <see cref="TypeBinaryExpression"/>. /// </summary> /// <param name="node">The expression to visit.</param> /// <returns>The modified expression, if it or any subexpression was modified; /// otherwise, returns the original expression.</returns> protected internal virtual Expression VisitTypeBinary(TypeBinaryExpression node) { return(node.Update(Visit(node.Expression))); }
protected virtual Expression VisitTypeIs (TypeBinaryExpression type) { Expression e = Visit (type.Expression); if (e != type.Expression) return Expression.TypeIs (e, type.TypeOperand); return type; }
private static string VisitTypeBinary(TypeBinaryExpression node) { throw new NotImplementedException(); }
protected virtual Expression VisitTypeIs(TypeBinaryExpression binary) { Expression expr = this.Visit(binary.Expression); return this.UpdateTypeIs(binary, expr, binary.TypeOperand); }
public TypeBinaryExpressionMutator(TypeBinaryExpression expression) { TypeBinaryExpression = expression; }
protected override Expression VisitTypeIs(TypeBinaryExpression b) { this.Visit(b.Expression); this.Write(" is "); this.Write(this.GetTypeName(b.TypeOperand)); return b; }
internal virtual void VisitTypeIs(TypeBinaryExpression type) { Visit(type.Expression); }
/// <summary> /// Visits a TypeBinaryExpression. /// </summary> /// <param name="node">The TypeBinaryExpression.</param> /// <returns>The TypeBinaryExpression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { WriteHeader(node); using (new Indentation(this)) { WriteLine("TypeOperand={0}", FriendlyClassName(node.TypeOperand)); WriteLine("Expression:"); VisitIndented(node.Expression); } return node; }
protected override Expression VisitTypeBinary(TypeBinaryExpression b) { var f = GetField(b.Expression); FieldReference fr = f as FieldReference; if (fr != null) { if (b.TypeOperand.IsAssignableFrom(fr.FieldType)) { sb.Append(fr.Name.SqlEscape() + " IS NOT NULL"); } else throw new InvalidOperationException("A {0} will never be {1}".FormatWith(fr.FieldType.TypeName(), b.TypeOperand.TypeName())); return b; } FieldImplementedBy fib = f as FieldImplementedBy; if (fib != null) { var imp = fib.ImplementationColumns.Where(kvp => b.TypeOperand.IsAssignableFrom(kvp.Key)); if (imp.Any()) sb.Append(imp.ToString(kvp => kvp.Value.Name.SqlEscape() + " IS NOT NULL", " OR ")); else throw new InvalidOperationException("No implementation ({0}) will never be {1}".FormatWith(fib.ImplementationColumns.Keys.ToString(t=>t.TypeName(), ", "), b.TypeOperand.TypeName())); return b; } throw new NotSupportedException("'is' only works with ImplementedBy or Reference fields"); }
/// <summary> /// Visit a Is expression. /// </summary> /// <param name="typeBinaryExp"></param> /// <returns></returns> protected virtual Expression VisitTypeIs(TypeBinaryExpression typeBinaryExp) { Expression expr = Visit(typeBinaryExp.Expression); return expr != typeBinaryExp.Expression ? Expression.TypeIs(expr, typeBinaryExp.TypeOperand) : typeBinaryExp; }
/// <summary> /// Visits a TypeBinaryExpression. /// </summary> /// <param name="node">The TypeBinaryExpression.</param> /// <returns>The TypeBinaryExpression.</returns> protected override Expression VisitTypeBinary(TypeBinaryExpression node) { _sb.Append("<TypeBinaryExpression>"); return node; }
private IMongoQuery BuildTypeIsQuery(TypeBinaryExpression typeBinaryExpression) { var nominalType = typeBinaryExpression.Expression.Type; var actualType = typeBinaryExpression.TypeOperand; var discriminatorConvention = BsonSerializer.LookupDiscriminatorConvention(nominalType); var discriminator = discriminatorConvention.GetDiscriminator(nominalType, actualType); if (discriminator == null) { return BuildBooleanQuery(true); } if (discriminator.IsBsonArray) { discriminator = discriminator.AsBsonArray[discriminator.AsBsonArray.Count - 1]; } var elementName = discriminatorConvention.ElementName; var serializationInfo = _serializationInfoHelper.GetSerializationInfo(typeBinaryExpression.Expression); if (serializationInfo.ElementName != null) { elementName = string.Format("{0}.{1}", serializationInfo.ElementName, elementName); } return Query.EQ(elementName, discriminator); }
internal override Expression VisitTypeIs(TypeBinaryExpression b) { throw new NotSupportedException(Strings.ALinq_ExpressionNotSupportedInProjectionToEntity(this.type, b.ToString())); }
/// <summary> /// Visits a TypeBinaryExpression. /// </summary> /// <param name="b">The TypeBinaryExpression.</param> /// <returns>The TypeBinaryExpression (possibly modified).</returns> protected virtual Expression VisitTypeIs(TypeBinaryExpression b) { Expression expr = this.Visit(b.Expression); if (expr != b.Expression) { return Expression.TypeIs(expr, b.TypeOperand); } return b; }
private Expression VisitTypeIs(TypeBinaryExpression b) { var expr = Visit(b.Expression); return(expr != b.Expression ? Expression.TypeIs(expr, b.TypeOperand) : b); }