static void Main(string[] args)
{
// Setup static logger factory
ILoggerFactory loggerFactory = QboxNextLogProvider.LoggerFactory = new LoggerFactory();
ApplicationServiceProvider = new ServiceCollection()
.AddSingleton(loggerFactory)
.AddLogging()
.AddParsers()
.BuildServiceProvider();
var program = new Program();
var settings = new CommandLineParserSettings {
IgnoreUnknownArguments = true, CaseSensitive = false
};
ICommandLineParser parser = new CommandLineParser(settings);
if (parser.ParseArguments(args, program, System.Console.Error))
{
program.Run();
}
else
{
System.Console.WriteLine("Usage: QboxNext.ParseQboxMessage --message=<message>");
}
}
static void Main(string[] args)
{
// Setup static logger factory
QboxNextLogProvider.LoggerFactory = new NLogLoggerFactory();
Log.Info("Starting...");
// Make sure that the default parsing and formatting of numbers is using '.' as floating point.
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Log.Debug(string.Format("SimulateQbox {0}", System.Reflection.Assembly.GetExecutingAssembly().GetName().Version));
var settings = new CommandLineParserSettings {
IgnoreUnknownArguments = true, CaseSensitive = false
};
ICommandLineParser parser = new CommandLineParser(settings);
var options = new QboxSimulatorOptions();
if (parser.ParseArguments(args, options, Console.Error) && CheckArguments(options))
{
RunSimulators(options);
Log.Info("Finishing...");
}
else
{
Log.Error("invalid parameter usage");
}
Log.Info("Closing");
// Ensure to flush and stop internal timers/threads before application-exit (Avoid segmentation fault on Linux)
NLog.LogManager.Shutdown();
}
public static Options Create(string[] args, CommandLineParserSettings settings)
{
Options mailOptions = new Options();
ICommandLineParser parser = new CommandLineParser(settings);
parser.ParseArguments(args, mailOptions);
return(mailOptions);
}
private void CreateOptions()
{
options = new CommandLineOptions();
CommandLineParserSettings parserSettings = new CommandLineParserSettings();
CommandLineParser parser = new CommandLineParser(parserSettings);
parser.ParseArguments(args, options);
}
public void SettingHelpWriterUsingProperty()
{
var writer = new StringWriter();
var settings = new CommandLineParserSettings();
settings.HelpWriter = writer;
ICommandLineParser parser = new CommandLineParser(settings);
var options = new SimpleOptionsWithHelpOption();
bool success = parser.ParseArguments(new string[] { "--help" }, options);
Assert.AreEqual(false, success);
Assert.AreEqual("MockOptions::GetUsage()", writer.ToString());
}
public void Setting_help_writer_using_property()
{
var writer = new StringWriter();
var settings = new CommandLineParserSettings();
settings.HelpWriter = writer;
ICommandLineParser parser = new CommandLineParser(settings);
var options = new SimpleOptionsWithHelpOption();
bool success = parser.ParseArguments(new string[] { "--help" }, options);
success.Should().BeFalse();
writer.ToString().Should().Be("MockOptions::GetUsage()");
}
public OptionMap(int capacity, CommandLineParserSettings settings)
#endif
{
_settings = settings;
IEqualityComparer<string> comparer =
_settings.CaseSensitive ? StringComparer.Ordinal : StringComparer.OrdinalIgnoreCase;
_names = new Dictionary<string, string>(capacity, comparer);
_map = new Dictionary<string, OptionInfo>(capacity * 2, comparer);
if (_settings.MutuallyExclusive)
{
_mutuallyExclusiveSetMap = new Dictionary<string, MutuallyExclusiveInfo>(capacity, StringComparer.OrdinalIgnoreCase);
}
}
public void SettingHelpWriterUsingProperty()
{
var writer = new StringWriter();
var settings = new CommandLineParserSettings();
settings.HelpWriter = writer;
ICommandLineParser parser = new CommandLineParser(settings);
var options = new SimpleOptionsWithHelpOption();
bool success = parser.ParseArguments(new string[] { "--help" }, options);
Assert.AreEqual(false, success);
Assert.AreEqual("MockOptions::GetUsage()", writer.ToString());
}
/// <summary>
/// Parses the arguments.
/// </summary>
/// <param name='args'>
/// The command line arguments.
/// </param>
/// <returns>
/// The parsed arguments.
/// </returns>
private static T ParseArguments(string[] args)
{
T arguments = new T();
var parserSettings = new CommandLineParserSettings();
parserSettings.CaseSensitive = true;
parserSettings.HelpWriter = System.Console.Out;
var parser = new CommandLineParser(parserSettings);
parser.ParseArguments(args, arguments);
return(arguments);
}
private static IContainer CreateContainer()
{
var settings = new CommandLineParserSettings<ISubCommand> { EnableYaclopsCommands = true };
ContainerBuilder builder = new ContainerBuilder();
// Command-line specific stuff
builder.RegisterAssemblyTypes(Assembly.GetExecutingAssembly())
.Where(t => typeof(ISubCommand).IsAssignableFrom(t) && t.IsPublic)
.SingleInstance()
.As<ISubCommand>();
builder.RegisterType<CommandLineParser>().WithParameter("settings", settings);
return builder.Build();
}
static void Main(string[] args)
{
var program = new Program();
var settings = new CommandLineParserSettings {
IgnoreUnknownArguments = true, CaseSensitive = false
};
ICommandLineParser parser = new CommandLineParser(settings);
if (parser.ParseArguments(args, program, System.Console.Error))
{
program.Run();
}
else
{
Console.WriteLine("Usage: QboxNext.MergeQbx --original=<path to original QBX file> --new=<path to new QBX file>");
}
}
public static OptionMap Create(object target, CommandLineParserSettings settings)
{
var list = ReflectionUtil.RetrievePropertyList<BaseOptionAttribute>(target);
if (list == null)
{
return null;
}
var map = new OptionMap(list.Count, settings);
foreach (var pair in list)
{
if (pair.Left != null && pair.Right != null)
{
map[pair.Right.UniqueName] = new OptionInfo(pair.Right, pair.Left);
}
}
map.RawOptions = target;
return map;
}
static void Main(string[] args)
{
try
{
var globals = new GlobalSettings();
var settings = new CommandLineParserSettings<ISampleCommand>
{
ProgramName = "MyApp"
};
var parser = ParserBuilder<ISampleCommand>.FromCommands(Assembly.GetExecutingAssembly())
.WithGlobals(globals)
.WithSettings(settings)
.Build();
var command = parser.Parse(args);
if (globals.ShowLogo)
{
PrintLogo();
}
if (command != null)
{
command.Dump();
}
}
catch (CommandLineParserException ex)
{
Console.WriteLine(ex.Message);
}
catch (Exception ex)
{
Console.WriteLine("Unhandled exception in main.");
Console.WriteLine(ex);
}
if (Debugger.IsAttached)
{
Console.Write("<press ENTER to continue>");
Console.ReadLine();
}
}
[STAThread] // おまじない
static void Main(string[] args)
{
// コマンドライン引数の情報を入れる構造体
var param = new IPParams();
//コマンドライン引数の解析
var setting = new CommandLineParserSettings(Console.Error);
var paser = new CommandLineParser(setting);
//パースに失敗した場合停止
if (!paser.ParseArguments(args, param))
{
Environment.Exit(1);
}
var executor = new ImageProcessRunner(param);
executor.Start();
}
static void Main(string[] args)
{
// Setup static logger factory
QboxNextLogProvider.LoggerFactory = new LoggerFactory();
var program = new Program();
var settings = new CommandLineParserSettings {
IgnoreUnknownArguments = true, CaseSensitive = false
};
ICommandLineParser parser = new CommandLineParser(settings);
if (parser.ParseArguments(args, program, System.Console.Error))
{
program.Run();
}
else
{
System.Console.WriteLine("Usage: QboxNext.DumpQbx --qbx=<path> [--values]");
}
}
public static OptionMap CreateMap(object target,
IList<Pair<PropertyInfo, VerbOptionAttribute>> verbs, CommandLineParserSettings settings)
{
var map = new OptionMap(verbs.Count, settings);
foreach (var verb in verbs)
{
var optionInfo = new OptionInfo(verb.Right, verb.Left)
{
HasParameterLessCtor = verb.Left.PropertyType.GetConstructor(Type.EmptyTypes) != null
};
if (!optionInfo.HasParameterLessCtor && verb.Left.GetValue(target, null) == null)
{
throw new CommandLineParserException(string.Format("Type {0} must have a parameterless constructor or" +
" be already initialized to be used as a verb command.", verb.Left.PropertyType));
}
map[verb.Right.UniqueName] = optionInfo;
}
map.RawOptions = target;
return map;
}
public void ShouldBeAbleToCreateNewOptionsFromArgsAndSpecifyingCommandLineParserSettings()
{
string[] args = new string[] { "-h" };
StringWriter writer = new StringWriter();
CommandLineParserSettings settings = new CommandLineParserSettings(writer);
StringBuilder expectedHelpText = new StringBuilder();
expectedHelpText.AppendLine(String.Format("CommandLine Utility to send email using SMTP protocol {0}", System.Environment.NewLine));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "f", "from".PadRight(15, ' '), "From address"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "t", "to".PadRight(15, ' '), "To address seperated by comma"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "c", "cc".PadRight(15, ' '), "Cc address seperated by comma"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "b", "bcc".PadRight(15, ' '), "Bcc address seperated by comma"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "s", "subject".PadRight(15, ' '), "Subject for the email"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "m", "body".PadRight(15, ' '), "Email body"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "a", "attachment".PadRight(15, ' '), "Files to be attached seperated by comma"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "l", "configration".PadRight(15, ' '), "Mail client configuration file"));
expectedHelpText.AppendLine(String.Format("-{0} -{1}{2}", "g", "generate".PadRight(15, ' '), "Generates sample configuration file"));
Options option = Options.Create(args, settings);
Assert.AreEqual(expectedHelpText.AppendLine().ToString(), writer.ToString());
}
static void Main(string[] args)
{
try
{
var globals = new GlobalSettings();
var settings = new CommandLineParserSettings<ISubCommand>
{
ProgramName = "ConMan"
};
GlobalParser parser = new GlobalParser(settings);
parser.AddGlobalOptions(globals);
if (parser.Parse(args))
{
globals.Execute();
}
}
catch (CommandLineParserException ex)
{
Console.WriteLine(ex.Message);
}
}
static void Main(string[] args)
{
Options options = new Options();
CommandLineParserSettings parserSettings = new CommandLineParserSettings();
parserSettings.CaseSensitive = true;
CommandLineParser parser = new CommandLineParser(parserSettings);
if (!parser.ParseArguments(args, options, Console.Error))
{
return;
}
var config = new CouchbaseClientConfiguration();
config.Bucket = options.Bucket;
var url = "http://";
if (!options.Hostname.Contains(":"))
{
options.Hostname += ":8091";
}
url += options.Hostname + "/pools";
config.Urls.Add(new Uri(url));
Console.Error.WriteLine("URL: " + url + ", Bucket: " + config.Bucket);
Console.Error.WriteLine("Design: " + options.Design + ", View: " + options.View);
CouchbaseClient cli = new CouchbaseClient(config);
var res = cli.ExecuteStore(Enyim.Caching.Memcached.StoreMode.Set, "foo", "bar");
Console.WriteLine("Store result ? {0}", res.Success);
var view = cli.GetView(options.Design, options.View);
if (options.Group)
{
view.Group(options.Group);
}
if (options.GroupLevel > 0)
{
view.GroupAt(options.GroupLevel);
}
if (options.Range != null)
{
if (options.Range.Count > 2)
{
Console.Error.WriteLine("Too many keys in range (use -R for compount keys)");
return;
}
if (!String.IsNullOrEmpty(options.Range[0]))
{
view.StartKey(options.Range[0]);
}
if (!String.IsNullOrEmpty(options.Range[1]))
{
view.EndKey(options.Range[1]);
}
}
else if (options.CompoundRanges != null)
{
IList <string> sk = null, ek = null;
int firstIx = options.CompoundRanges.IndexOf(":");
if (firstIx == -1)
{
Console.Error.WriteLine("Malformed compound range");
return;
}
if (firstIx == 0)
{
ek = options.CompoundRanges.Skip(1).ToList();
}
else if (firstIx == options.CompoundRanges.Count - 1)
{
sk = options.CompoundRanges.Take(
options.CompoundRanges.Count - 1).ToList();
}
else
{
sk = options.CompoundRanges.Take(firstIx).ToList();
ek = options.CompoundRanges.Skip(firstIx + 1).ToList();
}
if (sk != null)
{
Console.Error.WriteLine("Using start key " +
new JavaScriptSerializer().Serialize(sk));
view.StartKey(sk);
}
if (ek != null)
{
if (ek[0].StartsWith("+"))
{
ek[0] = new String(ek[0].Skip(1).ToArray());
view.WithInclusiveEnd(true);
}
Console.Error.WriteLine("Using end key " +
new JavaScriptSerializer().Serialize(ek));
view.EndKey(ek);
}
}
if (options.Limit > 0)
{
view = view.Limit(options.Limit);
}
if (options.Fresh)
{
view.Stale(StaleMode.False);
}
try
{
DoExecuteView(view);
}
catch (WebException exc)
{
Console.WriteLine(exc);
}
}
static void Main(string[] args)
{
CbcOptions options = new CbcOptions();
CommandLineParserSettings settings = new CommandLineParserSettings();
settings.CaseSensitive = true;
CommandLineParser parser = new CommandLineParser(settings);
if (!parser.ParseArguments(args, options, System.Console.Error))
{
return;
}
options.Process();
var config = new CouchbaseClientConfiguration();
config.Bucket = options.Bucket;
config.Username = options.Username;
config.Password = options.Password;
config.BucketPassword = options.BucketPassword;
string uriString = "http://" + options.Hostname + "/pools";
System.Console.WriteLine("URI: " + uriString);
config.Urls.Add(new UriBuilder(uriString).Uri);
DateTime begin = DateTime.Now;
CouchbaseClient cli = new CouchbaseClient(config);
System.Console.WriteLine("Created new client..");
if (!commandMap.ContainsKey(options.Command))
{
throw new ArgumentException("Unknown command!");
}
Type t = commandMap[options.Command];
Type[] proto =
{
typeof(CouchbaseClient),
typeof(string),
typeof(CbcOptions)
};
object[] cargs =
{
cli,
options.Key,
options
};
CommandBase cmd = (CommandBase)t.GetConstructor(proto).Invoke(cargs);
cmd.Execute();
var duration = DateTime.Now - begin;
Console.WriteLine(
String.Format("Duration was {0:F} Sec.", duration.TotalMilliseconds / 1000));
}
private OptionMap(int capacity, CommandLineParserSettings settings)
