//---------< adds getStrongComponent to messageDispatcher dictionary >------------------
        void getStrongComponent()
        {
            Func <CommMessage, CommMessage> getStrongComponent = (CommMessage msg) =>
            {
                localFileMgr.currentPath = "";
                CommMessage reply = new CommMessage(CommMessage.MessageType.reply);
                reply.to      = msg.from;
                reply.from    = msg.to;
                reply.command = "getStrongComponent";
                string[] args = new string[msg.arguments.Count];
                for (var i = 0; i < args.Length; ++i)
                {
                    args[i] = msg.arguments[i].ToString();
                }
                List <string> files     = ProcessFiles(args);
                Executive     executive = new Executive();
                executive.typeAnalysis(files);
                Repository repo = Repository.getInstance();
                executive.dependencyAnalysis(files);
                repo.dependencyTable.show();
                CsGraph <string, string> graph = executive.buildDependencyGraph();
                graph.strongComponents();
                foreach (var item in graph.strongComp)
                {
                    reply.arguments.Add("Strong Component " + (item.Key + 1).ToString() + ":");
                    foreach (var elem in item.Value)
                    {
                        reply.arguments.Add(elem.name);
                    }
                }
                return(reply);
            };

            messageDispatcher["getStrongComponent"] = getStrongComponent;
        }
Ejemplo n.º 2
0
        //----< processing starts here >---------------------------------
#if (TEST_EXECUTIVE)
        static void Main(string[] args)
        {
            Console.Write("\n  Dependency Analysis");
            Console.Write("\n =====================\n");

            Executive exec = new Executive();

            ShowCommandLine(args);

            // finding files to analyze

            FileUtilities.Navigate nav = new FileUtilities.Navigate();
            nav.Add("*.cs");
            nav.go(args[0]);  // read path from command line
            List <string> files = nav.allFiles;

            exec.typeAnalysis(files);

            Console.Write("\n  TypeTable Contents:");
            Console.Write("\n ---------------------");

            Repository repo = Repository.getInstance();

            repo.typeTable.show();
            Console.Write("\n");

            /////////////////////////////////////////////////////////////////
            // Pass #2 - Find Dependencies

            Console.Write("\n  Dependency Analysis:");
            Console.Write("\n ----------------------");

            exec.dependencyAnalysis(files);
            repo.dependencyTable.show();

            Console.Write("\n\n  building dependency graph");
            Console.Write("\n ---------------------------");

            CsGraph <string, string> graph = exec.buildDependencyGraph();

            graph.showDependencies();

            Console.Write("\n\n  Strong Components:");
            Console.Write("\n --------------------");
            graph.strongComponents();
            foreach (var item in graph.strongComp)
            {
                Console.Write("\n  component {0}", item.Key);
                Console.Write("\n    ");
                foreach (var elem in item.Value)
                {
                    Console.Write("{0} ", elem.name);
                }
            }
            Console.Write("\n\n");
            Console.Read();
        }
        public void StrongComponentResultFile(List <string> arguments, string sscresult)
        {
            Console.Write("\n------------------------------");
            Console.Write("\n STRONG COMPONENT");
            Console.Write("\n------------------------------");
            Repository rep = Repository.getInstance();

            typeTableAnanlsis(arguments, sscresult, false);
            DependencyResult(arguments, sscresult, false);
            CsGraph <string, string> graph = buildDependencyGraph();

            graph.strongComponents();
            if (File.Exists(sscresult))
            {
                using (var textWriter = new StreamWriter(sscresult, false))
                {
                    foreach (var item in graph.strongComp)
                    {
                        Console.Write("\n  component {0}", item.Key);
                        Console.Write("\n    ");
                        textWriter.Write("\n  component {0}", item.Key);
                        textWriter.Write("\n    ");
                        foreach (var elem in item.Value)
                        {
                            Console.Write("{0} ", elem.name);
                            textWriter.Write("{0} ", elem.name);
                        }
                    }
                }
            }
            else if (!File.Exists(sscresult))
            {
                File.Create(sscresult);
                TextWriter textwriter = new StreamWriter(sscresult);
                foreach (var item in graph.strongComp)
                {
                    Console.Write("\n  component {0}", item.Key);
                    Console.Write("\n    ");
                    textwriter.Write("\n  component {0}", item.Key);
                    textwriter.Write("\n    ");
                    foreach (var elem in item.Value)
                    {
                        Console.Write("{0} ", elem.name);
                        textwriter.Write("{0} ", elem.name);
                    }
                }
                textwriter.Close();
            }
        }
        //performs strong compoenent analysis
        void performStrongComp()
        {
            Func <CommMessage, CommMessage> performStrongComp = (CommMessage msg) =>
            {
                CommMessage reply = new CommMessage(CommMessage.MessageType.reply);
                reply.to      = msg.from;
                reply.from    = msg.to;
                reply.command = "performStrongComp";
                Executive exe = new Executive();
                foreach (var item in msg.arguments)
                {
                    string path = System.IO.Path.Combine(Environment.root, item);
                    string b    = System.IO.Path.GetFullPath(path);
                    exe.files.Add(b);
                }
                exe.typeAnalysis(exe.files);
                exe.dependencyAnalysis(exe.files);
                Repository repo = Repository.getInstance();
                repo.typeTable.show();
                repo.dependencyTable.show();
                Console.Write("\n\n  Building dependency graph");
                Console.Write("\n ---------------------------");

                CsGraph <string, string> graph = exe.buildDependencyGraph();
                graph.showDependencies();

                Console.Write("\n\n  Strong Components:");
                Console.Write("\n --------------------");
                graph.strongComponents();
                foreach (var item in graph.strongComp)
                {
                    Console.Write("\n  Component {0}", item.Key);
                    Console.Write("\n    ");
                    foreach (var elem in item.Value)
                    {
                        Console.Write("{0} ", elem.name);
                    }
                }
                strongCompToString(graph);
                Console.Write("\n\n");

                reply.arguments = strongCompMessage;

                return(reply);
            };

            messageDispatcher["performStrongComp"] = performStrongComp;
        }
        public void displaystrongcomponent(List <string> arguments, string displaytokenfile)
        {
            Repository repo = Repository.getInstance();

            TypeAnalys(arguments, displaytokenfile, false);
            DependencyAnalys(arguments, displaytokenfile, false);
            CsGraph <string, string> graph = buildDependencyGraph();

            graph.strongComponents();

            if (!File.Exists(displaytokenfile))
            {
                File.Create(displaytokenfile);
                TextWriter wr = new StreamWriter(displaytokenfile);
                foreach (var item in graph.strongComp)
                {
                    Console.Write("\n  component {0}", item.Key);
                    Console.Write("\n    ");
                    wr.Write("\n  component {0}", item.Key);
                    wr.Write("\n    ");
                    foreach (var elem in item.Value)
                    {
                        Console.Write("{0} ", elem.name);
                        wr.Write("{0} ", elem.name);
                    }
                }
                wr.Close();
            }
            else if (File.Exists(displaytokenfile))
            {
                using (var wr = new StreamWriter(displaytokenfile, false))
                {
                    foreach (var item in graph.strongComp)
                    {
                        Console.Write("\n  component {0}", item.Key);
                        Console.Write("\n    ");
                        wr.Write("\n  component {0}", item.Key);
                        wr.Write("\n    ");
                        foreach (var elem in item.Value)
                        {
                            Console.Write("{0} ", elem.name);
                            wr.Write("{0} ", elem.name);
                        }
                    }
                }
            }
        }