C# INode.LeftEdge方法代码示例

        /// <summary>
        ///   Clusters Two INodes together, sets new root/parent/left and right edges
        /// </summary>
        /// <param name="left"> Node on the left </param>
        /// <param name="right"> Node on the Right </param>
        /// <param name="match"> Inverted or Not Inverted </param>
        /// <param name="matchData"> Optional MatchData variable, store clustering information </param>
        public Cluster(INode left, INode right, Match match = Match.NonInverted, MatchData matchData = null)
        {
            if (match == Match.Impossible)
            {
                throw new ArgumentException("Match is apparently impossible why are you trying?");
            }

            // Now Build the new nodes
            _left = left;
            _right = right;
            _matchData = matchData;
            _size = left.Size() + right.Size();
            _leftedge = left.LeftEdge();
            _rightedge = right.RightEdge();

            // Set the parents accordingly
            left.Parent(this);
            right.Parent(this);
            _parent = null;

            // change the roots
            _left.Root(this);
            _right.Root(this);

            // Update Count
            Id = _count++;
        }

        /// <summary>
        ///   IsFit checks if given a specified side, it can be fit with a shreds's edge
        ///   This Also returns a match object
        /// </summary>
        /// <param name="root"> </param>
        /// <param name="shred"> </param>
        /// <param name="side"> </param>
        /// <returns> </returns>
        private static Tuple<Match, Direction> IsFit(INode root, Shred shred, Side side)
        {
            Side query;
            Match match;

            if (side.Orientation != shred.Orientation)
            {
                query = new Side(shred, Enumeration.Opposite(side.Direction), shred.Orientation);
                match = Match.Inverted;
            }
            else
            {
                query = side;
                match = Match.NonInverted;
            }

            // If Directions match AND The Availablility then return match, otherwise impossible
            if (query.Direction == Direction.FromLeft && root.LeftEdge() == shred.LeftEdge())
            {
                return new Tuple<Match, Direction>(match, Direction.FromLeft);
            }
            if (query.Direction == Direction.FromRight && root.RightEdge() == shred.RightEdge())
            {
                return new Tuple<Match, Direction>(match, Direction.FromRight);
            }
            return new Tuple<Match, Direction>(Match.Impossible, Direction.FromLeft);
        }

        private static bool ValidateEdges(INode node)
        {
            if (node.IsLeaf())
            {
                return true;
            }

            // Get the expected
            var actualLeft = node.LeftEdge();
            var actualRight = node.RightEdge();

            INode left = node;
            INode right = node;
            while (!left.IsLeaf())
            {
                left = left.Left();
            }
            while (!right.IsLeaf())
            {
                right = right.Right();
            }

            var expectedLeft = left.LeftEdge();
            var expectedRight = right.RightEdge();

            Assert.IsTrue(actualLeft == expectedLeft);
            Assert.IsTrue(actualRight == expectedRight);

            if (actualLeft != expectedLeft || actualRight != expectedRight)
            {
                return false;
            }

            // Repeat for node children
            return ValidateEdges(node.Left()) && ValidateEdges(node.Right());
        }

        private static bool IsEqual(INode nodeA, INode nodeB)
        {
            if (nodeA.IsLeaf() ^ nodeB.IsLeaf())
            {
                throw new Exception("Identical nodes should be at the same height");
            }

            Assert.IsTrue(nodeA.LeftEdge().Direction == nodeB.LeftEdge().Direction);
            Assert.IsTrue(nodeA.RightEdge().Direction == nodeB.RightEdge().Direction);
            Assert.IsTrue(nodeA.LeftEdge().Orientation == nodeB.LeftEdge().Orientation);
            Assert.IsTrue(nodeA.RightEdge().Orientation == nodeB.RightEdge().Orientation);

            if (nodeA.IsLeaf() && nodeB.IsLeaf())
            {
                return true;
            }

            return IsEqual(nodeA.Left(), nodeB.Left()) && IsEqual(nodeA.Right(), nodeB.Right());
        }

        private static bool IsMirror(INode reg, INode rev)
        {
            if (reg.IsLeaf() ^ rev.IsLeaf())
            {
                throw new Exception("Mirrored nodes are not at the same height");
            }

            if (reg.IsLeaf() && rev.IsLeaf())
            {
                Assert.IsTrue(reg.Size() == rev.Size());
                Assert.IsTrue(reg.Leaf().Orientation == Enumeration.Opposite(rev.Leaf().Orientation));
                Assert.IsTrue(reg.LeftEdge().Direction == Enumeration.Opposite(rev.RightEdge().Direction));
                return true;
            }

            return IsMirror(reg.Left(), rev.Right()) && IsMirror(reg.Right(), rev.Left());
        }