Deveel.Data.Linq.ExpressionVisitor Class Reference

Inheritance diagram for Deveel.Data.Linq.ExpressionVisitor:

Public Member Functions
virtual Expression	Visit (Expression exp)

Protected Member Functions
	ExpressionVisitor ()
virtual MemberBinding	VisitBinding (MemberBinding binding)
virtual ElementInit	VisitElementInitializer (ElementInit initializer)
virtual Expression	VisitUnary (UnaryExpression u)
virtual Expression	VisitBinary (BinaryExpression b)
virtual Expression	VisitTypeIs (TypeBinaryExpression b)
virtual Expression	VisitConstant (ConstantExpression c)
virtual Expression	VisitConditional (ConditionalExpression c)
virtual Expression	VisitParameter (ParameterExpression p)
virtual Expression	VisitMemberAccess (MemberExpression m)
virtual Expression	VisitMethodCall (MethodCallExpression m)
virtual ReadOnlyCollection< Expression >	VisitExpressionList (ReadOnlyCollection< Expression > original)
virtual MemberAssignment	VisitMemberAssignment (MemberAssignment assignment)
virtual MemberMemberBinding	VisitMemberMemberBinding (MemberMemberBinding binding)
virtual MemberListBinding	VisitMemberListBinding (MemberListBinding binding)
virtual IEnumerable< MemberBinding >	VisitBindingList (ReadOnlyCollection< MemberBinding > original)
virtual IEnumerable< ElementInit >	VisitElementInitializerList (ReadOnlyCollection< ElementInit > original)
virtual Expression	VisitLambda (LambdaExpression lambda)
virtual NewExpression	VisitNew (NewExpression nex)
virtual Expression	VisitMemberInit (MemberInitExpression init)
virtual Expression	VisitListInit (ListInitExpression init)
virtual Expression	VisitNewArray (NewArrayExpression na)
virtual Expression	VisitInvocation (InvocationExpression iv)

Detailed Description

Definition at line 24 of file ExpressionVisitor.cs.

Constructor & Destructor Documentation

Deveel.Data.Linq.ExpressionVisitor.ExpressionVisitor ( )

inlineprotected

Definition at line 25 of file ExpressionVisitor.cs.

                                      {
        }

Member Function Documentation

virtual Expression Deveel.Data.Linq.ExpressionVisitor.Visit ( Expression  exp )

inlinevirtual

Reimplemented in Deveel.Data.Linq.Evaluator.Nominator, and Deveel.Data.Linq.Evaluator.SubtreeEvaluator.

Definition at line 28 of file ExpressionVisitor.cs.

                                                        {
            if (exp == null)
                return exp;
            switch (exp.NodeType) {
                case ExpressionType.Negate:
                case ExpressionType.NegateChecked:
                case ExpressionType.Not:
                case ExpressionType.Convert:
                case ExpressionType.ConvertChecked:
                case ExpressionType.ArrayLength:
                case ExpressionType.Quote:
                case ExpressionType.TypeAs:
                    return this.VisitUnary((UnaryExpression)exp);
                case ExpressionType.Add:
                case ExpressionType.AddChecked:
                case ExpressionType.Subtract:
                case ExpressionType.SubtractChecked:
                case ExpressionType.Multiply:
                case ExpressionType.MultiplyChecked:
                case ExpressionType.Divide:
                case ExpressionType.Modulo:
                case ExpressionType.And:
                case ExpressionType.AndAlso:
                case ExpressionType.Or:
                case ExpressionType.OrElse:
                case ExpressionType.LessThan:
                case ExpressionType.LessThanOrEqual:
                case ExpressionType.GreaterThan:
                case ExpressionType.GreaterThanOrEqual:
                case ExpressionType.Equal:
                case ExpressionType.NotEqual:
                case ExpressionType.Coalesce:
                case ExpressionType.ArrayIndex:
                case ExpressionType.RightShift:
                case ExpressionType.LeftShift:
                case ExpressionType.ExclusiveOr:
                    return VisitBinary((BinaryExpression)exp);
                case ExpressionType.TypeIs:
                    return VisitTypeIs((TypeBinaryExpression)exp);
                case ExpressionType.Conditional:
                    return VisitConditional((ConditionalExpression)exp);
                case ExpressionType.Constant:
                    return VisitConstant((ConstantExpression)exp);
                case ExpressionType.Parameter:
                    return VisitParameter((ParameterExpression)exp);
                case ExpressionType.MemberAccess:
                    return VisitMemberAccess((MemberExpression)exp);
                case ExpressionType.Call:
                    return VisitMethodCall((MethodCallExpression)exp);
                case ExpressionType.Lambda:
                    return VisitLambda((LambdaExpression)exp);
                case ExpressionType.New:
                    return VisitNew((NewExpression)exp);
                case ExpressionType.NewArrayInit:
                case ExpressionType.NewArrayBounds:
                    return VisitNewArray((NewArrayExpression)exp);
                case ExpressionType.Invoke:
                    return VisitInvocation((InvocationExpression)exp);
                case ExpressionType.MemberInit:
                    return VisitMemberInit((MemberInitExpression)exp);
                case ExpressionType.ListInit:
                    return VisitListInit((ListInitExpression)exp);
                default:
                    throw new Exception(string.Format("Unhandled expression type: '{0}'", exp.NodeType));
            }
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitBinary ( BinaryExpression  b )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Linq.QueryBuilder.

Definition at line 124 of file ExpressionVisitor.cs.

                                                                     {
            Expression left = Visit(b.Left);
            Expression right = Visit(b.Right);
            Expression conversion = Visit(b.Conversion);
            if (left != b.Left || right != b.Right || conversion != b.Conversion) {
                if (b.NodeType == ExpressionType.Coalesce && b.Conversion != null)
                    return Expression.Coalesce(left, right, conversion as LambdaExpression);
                
                return Expression.MakeBinary(b.NodeType, left, right, b.IsLiftedToNull, b.Method);
            }
            return b;
        }

virtual MemberBinding Deveel.Data.Linq.ExpressionVisitor.VisitBinding ( MemberBinding  binding )

inlineprotectedvirtual

Definition at line 95 of file ExpressionVisitor.cs.

                                                                            {
            switch (binding.BindingType) {
                case MemberBindingType.Assignment:
                    return VisitMemberAssignment((MemberAssignment)binding);
                case MemberBindingType.MemberBinding:
                    return VisitMemberMemberBinding((MemberMemberBinding)binding);
                case MemberBindingType.ListBinding:
                    return VisitMemberListBinding((MemberListBinding)binding);
                default:
                    throw new Exception(string.Format("Unhandled binding type '{0}'", binding.BindingType));
            }
        }

virtual IEnumerable<MemberBinding> Deveel.Data.Linq.ExpressionVisitor.VisitBindingList ( ReadOnlyCollection< MemberBinding >  original )

inlineprotectedvirtual

Definition at line 224 of file ExpressionVisitor.cs.

                                                                                                                  {
            List<MemberBinding> list = null;
            for (int i = 0, n = original.Count; i < n; i++) {
                MemberBinding b = this.VisitBinding(original[i]);
                if (list != null) {
                    list.Add(b);
                } else if (b != original[i]) {
                    list = new List<MemberBinding>(n);
                    for (int j = 0; j < i; j++) {
                        list.Add(original[j]);
                    }
                    list.Add(b);
                }
            }
            if (list != null)
                return list;
            return original;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitConditional ( ConditionalExpression  c )

inlineprotectedvirtual

Definition at line 149 of file ExpressionVisitor.cs.

                                                                               {
            Expression test = Visit(c.Test);
            Expression ifTrue = Visit(c.IfTrue);
            Expression ifFalse = Visit(c.IfFalse);
            if (test != c.Test || ifTrue != c.IfTrue || ifFalse != c.IfFalse) {
                return Expression.Condition(test, ifTrue, ifFalse);
            }
            return c;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitConstant ( ConstantExpression  c )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Linq.ExpressionTreeModifier.

Definition at line 145 of file ExpressionVisitor.cs.

                                                                         {
            return c;
        }

virtual ElementInit Deveel.Data.Linq.ExpressionVisitor.VisitElementInitializer ( ElementInit  initializer )

inlineprotectedvirtual

Definition at line 108 of file ExpressionVisitor.cs.

                                                                                       {
            ReadOnlyCollection<Expression> arguments = VisitExpressionList(initializer.Arguments);
            if (arguments != initializer.Arguments) {
                return Expression.ElementInit(initializer.AddMethod, arguments);
            }
            return initializer;
        }

virtual IEnumerable<ElementInit> Deveel.Data.Linq.ExpressionVisitor.VisitElementInitializerList ( ReadOnlyCollection< ElementInit >  original )

inlineprotectedvirtual

Definition at line 243 of file ExpressionVisitor.cs.

                                                                                                                         {
            List<ElementInit> list = null;
            for (int i = 0, n = original.Count; i < n; i++) {
                ElementInit init = this.VisitElementInitializer(original[i]);
                if (list != null) {
                    list.Add(init);
                } else if (init != original[i]) {
                    list = new List<ElementInit>(n);
                    for (int j = 0; j < i; j++) {
                        list.Add(original[j]);
                    }
                    list.Add(init);
                }
            }
            if (list != null)
                return list;
            return original;
        }

virtual ReadOnlyCollection<Expression> Deveel.Data.Linq.ExpressionVisitor.VisitExpressionList ( ReadOnlyCollection< Expression >  original )

inlineprotectedvirtual

Definition at line 180 of file ExpressionVisitor.cs.

                                                                                                                      {
            List<Expression> list = null;
            for (int i = 0, n = original.Count; i < n; i++) {
                Expression p = this.Visit(original[i]);
                if (list != null) {
                    list.Add(p);
                } else if (p != original[i]) {
                    list = new List<Expression>(n);
                    for (int j = 0; j < i; j++) {
                        list.Add(original[j]);
                    }
                    list.Add(p);
                }
            }
            if (list != null) {
                return list.AsReadOnly();
            }
            return original;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitInvocation ( InvocationExpression  iv )

inlineprotectedvirtual

Definition at line 311 of file ExpressionVisitor.cs.

                                                                              {
            IEnumerable<Expression> args = this.VisitExpressionList(iv.Arguments);
            Expression expr = this.Visit(iv.Expression);
            if (args != iv.Arguments || expr != iv.Expression) {
                return Expression.Invoke(expr, args);
            }
            return iv;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitLambda ( LambdaExpression  lambda )

inlineprotectedvirtual

Definition at line 262 of file ExpressionVisitor.cs.

                                                                          {
            Expression body = this.Visit(lambda.Body);
            if (body != lambda.Body) {
                return Expression.Lambda(lambda.Type, body, lambda.Parameters);
            }
            return lambda;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitListInit ( ListInitExpression  init )

inlineprotectedvirtual

Definition at line 290 of file ExpressionVisitor.cs.

                                                                            {
            NewExpression n = this.VisitNew(init.NewExpression);
            IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(init.Initializers);
            if (n != init.NewExpression || initializers != init.Initializers) {
                return Expression.ListInit(n, initializers);
            }
            return init;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitMemberAccess ( MemberExpression  m )

inlineprotectedvirtual

Definition at line 163 of file ExpressionVisitor.cs.

                                                                           {
            Expression exp = this.Visit(m.Expression);
            if (exp != m.Expression) {
                return Expression.MakeMemberAccess(exp, m.Member);
            }
            return m;
        }

virtual MemberAssignment Deveel.Data.Linq.ExpressionVisitor.VisitMemberAssignment ( MemberAssignment  assignment )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Linq.QueryBuilder.

Definition at line 200 of file ExpressionVisitor.cs.

                                                                                              {
            Expression e = this.Visit(assignment.Expression);
            if (e != assignment.Expression) {
                return Expression.Bind(assignment.Member, e);
            }
            return assignment;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitMemberInit ( MemberInitExpression  init )

inlineprotectedvirtual

Definition at line 281 of file ExpressionVisitor.cs.

                                                                                {
            NewExpression n = this.VisitNew(init.NewExpression);
            IEnumerable<MemberBinding> bindings = this.VisitBindingList(init.Bindings);
            if (n != init.NewExpression || bindings != init.Bindings) {
                return Expression.MemberInit(n, bindings);
            }
            return init;
        }

virtual MemberListBinding Deveel.Data.Linq.ExpressionVisitor.VisitMemberListBinding ( MemberListBinding  binding )

inlineprotectedvirtual

Definition at line 216 of file ExpressionVisitor.cs.

                                                                                              {
            IEnumerable<ElementInit> initializers = this.VisitElementInitializerList(binding.Initializers);
            if (initializers != binding.Initializers) {
                return Expression.ListBind(binding.Member, initializers);
            }
            return binding;
        }

virtual MemberMemberBinding Deveel.Data.Linq.ExpressionVisitor.VisitMemberMemberBinding ( MemberMemberBinding  binding )

inlineprotectedvirtual

Definition at line 208 of file ExpressionVisitor.cs.

                                                                                                    {
            IEnumerable<MemberBinding> bindings = this.VisitBindingList(binding.Bindings);
            if (bindings != binding.Bindings) {
                return Expression.MemberBind(binding.Member, bindings);
            }
            return binding;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitMethodCall ( MethodCallExpression  m )

inlineprotectedvirtual

Reimplemented in Deveel.Data.Linq.InnermostWhereFinder.

Definition at line 171 of file ExpressionVisitor.cs.

                                                                             {
            Expression obj = this.Visit(m.Object);
            IEnumerable<Expression> args = this.VisitExpressionList(m.Arguments);
            if (obj != m.Object || args != m.Arguments) {
                return Expression.Call(obj, m.Method, args);
            }
            return m;
        }

virtual NewExpression Deveel.Data.Linq.ExpressionVisitor.VisitNew ( NewExpression  nex )

inlineprotectedvirtual

Definition at line 270 of file ExpressionVisitor.cs.

                                                                    {
            IEnumerable<Expression> args = this.VisitExpressionList(nex.Arguments);
            if (args != nex.Arguments) {
                if (nex.Members != null)
                    return Expression.New(nex.Constructor, args, nex.Members);
                else
                    return Expression.New(nex.Constructor, args);
            }
            return nex;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitNewArray ( NewArrayExpression  na )

inlineprotectedvirtual

Definition at line 299 of file ExpressionVisitor.cs.

                                                                          {
            IEnumerable<Expression> exprs = this.VisitExpressionList(na.Expressions);
            if (exprs != na.Expressions) {
                if (na.NodeType == ExpressionType.NewArrayInit) {
                    return Expression.NewArrayInit(na.Type.GetElementType(), exprs);
                } else {
                    return Expression.NewArrayBounds(na.Type.GetElementType(), exprs);
                }
            }
            return na;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitParameter ( ParameterExpression  p )

inlineprotectedvirtual

Definition at line 159 of file ExpressionVisitor.cs.

                                                                           {
            return p;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitTypeIs ( TypeBinaryExpression  b )

inlineprotectedvirtual

Definition at line 137 of file ExpressionVisitor.cs.

                                                                         {
            Expression expr = Visit(b.Expression);
            if (expr != b.Expression) {
                return Expression.TypeIs(expr, b.TypeOperand);
            }
            return b;
        }

virtual Expression Deveel.Data.Linq.ExpressionVisitor.VisitUnary ( UnaryExpression  u )

inlineprotectedvirtual

Definition at line 116 of file ExpressionVisitor.cs.

                                                                   {
            Expression operand = Visit(u.Operand);
            if (operand != u.Operand) {
                return Expression.MakeUnary(u.NodeType, operand, u.Type, u.Method);
            }
            return u;
        }

---

The documentation for this class was generated from the following file:

• /var/calculate/remote/distfiles/egit-src/deveeldb.git/src/deveeldb-linq/Deveel.Data.Linq.old/ExpressionVisitor.cs