Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Data.Entity/System/Data/Query/InternalTrees/Nodes.cs

@@ -0,0 +1,190 @@
+//---------------------------------------------------------------------
+// <copyright file="Nodes.cs" company="Microsoft">
+//      Copyright (c) Microsoft Corporation.  All rights reserved.
+// </copyright>
+//
+// @owner  [....]
+// @backupOwner [....]
+//---------------------------------------------------------------------
+
+using System;
+using System.Collections.Generic;
+using System.Data.Metadata.Edm;
+using System.Globalization;
+using System.Diagnostics;
+
+namespace System.Data.Query.InternalTrees
+{
+    /// <summary>
+    /// A Node describes a node in a query tree. Each node has an operator, and
+    /// a list of zero or more children of that operator.
+    /// </summary>
+    internal class Node
+    {
+        #region private state
+        private int m_id;
+        private List<Node> m_children;
+        private Op m_op;
+        private NodeInfo m_nodeInfo;
+        #endregion
+
+        #region constructors
+        /// <summary>
+        /// Basic constructor. 
+        /// 
+        /// NEVER call this routine directly - you should always use the Command.CreateNode
+        /// factory methods.
+        /// </summary>
+        /// <param name="nodeId">id for the node</param>
+        /// <param name="op">The operator</param>
+        /// <param name="children">List of child nodes</param>
+        internal Node(int nodeId, Op op, List<Node> children)
+        {
+            m_id = nodeId;
+            m_op = op;
+            m_children = children;
+        }
+
+        /// <summary>
+        /// This routine is only used for building up rule patterns. 
+        /// NEVER use this routine for building up nodes in a user command tree.
+        /// </summary>
+        /// <param name="op"></param>
+        /// <param name="children"></param>
+        internal Node(Op op, params Node[] children)
+            : this(-1, op, new List<Node>(children))
+        {
+        }
+        #endregion
+
+        #region public properties and methods
+
+#if DEBUG
+        internal int Id { get { return m_id; } }
+#endif
+
+        /// <summary>
+        /// Get the list of children
+        /// </summary>
+        internal List<Node> Children { get { return m_children; } }
+
+        /// <summary>
+        /// Gets or sets the node's operator
+        /// </summary>
+        internal Op Op { get { return m_op; } set { m_op = value; } }
+
+        /// <summary>
+        /// Simpler (?) getter/setter routines
+        /// </summary>
+        internal Node Child0 { get { return m_children[0]; } set { m_children[0] = value; } }
+        /// <summary>
+        /// Do I have a zeroth child?
+        /// </summary>
+        internal bool HasChild0 { get { return m_children.Count > 0; } }
+
+        /// <summary>
+        /// Get/set first child
+        /// </summary>
+        internal Node Child1 { get { return m_children[1]; } set { m_children[1] = value; } }
+        /// <summary>
+        /// Do I have a child1?
+        /// </summary>
+        internal bool HasChild1 { get { return m_children.Count > 1; } }
+
+        /// <summary>
+        /// get/set second child
+        /// </summary>
+        internal Node Child2 { get { return m_children[2]; } set { m_children[2] = value; } }
+        /// <summary>
+        /// get/set second child
+        /// </summary>
+        internal Node Child3 { get { return m_children[3]; } /* commented out because of fxcop - there are no upstream callers -- set { m_children[3] = value; }*/ }
+        /// <summary>
+        /// Do I have a child2 (third child really)
+        /// </summary>
+        internal bool HasChild2 { get { return m_children.Count > 2; } }
+        /// <summary>
+        /// Do I have a child3 (fourth child really)
+        /// </summary>
+        internal bool HasChild3 { get { return m_children.Count > 3; } }
+
+        #region equivalence functions
+        /// <summary>
+        /// Is this subtree equivalent to another subtree
+        /// </summary>
+        /// <param name="other"></param>
+        /// <returns></returns>
+        internal bool IsEquivalent(Node other)
+        {
+            if (this.Children.Count != other.Children.Count)
+            {
+                return false;
+            }
+            bool? opEquivalent = this.Op.IsEquivalent(other.Op);
+            if (opEquivalent != true)
+            {
+                return false;
+            }
+            for (int i = 0; i < this.Children.Count; i++)
+            {
+                if (!this.Children[i].IsEquivalent(other.Children[i]))
+                {
+                    return false;
+                }
+            }
+            return true;
+        }
+        #endregion
+
+        #region NodeInfo methods and properties
+        /// <summary>
+        /// Has the node info been initialized, i.e. previously computed
+        /// </summary>
+        internal bool IsNodeInfoInitialized { get { return (m_nodeInfo != null);  } }
+
+        /// <summary>
+        /// Get the nodeInfo for a node. Initializes it, if it has not yet been initialized
+        /// </summary>
+        /// <param name="command">Current command object</param>
+        /// <returns>NodeInfo for this node</returns>
+        internal NodeInfo GetNodeInfo(Command command)
+        {
+            if (m_nodeInfo == null)
+            {
+                InitializeNodeInfo(command);
+            }
+            return m_nodeInfo;
+        }
+        /// <summary>
+        /// Gets the "extended" nodeinfo for a node; if it has not yet been initialized, then it will be
+        /// </summary>
+        /// <param name="command">current command object</param>
+        /// <returns>extended nodeinfo for this node</returns>
+        internal ExtendedNodeInfo GetExtendedNodeInfo(Command command)
+        {
+            if (m_nodeInfo == null)
+            {
+                InitializeNodeInfo(command);
+            }
+            ExtendedNodeInfo extendedNodeInfo = m_nodeInfo as ExtendedNodeInfo;
+            Debug.Assert(extendedNodeInfo != null);
+            return extendedNodeInfo;
+        }
+
+        private void InitializeNodeInfo(Command command)
+        {
+            if (this.Op.IsRelOp || this.Op.IsPhysicalOp)
+            {
+                m_nodeInfo = new ExtendedNodeInfo(command);
+            }
+            else
+            {
+                m_nodeInfo = new NodeInfo(command);
+            }
+            command.RecomputeNodeInfo(this);
+        }
+        #endregion
+
+        #endregion
+    }
+}