Example #1
0
        public override CommandResult Execute()
        {
            Console.WriteLine("Entering loop.");

            var options = new LoopOptions
            {
                EndOfLineCommentCharacter = '#'
            };

            var keyBindingSet = ConsoleKeyBindingSet.CreateDefaultSet();

            keyBindingSet.Bind('c', ConsoleModifiers.Control, ConsoleInputOperation.Abort);

            ++_count;

            var parameters = new LoopInputOutputParameters
            {
                Prompt        = new ColoredString($"Loop{new string('>', _count)} ", ConsoleColor.Cyan),
                KeyBindingSet = keyBindingSet
            };

            new Loop <MainCommandType>(parameters, options).Execute();

            --_count;

            Console.WriteLine("Exited loop.");

            return(CommandResult.Success);
        }
Example #2
0
 public static ProcessResult <Clip[]> Apply(LoopOptions options, params Clip[] clips)
 {
     foreach (var clip in clips)
     {
         ClipUtilities.EnlargeClipByLooping(clip, options.Length * clip.Length);
     }
     return(new ProcessResult <Clip[]>(clips));
 }
 private bool Loop()
 {
     GenericButtonPress(loopOption);
     currentLoop     = (LoopOptions)(((int)currentLoop + 1) % 3);
     loopDisp.sprite = loopOptions[(int)currentLoop];
     if (currentLoop == LoopOptions.Shuffle)
     {
         ShuffleQueue();
     }
     return(false);
 }
Example #4
0
        public void LoopWithSimpleCommand()
        {
            var client = Substitute.For <ILoopClient>();

            client.ReadLine().Returns("DoSomething", string.Empty, "&DoSomething", (string)null);

            var options = new LoopOptions {
                EndOfLineCommentCharacter = '&'
            };

            new Loop <TestCommand>(client, options).Execute();
        }
Example #5
0
        public void TestThatCommandDependingOnInjectionExecutesWithInjection()
        {
            var client = Substitute.For <ILoopClient>();

            client.ReadLine().Returns(string.Empty, null);

            var parserOptions = new CommandLineParserOptions().With()
                                .ConfigureServices(s => s.AddSingleton(new InjectedObject()));
            var options = new LoopOptions {
                ParserOptions = parserOptions
            };
            var loop = new Loop(typeof(InjectionCommand), client, options: options);

            loop.Invoking(l => l.ExecuteOnce()).Should().NotThrow();
        }
Example #6
0
        static int Main(string[] args)
        {
            Console.WriteLine("Setting up logging...");

            var loggerFactory = new LoggerFactory()
                                .AddConsole(LogLevel.Debug);

            var logger = loggerFactory.CreateLogger <Program>();

            Console.WriteLine("Parsing...");

            var options = new CommandLineParserOptions().With()
                          .ConfigureServices(s => s.AddSingleton <ILogger>(logger));

            if (!CommandLineParser.TryParse(args, options, out ProgramArguments programArgs))
            {
                return(1);
            }

            Console.WriteLine("Successfully parsed; reserialized:");
            Console.WriteLine("    " + string.Join(" ", CommandLineParser.Format(programArgs)));

            Console.WriteLine("Executing...");

            CommandResult result;

            if (programArgs.Command != null)
            {
                result = programArgs.Command.Execute();
            }
            else
            {
                var loopOptions = new LoopOptions {
                    ParserOptions = options
                };
                var loop = new Loop(typeof(ProgramArguments.ToplevelCommandType), options: loopOptions);
                loop.Execute();

                result = CommandResult.Success;
            }

            loggerFactory.Dispose();

            Console.WriteLine($"Result: {result}");

            return(0);
        }
Example #7
0
        public void GetHelp()
        {
            var loopOptions = new LoopOptions
            {
                ParserOptions = new CommandLineParserOptions
                {
                    HelpOptions = new ArgumentSetHelpOptions().With()
                                  .TwoColumnLayout()
                }
            };

            var client = Substitute.For <ILoopClient>();

            client.ReadLine().Returns("Help", "Help help", "Help exit", (string)null);

            new Loop(typeof(TestCommand), client, options: loopOptions).Execute();
        }
Example #8
0
        private static void RunInteractiveShell()
        {
            using var system = ActorSystem.Create("virus-simulation");
            RegisterGlobalActors(system);

            var parserOptions = new CommandLineParserOptions().With()
                                .ConfigureServices(s => s.AddSingleton(system));

            var loopOptions = new LoopOptions {
                ParserOptions = parserOptions
            };

            var loop = new Loop(typeof(CommandList), options: loopOptions);

            Console.WriteLine("Virus simulation");
            loop.Execute();
            Console.WriteLine("Exiting the application...");
        }
Example #9
0
 /// <summary>
 /// Primary constructor.
 /// </summary>
 /// <param name="loopOptions">Loop options.</param>
 /// <param name="argSetAttrib">Argument set attribute.</param>
 public HelpCommand(LoopOptions loopOptions, ArgumentSetAttribute argSetAttrib)
 {
     _loopOptions   = loopOptions?.DeepClone() ?? new LoopOptions();
     _parserOptions = _loopOptions.ParserOptions ?? new CommandLineParserOptions();
     _argSetAttrib  = argSetAttrib;
 }
 private void ShuffleQueue()
 {
     currentLoop    = LoopOptions.Shuffle;
     shufflePointer = 0;
     shuffleOrder   = Enumerable.Range(0, tracks.Length).ToArray().Shuffle();
 }
Example #11
0
        private static void RunInteractively()
        {
            Console.WriteLine("Entering loop.");

            var options = new LoopOptions
            {
                EndOfLineCommentCharacter = '#'
            };

            var keyBindingSet = ConsoleKeyBindingSet.CreateDefaultSet();
            keyBindingSet.Bind('c', ConsoleModifiers.Control, ConsoleInputOperation.Abort);

            var parameters = new LoopInputOutputParameters
            {
                Prompt = new ColoredString("Loop> ", ConsoleColor.Cyan),
                KeyBindingSet = keyBindingSet
            };

            Loop<VerbType>.Execute(parameters, options);

            Console.WriteLine("Exited loop.");
        }
Example #12
0
 public void Loop(LoopOptions options)
 {
     event_base_loop(Handle, (int)options);
 }