Пример #1
0
        /// <summary>
        /// Builds a pattern graph out of the graph.
        /// The pattern graph retains links to the original graph elements and uses them for attribute comparison.
        /// </summary>
        /// <param name="graph">The graph which is to be transfered into a pattern</param>
        /// <returns></returns>
        private static PatternGraph BuildPatternGraph(IGraph graph)
        {
            int numNodes = graph.NumNodes;
            int numEdges = graph.NumEdges;

            int count = 0;

            PatternNode[] nodes = new PatternNode[numNodes];
            INode[]       correspondingNodes = new INode[numNodes];
            foreach (INode node in graph.Nodes)
            {
                LGSPNode n = (LGSPNode)node;
                nodes[count] = new PatternNode(
                    n.Type.TypeID, n.Type, n.Type.PackagePrefixedName,
                    graph.Name + "_node_" + count, "node_" + count,
                    null, null,
                    1.0f, -1, false,
                    null, null, null, null, null,
                    null, false, null
                    );
                correspondingNodes[count] = node;
                ++count;
            }

            count = 0;
            PatternEdge[] edges = new PatternEdge[numEdges];
            IEdge[]       correspondingEdges = new IEdge[numEdges];
            foreach (IEdge edge in graph.Edges)
            {
                LGSPEdge e = (LGSPEdge)edge;
                edges[count] = new PatternEdge(
                    true,
                    e.Type.TypeID, e.Type, e.Type.PackagePrefixedName,
                    graph.Name + "_edge_" + count, "edge_" + count,
                    null, null,
                    1.0f, -1, false,
                    null, null, null, null, null,
                    null, false, null
                    );
                correspondingEdges[count] = edge;
                ++count;
            }

            bool[,] homNodes = new bool[numNodes, numNodes];
            for (int i = 0; i < numNodes; ++i)
            {
                for (int j = 0; j < numNodes; ++j)
                {
                    homNodes[i, j] = false;
                }
            }

            bool[,] homEdges = new bool[numEdges, numEdges];
            for (int i = 0; i < numEdges; ++i)
            {
                for (int j = 0; j < numEdges; ++j)
                {
                    homEdges[i, j] = false;
                }
            }

            bool[,] homNodesGlobal = new bool[numNodes, numNodes];
            for (int i = 0; i < numNodes; ++i)
            {
                for (int j = 0; j < numNodes; ++j)
                {
                    homNodesGlobal[i, j] = false;
                }
            }

            bool[,] homEdgesGlobal = new bool[numEdges, numEdges];
            for (int i = 0; i < numEdges; ++i)
            {
                for (int j = 0; j < numEdges; ++j)
                {
                    homEdgesGlobal[i, j] = false;
                }
            }

            bool[] totallyHomNodes = new bool[numNodes];
            for (int i = 0; i < numNodes; ++i)
            {
                totallyHomNodes[i] = false;
            }

            bool[] totallyHomEdges = new bool[numEdges];
            for (int i = 0; i < numEdges; ++i)
            {
                totallyHomEdges[i] = false;
            }

            List <PatternCondition> pcs = new List <PatternCondition>();

            for (int i = 0; i < numNodes; ++i)
            {
                if (nodes[i].Type.NumAttributes > 0)
                {
                    pcs.Add(new PatternCondition(new expression.AreAttributesEqual(correspondingNodes[i], nodes[i]),
                                                 new string[] { nodes[i].name }, new string[] { }, new string[] { },
                                                 new PatternNode[] { nodes[i] }, new PatternEdge[] { }, new PatternVariable[] { }));
                }
            }
            for (int i = 0; i < numEdges; ++i)
            {
                if (edges[i].Type.NumAttributes > 0)
                {
                    pcs.Add(new PatternCondition(new expression.AreAttributesEqual(correspondingEdges[i], edges[i]),
                                                 new string[] { }, new string[] { edges[i].name }, new string[] { },
                                                 new PatternNode[] { }, new PatternEdge[] { edges[i] }, new PatternVariable[] { }));
                }
            }
            PatternCondition[] patternConditions = pcs.ToArray();

            PatternGraph patternGraph = new PatternGraph(
                graph.Name,
                nodes, edges,
                patternConditions,
                homNodes, homEdges,
                homNodesGlobal, homEdgesGlobal,
                totallyHomNodes, totallyHomEdges,
                correspondingNodes, correspondingEdges
                );

            foreach (PatternNode node in nodes)
            {
                node.pointOfDefinition = patternGraph;
            }
            foreach (PatternEdge edge in edges)
            {
                edge.pointOfDefinition = patternGraph;
            }

            foreach (IEdge edge in graph.Edges)
            {
                int edgeIndex   = Array.IndexOf <IEdge>(correspondingEdges, edge);
                int sourceIndex = Array.IndexOf <INode>(correspondingNodes, edge.Source);
                int targetIndex = Array.IndexOf <INode>(correspondingNodes, edge.Target);
                patternGraph.edgeToSourceNode.Add(edges[edgeIndex], nodes[sourceIndex]);
                patternGraph.edgeToTargetNode.Add(edges[edgeIndex], nodes[targetIndex]);
            }

            PatternGraphAnalyzer.PrepareInline(patternGraph);

            return(patternGraph);
        }
Пример #2
0
        private static void AnalyzeAndInlineMatchingPatterns(bool inline,
            LGSPRuleAndMatchingPatterns ruleAndMatchingPatterns)
        {
            PatternGraphAnalyzer analyzer = new PatternGraphAnalyzer();
            foreach(LGSPMatchingPattern matchingPattern in ruleAndMatchingPatterns.RulesAndSubpatterns)
            {
                analyzer.AnalyzeNestingOfPatternGraph(matchingPattern.patternGraph, false);
                PatternGraphAnalyzer.PrepareInline(matchingPattern.patternGraph);
                analyzer.RememberMatchingPattern(matchingPattern);
            }
            
            analyzer.ComputeInterPatternRelations(false);
            foreach(LGSPMatchingPattern matchingPattern in ruleAndMatchingPatterns.RulesAndSubpatterns)
            {
                // computes patternpath information, thus only in original pass
                analyzer.AnalyzeWithInterPatternRelationsKnown(matchingPattern.patternGraph);
            }

            if(inline)
            {
                foreach(LGSPMatchingPattern matchingPattern in ruleAndMatchingPatterns.RulesAndSubpatterns)
                {
#if DUMP_PATTERNS
                        // dump patterns for debugging - first original version without inlining
                        SourceBuilder builder = new SourceBuilder(true);
                        matchingPattern.patternGraph.DumpOriginal(builder);
                        StreamWriter writer = new StreamWriter(matchingPattern.name + "_pattern_dump.txt");
                        writer.Write(builder.ToString());
#endif

                    analyzer.InlineSubpatternUsages(matchingPattern.patternGraph);

#if DUMP_PATTERNS
                        // - then inlined version
                        builder = new SourceBuilder(true);
                        matchingPattern.patternGraph.DumpInlined(builder);
                        writer.Write(builder.ToString());
                        writer.Close();
#endif
                }
            }

            // hardcore/ugly parameterization for inlined case, working on inlined members in inlined pass, and original members on original pass
            // working with accessors encapsulating the inlined versions and the original version behind a common interface to keep the analyze code without case distinctions gets terribly extensive
            foreach(LGSPMatchingPattern matchingPattern in ruleAndMatchingPatterns.RulesAndSubpatterns)
                matchingPattern.patternGraph.maxIsoSpace = 0; // reset of max iso space for computation of max iso space of inlined patterns
            foreach(LGSPMatchingPattern matchingPattern in ruleAndMatchingPatterns.RulesAndSubpatterns)
            {
                analyzer.AnalyzeNestingOfPatternGraph(matchingPattern.patternGraph, true);
            }

            analyzer.ComputeInterPatternRelations(true);
        }