Exemplo n.º 1
0
        /// <summary>
        /// Removes the given Vertex from the graph; also removes all edges which use this vertex.  
        /// </summary>
        /// <param name="toRemove">The Vertex which will be completely removed from the graph.  </param>
        public void RemoveVertex(BaseVertex toRemove)
        {
            vertices.Remove(toRemove);

            foreach (BaseVertex vtx in vertices)
                vtx.RemoveConnections(toRemove);
        }
Exemplo n.º 2
0
 /// <summary>
 /// Removes all connections from this Vertex to a given target Vertex.
 /// </summary>
 /// <param name="target">Any connections from the current Vertex to target will be removed.</param>
 public void RemoveConnections(BaseVertex target)
 {
     for (int i = 0; i < connectsTo.Count; i++)
     {
         if (connectsTo[i].Connection.Name == target.Name)
         {
             connectsTo.RemoveAt(i);
             i--;
         }
     }
 }
Exemplo n.º 3
0
        // checks if node is in visited by name
        private bool isInList(ArrayList visited, BaseVertex node)
        {
            foreach (BaseVertex i in visited)
            {
                if (i.Name == node.Name)
                {

                    return true;
                }
            }

            return false;
        }
Exemplo n.º 4
0
 /// <summary>
 /// Checks all the edges to see if they are epsilon transitions
 /// </summary>
 /// <param name="node">node to check</param>
 /// <returns>true if there is an epsilon transition</returns>
 private bool hasEpsilonTransition(BaseVertex node)
 {
     foreach (Edge e in node.Connections)
     {
         if (e.Condition == this.epsilonTransition)
             return true;
     }
     return false;
 }
Exemplo n.º 5
0
 /// <summary>
 /// Get list of nodes that are connected to the input node by epsilon transitions
 /// </summary>
 /// <param name="node"></param>
 /// <returns></returns>
 private ArrayList getEpsilonTransition(BaseVertex node)
 {
     ArrayList eNodes = new ArrayList();
     foreach (Edge e in node.Connections)
     {
         if (e.Condition == this.epsilonTransition)
         {
             if (!this.isInList(eNodes, e.Connection))
             {
                 eNodes.Add(e.Connection);
             }
         }
     }
     return eNodes;
 }
Exemplo n.º 6
0
        /// <summary>
        /// perform an epsilon closure on a vertex
        /// </summary>
        /// <param name="v">vertex to perform e closure on</param>
        /// <returns>list of vertices in the epsilon closure of the vertex passed into the method</returns>
        public VertexSet eClosure(BaseVertex v)
        {
            Stack<BaseVertex> nodes = new Stack<BaseVertex>();
            BaseVertex current;
            VertexSet visited = new VertexSet(new ArrayList());

            // if the node passed doesn't have e transitions, return list with just passed in vertex, otherwise push onto stack and start algorithm
            if (this.hasEpsilonTransition(v))
            {
                nodes.Push(v);
            }

            while (nodes.Count > 0)
            {
                current = nodes.Pop();
                visited.addToSet(current);
                if (this.hasEpsilonTransition(current))
                {
                    ArrayList eNodes = this.getEpsilonTransition(current);
                    foreach (BaseVertex newNode in eNodes)
                    {
                        if (!visited.isInSet(newNode))
                        {
                            nodes.Push(newNode);
                        }
                    }
                }
            }
            if (visited.size() == 0)
            {
                visited.addToSet(v);
            }

            return visited;
        }
Exemplo n.º 7
0
        public Graph createGraph()
        {
            normalizeNames();

            Graph g = new Graph();

            BaseVertex[] verts = new BaseVertex[rowNames.Count];
            Dictionary<String, BaseVertex> vertexTable = new Dictionary<string,BaseVertex>();

            for (int x = 0; x < rowNames.Count; x++)
            {
                bool accepting = false;
                foreach (BaseVertex v in ((VertexSet)rowNames[x]).vertices)
                {
                    if (v.Accepting)
                        accepting = true;
                }
                BaseVertex vertex = g.CreateNewVertex(((VertexSet)rowNames[x]).ToDOTString(), accepting);
                vertexTable.Add(vertex.Name, vertex);
                verts[x] = vertex;
            }

            //iterate over vertices
            for (int i = 0; i < rowNames.Count; i++)
            {
                //iterate over alphabet
                for (int x = 0; x < columnNames.Count; x++)
                {
                    String toVertexName = ((VertexSet)table[x][i]).ToDOTString();
                    verts[i].AddConnection(vertexTable[toVertexName], columnNames[x].ToString());
                }
            }

            g.StartVertex = g.Vertices[1];

            return g;
        }
Exemplo n.º 8
0
 /// <summary>
 /// tests if a BaseVertex is in the VertexSet
 /// </summary>
 /// <param name="node">node to check to see if it is in the set</param>
 /// <returns>true if the vertex is in the set, false otherwise</returns>
 public bool isInSet(BaseVertex node)
 {
     foreach (BaseVertex i in this.vertices)
     {
         if (i.Name == node.Name)
             return true;
     }
     return false;
 }
Exemplo n.º 9
0
 /// <summary>
 /// Creates a new Edge with the given target Vertex and condition
 /// </summary>
 /// <param name="nextVertex">The vertex pointed to by this edge.  </param>
 /// <param name="condition">The condition which must be true for this vertex to be valid.</param>
 public Edge(BaseVertex nextVertex, string condition)
 {
     connectsTo = nextVertex;
     validOnCondition = condition;
     edgeText = String.Empty;
 }
Exemplo n.º 10
0
 public void AddConnection(BaseVertex newNode, string transitionString)
 {
     Edge newEdge = new Edge(newNode, transitionString);
     connectsTo.Add(newEdge);
 }
Exemplo n.º 11
0
 public void AddConnection(BaseVertex newNode, string transitionString, bool accepting)
 {
     Edge newEdge = new Edge(newNode, transitionString);
     connectsTo.Add(newEdge);
     this.isAccepting = accepting;
 }
Exemplo n.º 12
0
 public void AddConnection(BaseVertex newNode, string transitionString, bool accepting, bool isCharClass)
 {
     Edge newEdge = new Edge(newNode, transitionString, isCharClass);
     connectsTo.Add(newEdge);
 }
Exemplo n.º 13
0
        public bool CheckNodeEquality(BaseVertex that)
        {
            if (this.visited)
            {
                return true;
            }

            this.visited = true;

            if (this.connectsTo.Count == 0 && that.connectsTo.Count == 0)
            {
                return true;
            }
            if (this.connectsTo.Count != that.connectsTo.Count)
            {
                return false;
            }

            if (this.Accepting != that.Accepting)
                return false;

            foreach (Edge left in this.connectsTo)
            {
                int countEqualEdges = 0;
                foreach (Edge right in that.connectsTo)
                {
                    if(left.ShaneEquals(right))// && left.Connection.visited == false && right.Connection.visited == false)
                    {
                        if (left.Connection.CheckNodeEquality(right.Connection))
                        {
                            countEqualEdges++;
                        }
                    }
                }
                //didn't find a matching edge for this one, so its not the same node
                //finding 2 equivalent edges doesn't imply the vertices are different
                if (countEqualEdges == 0)
                {
                    return false;
                }
            }

            return true;
        }
Exemplo n.º 14
0
 /// <summary>
 /// Creates a new Edge with the given target Vertex and condition
 /// </summary>
 /// <param name="nextVertex">The vertex pointed to by this edge.  </param>
 /// <param name="condition">The condition which must be true for this vertex to be valid.</param>
 public Edge(BaseVertex nextVertex, string condition, bool isCharClass)
 {
     connectsTo = nextVertex;
     validOnCondition = condition;
     this.isCharClass = isCharClass;
 }
Exemplo n.º 15
0
 /// <summary>
 /// Creates a new Edge with the given target Vertex and condition
 /// </summary>
 /// <param name="nextVertex">The vertex pointed to by this edge.  </param>
 /// <param name="condition">The condition which must be true for this vertex to be valid.</param>
 public Edge(BaseVertex nextVertex, string condition)
 {
     connectsTo = nextVertex;
     validOnCondition = condition;
     isCharClass = false;
 }
Exemplo n.º 16
0
 /// <summary>
 /// Creates and returns a new BaseVertex with the given name and adds it to the graph
 /// </summary>
 /// <param name="name">The name of the vertex to be added.  The name must be unique.  </param>
 /// <returns>The new Vertex which was just created</returns>
 public BaseVertex CreateNewVertex(string name, bool accepting)
 {
     BaseVertex newV = new BaseVertex(name, accepting);
     vertices.Add(newV);
     return newV;
 }
Exemplo n.º 17
0
 /// <summary>
 /// Creates a new Graph with a default start vertex Vertices.  
 /// </summary>
 public Graph()
 {
     vertices = new List<BaseVertex>();
     start = this.CreateNewVertex("start", true);
 }
Exemplo n.º 18
0
 /// <summary>
 /// Creates and returns a new BaseVertex with the given name and adds it to the graph
 /// </summary>
 /// <param name="name">The name of the vertex to be added.  The name must be unique.  </param>
 /// <returns>The new Vertex which was just created</returns>
 public BaseVertex CreateNewVertex(string name)
 {
     BaseVertex newV = new BaseVertex(name);
     vertices.Add(newV);
     return newV;
 }
Exemplo n.º 19
0
 /// <summary>
 /// Creates a new Edge with the given target Vertex and condition
 /// </summary>
 /// <param name="nextVertex">The vertex pointed to by this edge.  </param>
 /// <param name="condition">The condition which must be true for this vertex to be valid.</param>
 /// <param name="edgeText">The text to show on for this edge</param>
 public Edge(BaseVertex nextVertex, string condition, string edgeText)
 {
     connectsTo = nextVertex;
     validOnCondition = condition;
     this.edgeText = edgeText;
 }
Exemplo n.º 20
0
 /// <summary>
 /// Adds a vertex to the VertexSet and updates the ID
 /// </summary>
 /// <param name="v">BaseVertex to add to the set</param>
 public void addToSet(BaseVertex v)
 {
     Debug.Assert(!this.isInSet(v)); // sanity check to ensure a set will never have duplicates
     vertices.Add(v);
     this.computeID();
 }