Esempio n. 1
0
        /// <summary>
        ///   Returns a copy of this instance.
        /// </summary>
        /// <returns>the copy of the arc.</returns>
        public override arc copy()
        {
            var copyOfArc = new ruleArc();

            copy(copyOfArc);
            return(copyOfArc);
        }
Esempio n. 2
0
        private void checkForNegativeArc(option location, node fromLNode, node fromHostNode,
                                         ruleArc newLArc)
        {
            var currentLArcIndex = L.arcs.IndexOf(newLArc);

            /* so, currentLArcIndex now, points to a LArc that has yet to be recognized. What we do from
             * this point depends on whether that LArc points to an L node we have yet to recognize, an L
             * node we have recognized, or null. */
            var nextLNode = (ruleNode)newLArc.otherNode(fromLNode);
            /* first we must match the arc to a possible arc leaving the fromHostNode .*/
            node nextHostNode = (nextLNode == null) ? null : location.findLMappedNode(nextLNode);

            var neighborHostArcs = fromHostNode.arcs.FindAll(a =>
                                                             (a is arc && !location.arcs.Contains(a)) &&
                                                             arcMatches(newLArc, (arc)a, fromHostNode, nextHostNode, (newLArc.From == fromLNode))).Cast <arc>();

            if ((nextHostNode != null) || newLArc.nullMeansNull)
            {
                foreach (var HostArc in neighborHostArcs)
                {
                    var newLocation = location.copy();
                    newLocation.arcs[currentLArcIndex] = HostArc;
                    findNegativeStartElement(newLocation);
                    if ((bool)AllNegativeElementsFound)
                    {
                        return;                                 /* another sub-branch found a match to the negative elements.
                                                                 * There's no point in finding more than one, so this statement
                                                                 * aborts the search down this branch. */
                    }
                }
            }
            else
            {
                foreach (var HostArc in neighborHostArcs)
                {
                    nextHostNode = HostArc.otherNode(fromHostNode);
                    if (!location.nodes.Contains(nextHostNode))
                    {
                        var newLocation = location.copy();
                        newLocation.arcs[currentLArcIndex] = HostArc;
                        if (nextLNode == null)
                        {
                            findNegativeStartElement(newLocation);
                        }
                        else
                        {
                            checkForNegativeNode(newLocation, nextLNode, nextHostNode);
                        }
                    }
                    if ((bool)AllNegativeElementsFound)
                    {
                        return;                                 /* another sub-branch found a match to the negative elements.
                                                                 * There's no point in finding more than one, so this statement
                                                                 * aborts the search down this branch. */
                    }
                }
            }
        }
Esempio n. 3
0
        public void addArcsFromGraphControl(Netron.GraphLib.UI.GraphControl graphControl1,
                                            Boolean ruleGraph)
        {
            Shape fromShape, toShape;
            arc   temparc;

            foreach (Connection a in graphControl1.Connections)
            {
                if (!arcs.Exists(delegate(arc b) { return(b.displayShape == a); }))
                {
                    if (ruleGraph)
                    {
                        temparc = new ruleArc(nameFromText(a.Text));
                    }
                    else
                    {
                        temparc = new arc(nameFromText(a.Text));
                    }
                    this.arcs.Add(temparc);
                }
                else
                {
                    temparc = arcs.Find(delegate(arc b) { return(b.displayShape == a); });
                }

                fromShape = a.From.BelongsTo;
                toShape   = a.To.BelongsTo;

                temparc.From = nodes.Find(delegate(node c)
                                          { return(sameName(c.name, fromShape.Text)); });
                temparc.To = nodes.Find(delegate(node c)
                                        { return(sameName(c.name, toShape.Text)); });

                for (int i = 0; i != fromShape.Connectors.Count; i++)
                {
                    if (fromShape.Connectors[i] == a.From)
                    {
                        temparc.fromConnector = i;
                    }
                }
                for (int i = 0; i != toShape.Connectors.Count; i++)
                {
                    if (toShape.Connectors[i] == a.To)
                    {
                        temparc.toConnector = i;
                    }
                }
                if (a.Text != "[Not_set]")
                {
                    temparc.name        = nameFromText(a.Text);
                    temparc.localLabels = labelsFromText(a.Text);
                }
                temparc.displayShape = a;
                temparc.setStyleKeyFromDisplayShape();
            }
        }
Esempio n. 4
0
        private string KarcsChangeDirection()
        {
            string badArcNames = "";

            foreach (ruleArc a in L.arcs)
            {
                ruleArc b = (ruleArc)R.arcs.Find(delegate(arc c) { return(c.name == a.name); });
                if ((b != null) && ((a.To.name == b.From.name) || (a.From.name == b.To.name)))
                {
                    badArcNames += a.name + ", ";
                }
            }
            return(badArcNames);
        }
Esempio n. 5
0
        private void checkArcAvoidNegatives(option location, node fromLNode, node fromHostNode,
                                            ruleArc newLArc)
        {
            var currentLArcIndex = L.arcs.IndexOf(newLArc);

            /* so, currentLArcIndex now, points to a LArc that has yet to be recognized. What we do from
             * this point depends on whether that LArc points to an L node we have yet to recognize, an L
             * node we have recognized, or null. */
            var nextLNode = (ruleNode)newLArc.otherNode(fromLNode);
            /* first we must match the arc to a possible arc leaving the fromHostNode .*/
            var nextHostNode = (nextLNode == null || nextLNode.NotExist) ? null
                               : location.findLMappedNode(nextLNode);

            var neighborHostArcs = fromHostNode.arcs.FindAll(a =>
                                                             (a is arc && !location.arcs.Contains(a)) &&
                                                             (arcMatches(newLArc, (arc)a, fromHostNode, nextHostNode, (newLArc.From == fromLNode)) ||
                                                              arcMatchRelaxed(newLArc, (arc)a, location, fromHostNode, nextHostNode, (newLArc.From == fromLNode)))).Cast <arc>();

            //relaxelt
            if ((nextHostNode != null) || newLArc.nullMeansNull)
            {
                foreach (var HostArc in neighborHostArcs)
                {
                    var newLocation = location.copy();
                    newLocation.arcs[currentLArcIndex] = HostArc;
                    FindPositiveStartElementAvoidNegatives(newLocation);
                }
            }
            else
            {
                foreach (var HostArc in neighborHostArcs)
                {
                    nextHostNode = HostArc.otherNode(fromHostNode);
                    if (!location.nodes.Contains(nextHostNode))
                    {
                        var newLocation = location.copy();
                        newLocation.arcs[currentLArcIndex] = HostArc;
                        if (nextLNode == null || nextLNode.NotExist)
                        {
                            FindPositiveStartElementAvoidNegatives(newLocation);
                        }
                        else
                        {
                            checkNodeAvoidNegatives(newLocation, nextLNode, nextHostNode);
                        }
                    }
                }
            }
        }
Esempio n. 6
0
        /// <summary>
        /// Overrides the object method to check all details of the graphs to see
        /// if they are identical. It is potentially time-consuming as it makes
        /// rules and assigns the graphs as the L of the rule, and then performs
        /// the "recognize" function on the other graph.
        /// </summary>
        /// <param name="obj">The other graph to compare to this one.</param>
        /// <param name="contentsOfGraphAreEqual">if set to <c>true</c> then check that contents of graph are equal even though they occupy different memory.</param>
        /// <returns>
        ///   <c>true</c> if the specified <see cref="System.Object" /> is equal to this instance; otherwise, <c>false</c>.
        /// </returns>
        public bool Equals(object obj, bool contentsOfGraphAreEqual)
        {
            if (Equals(obj))
            {
                return(true);
            }
            if (!contentsOfGraphAreEqual)
            {
                return(false);
            }
            if (!(obj is designGraph))
            {
                return(false);
            }
            var g = (designGraph)obj;

            if (!grammarRule.LabelsMatch(globalLabels, g.globalLabels, null, true))
            {
                return(false);
            }
            if (nodes.Count != g.nodes.Count)
            {
                return(false);
            }
            if (arcs.Count != g.arcs.Count)
            {
                return(false);
            }
            if (hyperarcs.Count != g.hyperarcs.Count)
            {
                return(false);
            }
            if (!DegreeSequence.SequenceEqual(g.DegreeSequence))
            {
                return(false);
            }

            var thisSecondaryDegree = new List <List <int> >();
            var gSecondaryDegree    = new List <List <int> >();

            for (int i = 0; i < nodes.Count; i++)
            {
                var thisDegreelist = new List <int>();
                var gDegreelist    = new List <int>();
                var thisNode       = nodes[i];
                var gNode          = g.nodes[i];
                foreach (var a in thisNode.arcs)
                {
                    if (a is arc)
                    {
                        thisDegreelist.Add(((arc)a).otherNode(thisNode).degree);
                    }
                }
                thisDegreelist.Sort();
                thisSecondaryDegree.Add(thisDegreelist);
                foreach (var a in gNode.arcs)
                {
                    if (a is arc)
                    {
                        gDegreelist.Add(((arc)a).otherNode(gNode).degree);
                    }
                }
                gDegreelist.Sort();
                gSecondaryDegree.Add(gDegreelist);
            }
            foreach (var degreeList in thisSecondaryDegree)
            {
                var i = gSecondaryDegree.FindIndex(v => v.SequenceEqual(degreeList));
                if (i == -1)
                {
                    return(false);
                }
                else
                {
                    gSecondaryDegree.RemoveAt(i);
                }
            }
            if (gSecondaryDegree.Any())
            {
                return(false);
            }
            var maxDegree = DegreeSequence[0];
            var dummyRule = new grammarRule
            {
                spanning = true,
                containsAllGlobalLabels = true,
                induced = true,
                L       = new designGraph()
            };

            #region put g's nodes, arcs and hyperarcs into the LHS of the rule
            foreach (var n in g.nodes)
            {
                var rn = new ruleNode(n)
                {
                    containsAllLocalLabels = true, strictDegreeMatch = true
                };
                if (n.degree == maxDegree)
                {
                    dummyRule.L.nodes.Insert(0, rn);
                }
                else
                {
                    dummyRule.L.nodes.Add(rn);
                }
            }
            foreach (var a in g.arcs)
            {
                var ra = new ruleArc(a)
                {
                    containsAllLocalLabels = true, directionIsEqual = true
                };
                dummyRule.L.arcs.Add(ra);
            }
            foreach (var ha in g.hyperarcs)
            {
                var rha = new ruleHyperarc(ha)
                {
                    containsAllLocalLabels = true, strictNodeCountMatch = true
                };
                dummyRule.L.hyperarcs.Add(rha);
            }
            dummyRule.L.RepairGraphConnections();
            #endregion

            if (dummyRule.recognize(this).Count < 1)
            {
                return(false);
            }

            #region put this's nodes, arcs and hyperarcs into the LHS of the rule
            dummyRule.L = new designGraph();
            foreach (var n in this.nodes)
            {
                var rn = new ruleNode(n)
                {
                    containsAllLocalLabels = true, strictDegreeMatch = true
                };
                if (n.degree == maxDegree)
                {
                    dummyRule.L.nodes.Insert(0, rn);
                }
                else
                {
                    dummyRule.L.nodes.Add(rn);
                }
            }
            foreach (var a in this.arcs)
            {
                var ra = new ruleArc(a)
                {
                    containsAllLocalLabels = true, directionIsEqual = true
                };
                dummyRule.L.arcs.Add(ra);
            }
            foreach (var ha in this.hyperarcs)
            {
                var rha = new ruleHyperarc(ha)
                {
                    containsAllLocalLabels = true, strictNodeCountMatch = true
                };
                dummyRule.L.hyperarcs.Add(rha);
            }
            dummyRule.L.RepairGraphConnections();
            #endregion
            if (dummyRule.recognize(g).Count < 1)
            {
                return(false);
            }
            return(true);
        }
Esempio n. 7
0
        public void addArcsFromGraphControl(Netron.GraphLib.UI.GraphControl graphControl1,
            Boolean ruleGraph)
        {
            Shape fromShape, toShape;
            arc temparc;

            foreach (Connection a in graphControl1.Connections)
            {
                if (!arcs.Exists(delegate(arc b) { return (b.displayShape == a); }))
                {
                    if (ruleGraph) temparc = new ruleArc(nameFromText(a.Text));
                    else temparc = new arc(nameFromText(a.Text));
                    this.arcs.Add(temparc);
                }
                else temparc = arcs.Find(delegate(arc b) { return (b.displayShape == a); });

                fromShape = a.From.BelongsTo;
                toShape = a.To.BelongsTo;

                temparc.From = nodes.Find(delegate(node c)
                 { return (sameName(c.name, fromShape.Text)); });
                temparc.To = nodes.Find(delegate(node c)
                 { return (sameName(c.name, toShape.Text)); });

                for (int i = 0; i != fromShape.Connectors.Count; i++)
                {
                    if (fromShape.Connectors[i] == a.From)
                        temparc.fromConnector = i;
                }
                for (int i = 0; i != toShape.Connectors.Count; i++)
                {
                    if (toShape.Connectors[i] == a.To)
                        temparc.toConnector = i;
                }
                if (a.Text != "[Not_set]")
                {
                    temparc.name = nameFromText(a.Text);
                    temparc.localLabels = labelsFromText(a.Text);
                }
                temparc.displayShape = a;
                temparc.setStyleKeyFromDisplayShape();
            }
        }