static void Main(String[] arguments)
{
var options = new Options();
var settings = new CommandLine.ParserSettings();
settings.IgnoreUnknownArguments = false;
CommandLine.Parser parser = new Parser(with => with.HelpWriter = Console.Error);
// Try to parse the command line arguments
if (parser.ParseArguments(arguments, options) == false)
{
// If we failed to parse print out the usage of this program
Console.Write(options.GetUsage());
return;
}
// Enable visuals
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try { Application.Run(new Main(options)); }
catch { }
}
static void Main(string[] args)
{
//(1)コマンドラインパーサーの初期化
ParserSettings setting = new ParserSettings();
setting.HelpWriter = Console.Error;
var parser = new Parser(setting);
//(2)オプション用クラスに引数を展開
var option = new ConsoleOption();
if (!parser.ParseArguments(args, option))
{
//パラメータに問題がある場合は、失敗ステータスで終了
Environment.Exit(1);
}
var filePath = System.IO.Path.GetFullPath(option.OutputDirPath);
var createYoutubeQRCode = new CreateYoutubeQRCodeLib.CreateYoutubeQRCode();
createYoutubeQRCode.TargetContentType = CreateYoutubeQRCodeLib.contentType.User;
createYoutubeQRCode.ConsumerKey = option.ClientID;
createYoutubeQRCode.ConsumerSecret = option.ClientSeacret;
createYoutubeQRCode.TargetFolderPath = filePath;
var t = createYoutubeQRCode.CreateQR();
t.Wait();
}
public Parser(ParserSettings settings)
{
Assumes.NotNull(settings, "settings", SR.ArgumentNullException_ParserSettingsInstanceCannotBeNull);
if (settings.Consumed)
{
throw new InvalidOperationException(SR.InvalidOperationException_ParserSettingsInstanceCanBeUsedOnce);
}
_settings = settings;
_settings.Consumed = true;
}
static void Main(string[] args)
{
var commandArgs = new CommandArgs();
var settings = new CommandLine.ParserSettings();
settings.IgnoreUnknownArguments = false;
CommandLine.Parser parser = new Parser(with => with.HelpWriter = Console.Error);
// Try to parse the command line arguments
if (parser.ParseArguments(args, commandArgs) == false)
{
// If we failed to parse print out the usage of this program
//Console.Write(commandArgs.GetUsage());
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new UnitTestForm());
return;
}
var unitTestRunner = new UnitTestRunner();
unitTestRunner.Run(commandArgs);
}
private Parser(bool singleton)
{
Settings = new ParserSettings(false, false, Console.Error)
{
ParsingCulture = CultureInfo.InvariantCulture
};
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandLine.Parser"/> class.
/// </summary>
public Parser()
{
_settings = new ParserSettings {
Consumed = true
};
}
private static StringComparison GetStringComparison(ParserSettings settings)
{
return(settings.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase);
}
internal Parser(ParserSettings settings)
{
this.settings = settings;
this.settings.Consumed = true;
}
private static StringComparison GetStringComparison(ParserSettings settings)
{
return settings.CaseSensitive ? StringComparison.Ordinal : StringComparison.OrdinalIgnoreCase;
}
static void Main(string[] args)
{
var options = new Options();
CommandLine.ParserSettings parserSettings = new ParserSettings();
parserSettings.HelpWriter = Console.Error;
CommandLine.Parser parser = new Parser(parserSettings);
if (parser.ParseArguments(args, options))
{
if (options.Verbose)
{
Console.WriteLine(options.Model);
Console.WriteLine(options.IP);
Console.WriteLine(options.Port);
}
}
else
{
Environment.Exit(1);
}
string output;
/*
string test1 = "{\"SettingInfo\":[{\"id\":40, \"name\":\"Boat Type\", \"type\":1, \"values\":[{\"id\":0, \"title\":\"Sailing\"}, {\"id\":1,\"title\":\"Fishing\"}, {\"id\":2, \"title\":\"Planing\" }]}]}";
RootSettingInfo rootSettingInfo1 = JsonConvert.DeserializeObject<RootSettingInfo>(test1);
string test2 = "{\"SettingInfo\":[{\"id\":1,\"name\":\"Backlight Level\",\"type\":2,\"low\":0,\"high\":10}]}";
RootSettingInfo rootSettingInfo2 = JsonConvert.DeserializeObject<RootSettingInfo>(test2);
string test3 = "{\"SettingInfo\":[{\"id\":2,\"name\":\"Night Mode\",\"type\":3}]}";
RootSettingInfo rootSettingInfo3 = JsonConvert.DeserializeObject<RootSettingInfo>(test3);
*/
Navico.NavicoDiscovery.MFD websocketMFD = null;
if ((options.IP == null) && (options.Port == null))
{
List<Navico.NavicoDiscovery.MFD> MFDList = new List<Navico.NavicoDiscovery.MFD>();
Thread newThread;
newThread = new Thread(() => Navico.NavicoDiscovery.ReceiveNewMessage(MFDList));
newThread.IsBackground = true;
newThread.Start();
newThread.Join();
foreach (Navico.NavicoDiscovery.MFD mfd in MFDList)
{
if (options.Model != null)
{
// if (string.Compare(mfd.Model, options.Model, true) != 0)
if (mfd.Model.IndexOf(options.Model) != 0)
{
continue;
}
}
if (options.IP != null)
{
// if (string.Compare(mfd.IP, options.IP, true) != 0)
if (mfd.IP.IndexOf(options.IP) != 0)
{
continue;
}
}
DbgOutput(string.Format("MFD: {0}\tModel: {1}\tIP: {2}", mfd.Name, mfd.Model, mfd.IP));
foreach (Navico.NavicoDiscovery.MFDService service in mfd.Services)
{
DbgOutput(string.Format("\tService: {0}\tVersion: {1}\tPort: {2}", service.Service, service.Version, service.Port));
if ((service.Service == "navico-nav-ws") /*|| (service.Service == "navico-navdata-websocket")*/)
{
if (websocketMFD == null)
{
websocketMFD = mfd;
websocketMFD.Services = null;
websocketMFD.Services = new NavicoDiscovery.MFDService[1];
websocketMFD.Services[0] = service;
}
}
}
}
if (websocketMFD == null)
{
return;
}
}
else
{
websocketMFD = new NavicoDiscovery.MFD();
websocketMFD.IP = options.IP;
websocketMFD.Services = new NavicoDiscovery.MFDService[1];
uint port = 2053;
if (!options.Port.IsNullOrEmpty())
{
port = Convert.ToUInt32(options.Port);
}
websocketMFD.Services[0] = new NavicoDiscovery.MFDService("navico-nav-ws", 0, port);
}
DbgOutput(string.Format("Connect to {0}:{1}", websocketMFD.IP, websocketMFD.Services[0].Port));
string wsURL;
wsURL = string.Format("ws://{0}:{1}", websocketMFD.IP, websocketMFD.Services[0].Port);
//wsURL = string.Format("ws://172.28.29.224:2053");
using (GoFree streamer = new GoFree(wsURL))
{
Listener l = new Listener(streamer);
l.Subscribe(streamer);
streamer.Connect();
Thread.Sleep(500);
Console.WriteLine("\nType \"exit\" to exit.\n");
string data;
if (options.RequestingAListOfDataIDs)
{
DbgOutput("Requesting a list of data IDs");
// data = "{\"DataListReq\":{\"group\":1}}";
// streamer.Write(data);
RootDataListReq rootDataListReq = new RootDataListReq();
rootDataListReq.DataListReq = new DataListReq();
foreach (eDataGroup dataGroup in System.Enum.GetValues(typeof(eDataGroup)))
{
rootDataListReq.DataListReq.group = (int)dataGroup;
data = JsonConvert.SerializeObject(rootDataListReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RequestFullInformationAboutADataValue)
{
DbgOutput("Request full information about a data value");
// data = "{\"DataInfoReq\":[40]}";
// streamer.Write(data);
foreach (eDataType dataType in System.Enum.GetValues(typeof(eDataType)))
{
RootDataInfoReq rootDataInfoReq = new RootDataInfoReq();
rootDataInfoReq.DataInfoReq = new List<int>();
rootDataInfoReq.DataInfoReq.Add((int)dataType);
data = JsonConvert.SerializeObject(rootDataInfoReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RequestingAValue)
{
DbgOutput("Requesting a value");
// data = "{\"DataReq\":[{\"id\":1,\"repeat\":false,\"inst\":0}]}";
// streamer.Write(data);
foreach (eDataType dataType in System.Enum.GetValues(typeof(eDataType)))
{
RootDataReq rootDataReq = new RootDataReq();
rootDataReq.DataReq = new List<DataReq>();
DataReq dataReq = new DataReq();
dataReq.id = (int)dataType;
rootDataReq.DataReq.Add(dataReq);
data = JsonConvert.SerializeObject(rootDataReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RequestASettingsGroup)
{
DbgOutput("Request a settings group");
// data = "{\"SettingListReq\":[{\"group\":1}]}";
// streamer.Write(data);
foreach (eDataGroup dataGroup in System.Enum.GetValues(typeof(eDataGroup)))
{
RootSettingListReq rootSettingListReq = new RootSettingListReq();
rootSettingListReq.SettingListReq = new List<SettingListReq>();
SettingListReq settingListReq = new SettingListReq();
settingListReq.groupId = (int)dataGroup;
rootSettingListReq.SettingListReq.Add(settingListReq);
data = JsonConvert.SerializeObject(rootSettingListReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RequestSettingInformation)
{
DbgOutput("Request setting information");
// data = "{\"SettingInfoReq\":[1]}";
// streamer.Write(data);
foreach (eSettingIDs setting in System.Enum.GetValues(typeof(eSettingIDs)))
{
RootSettingInfoReq rootSettingInfoReq = new RootSettingInfoReq();
rootSettingInfoReq.SettingInfoReq = new List<int>();
rootSettingInfoReq.SettingInfoReq.Add((int)setting);
data = JsonConvert.SerializeObject(rootSettingInfoReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RequestAListOfSettings)
{
DbgOutput("Request a list of settings");
// data = "{\"SettingReq\":{\"ids\":[1,2,3],\"register\":false}}";
// streamer.Write(data);
foreach (eSettingIDs setting in System.Enum.GetValues(typeof(eSettingIDs)))
{
RootSettingReq rootSettingReq = new RootSettingReq();
rootSettingReq.SettingReq = new SettingReq();
rootSettingReq.SettingReq.ids = new List<int>();
rootSettingReq.SettingReq.ids.Add((int)setting);
data = JsonConvert.SerializeObject(rootSettingReq);
streamer.Write(data);
}
Thread.Sleep(1000);
}
if (options.RegisterToReceiveAnEvent)
{
DbgOutput("Register to receive an event");
// data = "{\"EventReg\":[1,2]}";
// streamer.Write(data);
foreach (eEvents eventValue in System.Enum.GetValues(typeof(eEvents)))
{
RootEventReg rootEventReg = new RootEventReg();
rootEventReg.EventReg = new List<int>();
rootEventReg.EventReg.Add((int)eventValue);
data = JsonConvert.SerializeObject(rootEventReg);
streamer.Write(data);
}
Thread.Sleep(1000);
}
/*
if (true)
{
DbgOutput("Set event");
foreach (eEvents eventValue in System.Enum.GetValues(typeof(eEvents)))
{
RootEventSet rootEventSet = new RootEventSet();
rootEventSet.EventSet = new List<EventSet>();
EventSet eventSet = new EventSet();
eventSet.id = (int)eventValue;
eventSet.
rootEventSet.EventSet.Add(eventSet);
data = JsonConvert.SerializeObject(rootEventSet);
streamer.Write(data);
}
Thread.Sleep(1000);
}
*/
if (options.MOBEvent)
{
DbgOutput("MOB event");
RootEventSet rootEventSet = new RootEventSet();
rootEventSet.EventSet = new List<EventSet>();
EventSet eventSet = new EventSet();
eventSet.id = (int)eEvents.MOB;
eventSet.name = "MOB";
eventSet.active = true;
rootEventSet.EventSet.Add(eventSet);
data = JsonConvert.SerializeObject(rootEventSet);
streamer.Write(data);
Thread.Sleep(1000);
}
if (options.CreateAWaypoint)
{
DbgOutput("Create a waypoint");
RootEventSet rootEventSet = new RootEventSet();
rootEventSet.EventSet = new List<EventSet>();
EventSet eventSet = new EventSet();
eventSet.id = (int)eEvents.WaypointCreate;
eventSet.latitude = 50.9892;
eventSet.longitude = -1.4975;
eventSet.wpName = "Waypoint1";
rootEventSet.EventSet.Add(eventSet);
data = JsonConvert.SerializeObject(rootEventSet);
streamer.Write(data);
Thread.Sleep(1000);
}
if (options.ActivateSilenceAcknowledgeDeactivateAnAlarm)
{
DbgOutput("Activate/Silence/Acknowledge/Deactivate an alarm");
RootEventSet rootEventSet = new RootEventSet();
rootEventSet.EventSet = new List<EventSet>();
EventSet eventSet = new EventSet();
// eventSet.id = (int)eEvents.AlarmActivate;
eventSet.id = (int)eEvents.AlarmSilence;
// eventSet.id = (int)eEvents.AlarmAcknowledge;
// eventSet.id = (int)eEvents.AlarmDeactivate;
eventSet.alarmId = 5;
eventSet.alarmText = "Low Speed";
eventSet.severity = 1;
rootEventSet.EventSet.Add(eventSet);
data = JsonConvert.SerializeObject(rootEventSet);
streamer.Write(data);
Thread.Sleep(1000);
}
if (options.ResetATripLog)
{
DbgOutput("Reset a trip log");
RootEventSet rootEventSet = new RootEventSet();
rootEventSet.EventSet = new List<EventSet>();
EventSet eventSet = new EventSet();
eventSet.id = (int)eEvents.TripLogReset;
eventSet.inst = 0;
rootEventSet.EventSet.Add(eventSet);
data = JsonConvert.SerializeObject(rootEventSet);
streamer.Write(data);
Thread.Sleep(1000);
}
if (options.RegisterForVesselsId)
{
DbgOutput("Register for vessels (id)");
// data = "{\"TrafficReq\":{\"subscribe\":true,\"id\":12345,\"sourceType\":0}}";
// streamer.Write(data);
RootTrafficReq rootTrafficReq = new RootTrafficReq();
rootTrafficReq.TrafficReq = new TrafficReq();
rootTrafficReq.TrafficReq.subscribe = true;
rootTrafficReq.TrafficReq.id = 12345;
rootTrafficReq.TrafficReq.sourceType = 0;
data = JsonConvert.SerializeObject(rootTrafficReq);
streamer.Write(data);
Thread.Sleep(1000);
}
if (options.RegisterForVesselsType)
{
DbgOutput("Register for vessels (type)");
// data = "{\"TrafficReg\":[0,2]}";
// streamer.Write(data);
RootTrafficReg rootTrafficReg = new RootTrafficReg();
rootTrafficReg.TrafficReg = new List<int>();
rootTrafficReg.TrafficReg.Add(0);
rootTrafficReg.TrafficReg.Add(2);
data = JsonConvert.SerializeObject(rootTrafficReg);
streamer.Write(data);
}
while (true)
{
Thread.Sleep(500);
Console.Write("> ");
data = Console.ReadLine();
if (data == "exit")
{
break;
}
streamer.Write(data);
}
}
}
private static void ConfigureSettings(ParserSettings settings)
{
settings.MutuallyExclusive = true;
settings.HelpWriter = System.Console.Out;
}
static void Main(string[] args)
{
var config = new Config();
var settings = new CommandLine.ParserSettings(true, true, false, Console.Error);
var parser = new CommandLine.Parser(settings);
string inputPath = null, outputPath = null;
bool isExtract = false, isRawExtract = false, isCreate = false;
if (args.Length == 0)
{
// Don't try to parse zero arguments or else it results in an exception
Console.WriteLine(config.GetUsage());
Environment.Exit(-1);
}
if (parser.ParseArguments(args, config))
{
if (!String.IsNullOrWhiteSpace(config.InputFileRaw))
{
inputPath = config.InputFileRaw;
isRawExtract = true;
isExtract = true;
}
else if (!String.IsNullOrWhiteSpace(config.InputFile))
{
inputPath = config.InputFile;
isExtract = true;
}
else if (!String.IsNullOrWhiteSpace(config.InputFolder))
{
inputPath = config.InputFolder;
isCreate = true;
}
if (!String.IsNullOrWhiteSpace(config.OutputPath))
{
outputPath = config.OutputPath;
}
else
{
if (isCreate)
{
outputPath = inputPath + ".ctpk";
}
else
{
string basePath = Path.GetDirectoryName(inputPath);
string baseFilename = Path.GetFileNameWithoutExtension(inputPath);
if (!String.IsNullOrWhiteSpace(basePath))
{
baseFilename = Path.Combine(basePath, baseFilename);
}
outputPath = baseFilename;
}
}
}
if (isCreate)
{
Ctpk.Create(inputPath, outputPath);
}
else if (isExtract)
{
Ctpk.Read(inputPath, outputPath, isRawExtract);
}
else
{
Console.WriteLine("Could not find path or file '{0}'", args[0]);
}
}
private Parser(bool singleton)
{
Settings = new ParserSettings(false, false, Console.Error);
}
static int Main(string[] args)
{
var options = new Options();
string verb = "";
object subOptions = null;
var ps = new CommandLine.ParserSettings();
IUserCredentialApplication credential = new Auth.UserCredentialApplicationFromFile();
CommandLine.Parser parser = new CommandLine.Parser(new CommandLine.ParserSettings {
MutuallyExclusive = true,
CaseSensitive = false,
HelpWriter = Console.Error
});
parser = CommandLine.Parser.Default;
if (parser.ParseArguments(args, options, (_verb, _subOptions) =>
{
verb = _verb;
subOptions = _subOptions;
}))
{
(subOptions as BaseOptions).CommandLine = string.Join(" ", args);
switch (verb)
{
case "upload":
{
var uploadOptions = subOptions as UploadOptions;
if (!uploadOptions.Batch && string.IsNullOrWhiteSpace(uploadOptions.ModuleName))
{
Console.Error.Write(options.GetUsage("upload"));
return(-1);
}
var drive = new IO.Google.Drive(credential);
var uploader = new Uploader(drive);
uploader.Upload(uploadOptions);
}
break;
case "download":
{
var drive = new IO.Google.Drive(credential);
var downloader = new Downloader(drive);
downloader.Download(subOptions as DownloadOptions);
}
break;
case "diff":
{
var diffOptions = subOptions as DiffOptions;
var drive = new IO.Google.Drive(credential);
var folder = drive.FindFolder(diffOptions.GDriveFolder);
ITranslationModule localModule = IO.ResX.FromResX(diffOptions.ResXDir, diffOptions.ModuleName, "en");
var downloader = new Downloader(drive);
var xlsx = downloader.DownloadXlsx(diffOptions);
var _remoteModule = IO.XlsX.FromXLSX(diffOptions.FileName, "en", xlsx);
_remoteModule.Name = diffOptions.ModuleName;
ITranslationModule remoteModule = _remoteModule.FilterByTags(diffOptions.Tags);
TranslationModuleDiff diff = localModule.Diff(remoteModule);
var diffJson = Newtonsoft.Json.JsonConvert.SerializeObject(diff, Newtonsoft.Json.Formatting.Indented);
Console.OutputEncoding = System.Text.Encoding.UTF8;
Console.Write(diffJson);
if (diffOptions.HTML)
{
var htmlLogger = new HTMLConcatLogger();
diff.Print(htmlLogger);
var fileName = System.IO.Path.GetTempFileName() + ".html";
System.IO.File.WriteAllText(fileName, htmlLogger.HTML);
System.Diagnostics.Process.Start(fileName);
}
}
break;
case "patch":
{
var patchOptions = subOptions as PatchOptions;
//read patch data from stdin
Console.InputEncoding = System.Text.Encoding.UTF8;
var jsonReader = new System.Text.StringBuilder();
string s;
while ((s = Console.ReadLine()) != null)
{
jsonReader.AppendLine(s);
}
string json = jsonReader.ToString();
//string json = System.IO.File.ReadAllText(@".\diff");
var diff = Newtonsoft.Json.JsonConvert.DeserializeObject <TranslationModuleDiff>(json);
TranslationModule localModule = IO.ResX.FromResX(patchOptions.ResXDir, patchOptions.ModuleName, "en");
localModule.Patch(diff);
IO.ResX.ToResX(localModule, patchOptions.ResXDir);
}
break;
}
}
return(0);
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandLine.Parser"/> class.
/// </summary>
public Parser()
{
Settings = new ParserSettings();
}
private static ParserResult <T> MakeParserResult <T>(ParserResult <T> parserResult, ParserSettings settings)
{
return(DisplayHelp(
parserResult,
settings.HelpWriter,
settings.MaximumDisplayWidth));
}
/// <summary>
/// Initializes a new instance of the <see cref="Parser"/> class,
/// configurable with a <see cref="ParserSettings"/> object.
/// </summary>
/// <param name="settings">The <see cref="ParserSettings"/> object is used to configure
/// aspects and behaviors of the parser.</param>
public Parser(ParserSettings settings)
{
Assumes.NotNull(settings, "settings", SR.ArgumentNullException_CommandLineParserSettingsInstanceCannotBeNull);
Settings = settings;
}
static void Main(string[] args)
{
var commandArgs = new CommandArgs();
var settings = new CommandLine.ParserSettings();
settings.IgnoreUnknownArguments = false;
CommandLine.Parser parser = new Parser(with => with.HelpWriter = Console.Error);
// Try to parse the command line arguments
if (parser.ParseArguments(args, commandArgs) == false)
{
// If we failed to parse print out the usage of this program
Console.Write(commandArgs.GetUsage());
return;
}
bool createPackage = commandArgs.CreatePackage;
String packageOutDir = Path.Combine(commandArgs.OutDir, "ZeroLauncherPackage");
//don't delete the old folder if we aren't creating the package (as we're only adding the id file),
//but otherwise make sure the old content is deleted
if (createPackage)
{
DeleteDirectory(commandArgs.OutDir);
}
Directory.CreateDirectory(commandArgs.OutDir);
if (createPackage)
{
Directory.CreateDirectory(packageOutDir);
}
String launcherExePath = Path.Combine(commandArgs.ZeroOutDir, "ZeroLauncher.exe");
if (commandArgs.MajorId == -1)
{
commandArgs.MajorId = int.Parse(QueryMajorId(launcherExePath, commandArgs.SourceDir, commandArgs.MaxTimeout));
}
//always create the id file
CreateVersionIdFile(commandArgs.OutDir, commandArgs.MajorId);
if (createPackage)
{
CreatePackage(commandArgs.SourceDir, commandArgs.ZeroOutDir, commandArgs.OutDir, packageOutDir);
ZipPackage(packageOutDir, Path.Combine(commandArgs.OutDir, "ZeroLauncherPackage.zip"));
}
if (commandArgs.GenerateInstaller)
{
if (createPackage == false)
{
Console.WriteLine("Generate installer requires create package");
return;
}
CopyDirectory(packageOutDir, commandArgs.ZeroOutDir);
GenerateInstaller(commandArgs.SourceDir, commandArgs.ZeroOutDir, commandArgs.MajorId);
}
if (commandArgs.CreatePatch)
{
if (createPackage == false)
{
Console.WriteLine("Generate patch requires create package");
return;
}
GeneratePatch(commandArgs.SourceDir, packageOutDir, commandArgs.MajorId, commandArgs.OutDir);
}
//open the package folder
if (commandArgs.OpenExplorer && Directory.Exists(commandArgs.OutDir))
{
Process.Start(commandArgs.OutDir);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="CommandLine.Parser"/> class.
/// </summary>
public Parser()
{
_settings = new ParserSettings { Consumed = true };
}
private static ParserResult <T> MakeParserResult <T>(Func <ParserResult <T> > parseFunc, ParserSettings settings)
{
return(DisplayHelp(
HandleUnknownArguments(
parseFunc(),
settings.IgnoreUnknownArguments),
settings.HelpWriter));
}
/// <summary>
/// Initializes a new instance of the <see cref="Parser"/> class,
/// configurable with <see cref="ParserSettings"/> using a delegate.
/// </summary>
/// <param name="configuration">The <see cref="Action<ParserSettings>"/> delegate used to configure
/// aspects and behaviors of the parser.</param>
public Parser(Action<ParserSettings> configuration)
{
Assumes.NotNull(configuration, "configuration", SR.ArgumentNullException_ParserSettingsDelegateCannotBeNull);
_settings = new ParserSettings();
configuration.Invoke(Settings);
_settings.Consumed = true;
}
private Parser CreateTestParser(StringBuilder sb)
{
ParserSettings settings = new ParserSettings(new StringWriter(sb));
return new Parser(settings);
}
