示例#1
0
        public Command(string[] _args)
        {
            uo = new UrlOperations(this);
            args = _args;
            //create parser
            parser = new CMDLineParser();

            if(_args.Length != 0){
                urlOpt = parser.AddStringParameter("-url", "adress of the website", true);
                if("get".Equals(_args[0]) || "test".Equals(_args[0])){
                    if("get".Equals(_args[0])){
                        getOpt=true;
                        saveOpt = parser.AddStringParameter("-save", "save the content of the website", false);
                    }
                    if("test".Equals(_args[0])){
                        testOpt=true;
                        timesOpt = parser.AddIntParameter("-times", "number of time to load the website", true);
                        avgOpt = parser.AddBoolSwitch("-avg", "average time to load the website");
                    }
                    try{
                        //parse the command line
                        parser.Parse(args);
                    } catch (CMDLineParser.CMDLineParserException ex){
                        getHelp();
                        Console.WriteLine("Error: " + ex.Message);
                        return;
                    }
                    //replace argument list with remaining arguments
                    args = parser.RemainingArgs();
                } else {
                    getHelp();
                  	Console.WriteLine("Error: Missing Required option: 'get' or 'set'");
                  	return;
                }
            }
        }
示例#2
0
        public WorkInstruction(string[] CommandlineArguments)
        {
            //Set default values
            this.Execute = false;
            this.GenerateReport = false;
            this.DestinationFilepath = "";
            this.DestinationFormat = OutputFormatEnum.Unknown;

            CMDLineParser parser = new CMDLineParser();
            parser.throwInvalidOptionsException = true;

            //Add -Help option
            CMDLineParser.Option HelpOption = parser.AddBoolSwitch("-Help", "Displays help");
            HelpOption.AddAlias("/?");

            //Add -Run option
            CMDLineParser.Option RunOption = parser.AddBoolSwitch("-Run", "Required. Execute all files in compilation path");

            //Add -Path parameter
            CompilationPathOption PathParameter = new CompilationPathOption("-Path", "Compilation path to load scripts from", false);
            parser.AddOption(PathParameter);

            //Add -Format parameter
            ReportFormatOption FormatParameter = new ReportFormatOption("-Format", "Format of the report that should be generated (HTML, XML, JSON)", false);
            parser.AddOption(FormatParameter);

            //Add -Filename parameter
            FilenameOption FilenameParameter = new FilenameOption("-Filename", "Filename of the generated report", false);
            parser.AddOption(FilenameParameter);

            //Add -Text parameter
            CMDLineParser.Option TextParameter = parser.AddStringParameter("-Text", "Additional text to be included in generated report", false);
            //FilenameParameter.AddAlias("/Text");

            bool commandLineParsed = false;

            try
            {
                parser.Parse(CommandlineArguments);
                commandLineParsed = true;
            }
            catch (CMDLineParser.CMDLineParserException ex)
            {
                //That didn't worked...
                Console.WriteLine(ex.Message);
                Console.WriteLine("Use /? for help");
                Console.WriteLine();
            }

            if (commandLineParsed)
            {
                if (HelpOption.isMatched)
                {
                    Console.WriteLine(parser.HelpMessage());
                }
                else
                {
                    if (RunOption.isMatched == false)
                    {
                        //No -Run command, nothing to do.
                        Console.WriteLine("Missing -RUN option");
                        Console.WriteLine(parser.HelpMessage());
                    }
                    else
                    {
                        this.Execute = true;

                        //Check for PATH parameter is set and use default path if not
                        this.CompilationPath = OptionIsMatchedAndNotEmpty(PathParameter) ? PathParameter.Value.ToString() : Xteq5UIConstant.DefaultCompilationFolder;

                        //Check for FILENAME parameter if we should generate a report. Only if this is set, check the additonal parameters for the report
                        if (OptionIsMatchedAndNotEmpty(FilenameParameter))
                        {
                            this.GenerateReport = true;
                            this.DestinationFilepath = FilenameParameter.Value.ToString();

                            //Check for the FORMAT parameter and use HTML if not set
                            string reportFormatString = OptionIsMatchedAndNotEmpty(FormatParameter) ? FormatParameter.Value.ToString() : "HTML";

                            //This direct cast without any error checking is OK because FORMATPARAMETER already tried to parse it and will only be set if the value is OK
                            this.DestinationFormat = OutputFormatConverter.ParseReportFormat(reportFormatString);

                            this.UserText = OptionIsMatchedAndNotEmpty(TextParameter) ? TextParameter.Value.ToString() : "";

                        }

                        //All done!

                    }
                }
            }
        }
 public static bool TestOptionValue(string test, CMDLineParser parser, string[] testargs, CMDLineParser.Option opt, object val)
 {
     string testcomment = " - " + test + " - :";
     try
     {
         parser.Parse(testargs);
         if (opt.Value.Equals(val))
         {
             Console.WriteLine("\nTestOK: " + testcomment + printValue(opt));
             return true;
         }
         else
         {
             Console.WriteLine("\nTestFailed: " + testcomment + " Expected Value:" + val + "::Value found:" + opt.Value);
             return false;
         }
     }
     catch (CMDLineParser.CMDLineParserException pex)
     {
         Console.WriteLine("\nTestFailed: " + testcomment + pex.Message);
     }
     return false;
 }
 public static bool TestOption(string test,CMDLineParser parser,string[] testargs,CMDLineParser.Option opt)
 {
     string testcomment= " - " + test + " - :";
     try
     {
         parser.Parse(testargs);
         Console.WriteLine("\nTestOK: " + testcomment + printValue(opt));
         return true;
     }
     catch (CMDLineParser.CMDLineParserException pex)
     {
         Console.WriteLine("\nTestFailed: " + testcomment + pex.Message);
     }
     return false;
 }
        public static bool TestException(string test , CMDLineParser parser, string[] testargs, System.Type exceptionType)
        {
            string testcomment = " - " + test + " - :";
            try
            {
                parser.Parse(testargs);
                Console.WriteLine("\nTestFailed: " + testcomment);
            }
            catch (Exception ex)
            {

                if (ex.GetType() == exceptionType)
                {
                    Console.WriteLine("\nTestOK: "+ testcomment + "Caught Error: " + ex.Message);
                    return true;
                }
                else
                    Console.WriteLine("\nTestFailed: " + testcomment + ex.Message);
            }
            return false;
        }
示例#6
0
        static void Main(string[] args)
        {
            UnhandledExceptionManager.AddHandler(); // This allows ability to catch all unhandled exceptions in the program!

            Application.EnableVisualStyles();
            Application.SetCompatibleTextRenderingDefault(false);

            //create parser
            CMDLineParser parser = new CMDLineParser();
            parser.throwInvalidOptionsException = false;

            //add Options
            #region addOptions
            //add default help "-help",..
            parser.AddHelpOption();
            CMDLineParser.Option TouchInputFilenameOpt = parser.AddStringParameter("-l", "Left", false);
            CMDLineParser.Option TouchInputDirectoryOpt = parser.AddStringParameter("-r", "Right", false);
            CMDLineParser.Option TouchOutputFilenameOpt = parser.AddStringParameter("-f", "Forwards", false);
            CMDLineParser.Option TouchOutputReportFileOpt = parser.AddStringParameter("-b", "Backwards", false);
            #endregion

            if (args.Length > 0)
            {
                try
                {
                    parser.Parse(args);
                }
                catch (CMDLineParser.CMDLineParserException e)
                {
                    Console.WriteLine("Error: " + e.Message);
                    parser.HelpMessage();
                }

                //parser.Debug();

                #region Section dealing with Multiple Instances of iRobotKinect
                if (ApplicationMutex != null && MainForm.MainFormMutex == ApplicationMutex) // This is sent to us by another copy of the program! Assume it is the qlp file to load
                {
                    MainForm.CRMainForm.TopMost = true;
                    MessageBox.Show("Args passed to iRobotKinect by another instance are:" + args[0], "iRobotKinect Remote Message"); // NGE07252013
                    if (args != null)
                    {
                        if (args.Count() == 1)
                        {
                            MainForm.CRMainForm.CommandLineDrivenOpenPlate(args[0]);
                        }
                        else if (parser._matchedSwitches.Count == 0 && parser._unmatchedArgs.Count == 2 && System.IO.Path.GetFileName((string)args[0]) == "iRobotKinect.exe") // Assume it is the file to load               
                        {
                            MainForm.CRMainForm.CommandLineDrivenOpenPlate(args[1]);
                        }
                    }
                #endregion Section dealing with Multiple Instances of iRobotKinect

                    return;
                }

                Application.EnableVisualStyles(); // NGE07242014 // Changes default way buttons and controls are shown - commented out makes basic 3d button shading
                Application.SetCompatibleTextRenderingDefault(false);
                // NGE07252013 if (args != null)
                // NGE07252013     MessageBox.Show("A Application.Run(CRMainForm = new MainForm(args, parser))" + string.Join("\t", args));
                // NGE07252013 else
                // NGE07252013     MessageBox.Show("A Application.Run(CRMainForm = new MainForm(args, parser))");

                CRMainForm = new MainForm();
                Program.Menu_Cache.Add(CRMainForm.Handle);
                Application.Run(CRMainForm);
            }
            else
            {
                #region Section dealing with Multiple Instances of iRobotKinect
                if (MainForm.AllowForMultipleInstancesOfiRobotKinect == false)
                {
                    bool MutexOwner = false;

                    // This application wants initial ownership of the "iRobotKinect", if not, then iRobotKinect is already running
                    ApplicationMutex = new Mutex(true, DefaultMutexName, out MutexOwner);

                    int tryNumber = 0;
                    while (MutexOwner == false && tryNumber < 5)
                    {
                        Thread.Sleep(3000); // Sleep for 3 seconds to see if other instance has finished exiting
                        // Try 5 times, waiting 3 seconds between each try
                        ApplicationMutex = new Mutex(true, DefaultMutexName, out MutexOwner);
                        tryNumber++;
                    }

                    if (MutexOwner == false)
                    {
                        MessageBox.Show("iRobotKinect software is already running.", "Error - Unable To Run iRobotKinect", MessageBoxButtons.OK, MessageBoxIcon.Error);
                        return;
                    }
                }
                else
                {
                    bool TooManyInstancesRunning = false;
                    string currentMutexName = "", newMutexName = "";
                    if (RuniRobotKinectDueToMutexCondition(true, out TooManyInstancesRunning, ref currentMutexName, ref newMutexName) == false)
                        return;

                    string mutexName = "";
                    bool bRet = IsiRobotKinectAlreadyRunning(ref mutexName);

                    bool MutexOwner = false;
                    if (newMutexName == "" || currentMutexName == mutexName) // The initial instance of iRobotKinect
                    {
                        if (newMutexName == "")
                            MainForm.InitialInstanceMutexName = currentMutexName;
                        ApplicationMutex = new Mutex(true, currentMutexName, out MutexOwner);
                    }
                    else
                        ApplicationMutex = null;
                }
                #endregion Section dealing with Multiple Instances of iRobotKinect

                Application.EnableVisualStyles(); // NGE07242014 // Changes default way buttons and controls are shown - commented out makes basic 3d button shading
                Application.SetCompatibleTextRenderingDefault(false);
                SetMessageFiltering();
              
                SplashCurrentlyShown = false; // NGE12262011 Set to True if showing Splash Screen
                // Show the splash ASAP
                // NGE11202013 SplashScreen.ShowSplash();

                try
                {
                    CRMainForm = new MainForm();
                    Program.Menu_Cache.Add(CRMainForm.Handle);
                    Application.Run(CRMainForm);
                }
                catch (System.IO.FileNotFoundException excep)
                {
                    MessageBox.Show("Missing file is : " + excep.FileName);
                }
                //catch (Exception ex)
                //{
                //    string errorString = ex.Message;
                //    if (MainForm.ShowApplication) MessageBox.Show(errorString);
                //}
            }
        }