internal static void ComplexParsing(string[] args, bool shouldBeSuccessful, ComplexVerb1?expectedResult)
{
CliParser fp = new CliParserBuilder()
.AddVerb <ComplexVerb1>("default", verb =>
{
verb.HelpText = "My Test Verb";
verb.AddValue(x => x.RequiredValue, x => x.HelpText = "h");
verb.AddValue(x => x.ConvertedValue, x => x.HelpText = "h");
verb.AddValueNullable(x => x.OptionalValue, x => { x.DefaultValue = null; x.HelpText = "h"; });
verb.AddSwitch(x => x.Switch1, x => { x.ShortName = "s1"; x.LongName = "ss1"; x.HelpText = "h"; });
verb.AddSwitch(x => x.DefaultValueSwitch, x => { x.ShortName = "s2"; x.LongName = "ss2"; x.DefaultValue = true; x.HelpText = "h"; });
verb.AddSwitchCore(a => a.ConvertedSwitch, new Arguments.Config.NamedArgConfig <ComplexVerb1, string, bool>()
{
Converter = v => Converted <string, string> .Value(v.ToString()),
HelpText = "h",
ShortName = "s3",
LongName = "ss3"
});
verb.AddSwitchCore(a => a.DefaultValueConvertedSwitch, new Arguments.Config.NamedArgConfig <ComplexVerb1, string, bool>()
{
Converter = v => Converted <string, string> .Value(v.ToString()),
DefaultValue = "Default",
HelpText = "h",
ShortName = "s4",
LongName = "ss4"
});
verb.AddOption(x => x.RequiredOption, x => { x.ShortName = "o1"; x.LongName = "oo1"; x.HelpText = "h"; });
verb.AddOption(x => x.OptionalOption, x => { x.ShortName = "o2"; x.LongName = "oo2"; x.DefaultValue = "Default"; x.HelpText = "h"; });
verb.AddOption(x => x.ConvertedOption, x => { x.ShortName = "o3"; x.LongName = "oo3"; x.HelpText = "h"; });
}).Build();
IParseResult result = fp.Parse(args);
Assert.Equal(shouldBeSuccessful, result.Ok);
if (shouldBeSuccessful)
{
SuccessfulParse <ComplexVerb1> tResult = Assert.IsType <SuccessfulParse <ComplexVerb1> >(result);
Assert.NotNull(tResult.Object);
ComplexVerb1 x = tResult.Object !;
Assert.True(expectedResult !.RequiredValue == x.RequiredValue);
Assert.True(expectedResult.ConvertedValue == x.ConvertedValue);
Assert.True(expectedResult.OptionalValue == x.OptionalValue);
Assert.True(expectedResult.Switch1 == x.Switch1);
Assert.True(expectedResult.DefaultValueSwitch == x.DefaultValueSwitch);
Assert.True(expectedResult.ConvertedSwitch == x.ConvertedSwitch);
Assert.True(expectedResult.DefaultValueConvertedSwitch == x.DefaultValueConvertedSwitch);
Assert.True(expectedResult.RequiredOption == x.RequiredOption);
Assert.True(expectedResult.OptionalOption == x.OptionalOption);
Assert.True(expectedResult.ConvertedOption == x.ConvertedOption);
}
}
public void Cero()
{
string Expected = "Cero";
int data = 0;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Twenty_Four()
{
string Expected = "Twenty Four ";
int data = 24;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Ninety_Five()
{
string Expected = "Ninety Five ";
int data = 95;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Nineteen()
{
string Expected = "Nineteen ";
int data = 19;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Eleven()
{
string Expected = "Eleven ";
int data = 11;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Twenty_Eight()
{
Converted Test1 = new Converted();
string expected = "Twenty Eight ";
int data = 28;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void Fouty_Five()
{
Converted Test1 = new Converted();
string expected = "Fouty Five ";
int data = 45;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void Five_Hundred_Ninety_Nine()
{
Converted Test1 = new Converted();
string expected = "Five hundred Ninety Nine ";
int data = 599;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void One_hundred()
{
Converted Test1 = new Converted();
string expected = "One hundred ";
int data = 100;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void Cero()
{
Converted Test1 = new Converted();
string expected = "Cero";
int data = 0;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void Ninety_Nine()
{
Converted Test1 = new Converted();
string expected = "Ninety Nine ";
int data = 99;
Assert.AreEqual(expected, Test1.Chance(data));
}
public void One()
{
string Expected = "One ";
int data = 1;
Converted test1 = new Converted();
Assert.AreEqual(Expected, test1.Chance(data));
}
public void Ten()
{
Converted Test1 = new Converted();
string expected = "Ten ";
int data = 10;
Assert.AreEqual(expected, Test1.Chance(data));
}
/// <summary>
/// 触发异常的事件
/// </summary>
/// <param name="filePath"></param>
/// <param name="ex"></param>
protected virtual void FireConvertedEvent()
{
try
{
if (Converted != null)
{
Converted.Invoke(null, null);
}
}
catch (Exception)
{
//本demo忽略此异常
//throw;
}
}
/// <summary>
/// 触发转换结果对象
/// </summary>
/// <param name="filePath"></param>
/// <param name="result"></param>
protected virtual void FireConvertedEvent(String filePath, Boolean result)
{
try
{
if (Converted != null)
{
Converted.Invoke(null, new ConvertedEventArgs()
{
FilePath = filePath,
Result = result
});
}
}
catch (Exception ex)
{
FireExceptionEvent(filePath, ex);
}
}
public SequenceLayer(IEnumerable <IConversion> conversions, Action <ConversionArgs> callback = null) : base(callback)
{
_inputGateBlock = new BufferBlock <ConversionArgs>();
_transformBlocks = new List <TransformBlock <ConversionArgs, ConversionArgs> >();
_notifyBlock = new ActionBlock <ConversionArgs>(args => Converted?.BeginInvoke(this, args, null, null));
InnerConversions = conversions as IConversion[] ?? conversions.ToArray();
RegisterSequenceBlocks(InnerConversions);
_outputGateBlock = new BroadcastBlock <ConversionArgs>(args => (ConversionArgs)args.Clone());
_lastSequenceBlock.LinkTo(_outputGateBlock);
_inputGateBlock.LinkTo(_firstSequenceBlock);
_outputGateBlock.LinkTo(_notifyBlock);
InitGates(new EntryGateBlock(this, _inputGateBlock), new OutGateBlock(this, _outputGateBlock));
void RegisterSequenceBlocks(IEnumerable <IConversion> conversionCollection)
{
TransformBlock <ConversionArgs, ConversionArgs> prevTransformBlock = null;
foreach (var conversion in conversionCollection)
{
var newBlock = new TransformBlock <ConversionArgs, ConversionArgs>(args => conversion.Convert(args));
_transformBlocks.Add(newBlock);
if (prevTransformBlock == null)
{
prevTransformBlock = newBlock;
_firstSequenceBlock = newBlock;
}
else
{
prevTransformBlock.LinkTo(newBlock);
prevTransformBlock = newBlock;
}
}
_lastSequenceBlock = prevTransformBlock;
}
}
public void RegisterPlugins(CSharpConverter converter)
{
if (converter == null)
{
throw new ArgumentNullException(nameof(converter));
}
ConvertBegin.Clear();
AfterPreprocessing.Clear();
GetCSharpNameResolvers.Clear();
GetCSharpTypeResolvers.Clear();
GetCSharpContainerResolvers.Clear();
CompilationConverters.Clear();
CommentConverters.Clear();
EnumConverters.Clear();
EnumItemConverters.Clear();
ClassConverters.Clear();
FieldConverters.Clear();
FunctionConverters.Clear();
FunctionTypeConverters.Clear();
ParameterConverters.Clear();
TypedefConverters.Clear();
Converting.Clear();
Converted.Clear();
ConvertEnd.Clear();
RegisteredPlugins.Clear();
for (var index = Options.Plugins.Count - 1; index >= 0; index--)
{
var plugin = Options.Plugins[index];
if (RegisteredPlugins.Contains(plugin))
{
continue;
}
RegisteredPlugins.Add(plugin);
plugin.Register(converter, this);
}
}
public void Open(string path)
{
// Start reading file...
var lines = ReadLines(path);
// Find first "#Fields:..." row.
var marker = lines
.SkipWhile(line => line.Text.StartsWith("#") && !line.Text.StartsWith("#Fields:"))
.FirstOrDefault();
// if not found, it's not W3C log file, then open the path with "Open" verb and exit.
if ((marker.Text?.StartsWith("#Fields:") ?? false) == false)
{
Shell.Open(path);
Exit?.Invoke(this, EventArgs.Empty);
return;
}
// Generate .xlsx path as temporary file.
var xlsxPath = Path.Combine(Path.GetTempPath(), $"~{Guid.NewGuid():N}.xlsx");
// Convert from W3C text log file to .xlsx file.
using (var xlbook = new XLWorkbook())
using (var xlsheet = xlbook.AddWorksheet("Sheet1"))
{
// Query columns header texts and adjust date & time column.
var headers = marker.Text.Split(' ').Skip(1).ToList();
var colIndexOfDate = headers.IndexOf("date");
var colIndexOfTime = headers.IndexOf("time");
if (colIndexOfDate != -1 && colIndexOfTime != -1)
{
headers[colIndexOfDate] = "date-time";
headers.RemoveAt(colIndexOfTime);
xlsheet.Column(colIndexOfDate + 1).Style.NumberFormat.Format = "yyyy/mm/dd hh:mm:ss";
}
// Build column header on .xlsx
using (var headerRow = xlsheet.Row(1))
headers.Each((header, index) =>
{
headerRow.Cell(index + 1).Value = header;
});
xlsheet.SheetView.FreezeRows(1);
xlsheet.RangeUsed().SetAutoFilter();
// Enumerate all content lines, and write into .xlsx
var prevProgress = 0;
lines
.Where(line => !line.Text.StartsWith("#"))
.Each((line, lineIndex) =>
{
var newProgress = (int)Math.Ceiling(line.Progress * 100);
if (prevProgress != newProgress)
{
prevProgress = newProgress;
Progress?.Invoke(this, new ProgressEventArgs(newProgress));
}
// Adjust date & time column.
var values = line.Text.Split(' ').ToList();
if (colIndexOfDate != -1 && colIndexOfTime != -1)
{
values[colIndexOfDate] += " " + values[colIndexOfTime];
values.RemoveAt(colIndexOfTime);
}
using (var valueRow = xlsheet.Row(lineIndex + 1 + 1))
values.Each((value, colIndex) =>
{
valueRow.Cell(colIndex + 1).Value = value;
});
});
xlsheet.Columns().AdjustToContents(minWidth: 0, maxWidth: 100);
xlbook.SaveAs(xlsxPath);
}
// Open with "Open" verb for .xlsx file.
File.SetAttributes(xlsxPath, FileAttributes.ReadOnly);
Converted?.Invoke(this, EventArgs.Empty);
var xlapp = Shell.Open(xlsxPath);
xlapp?.WaitForExit();
// Sweep .xlsx as temporary file.
try
{
File.SetAttributes(xlsxPath, FileAttributes.Normal);
File.Delete(xlsxPath);
}
catch (Exception) { }
Exit?.Invoke(this, EventArgs.Empty);
}
/// <summary>
/// Provides access to the converted event.
/// </summary>
protected void OnConverted()
{
Converted.RaiseEvent(new ConvertEventArgs <BasketConversionPair>(GetBasketConversionPair(), false), this);
}
// We'll choose not to make a public version of this for ints, because what would that mean for empty bags? protected override int _CompareTo(object b) => Converted.CompareTo(b);
/// <summary>
/// Raises the Converted event and passes the ResultModel to subscribers.
/// </summary>
/// <param name="sender"></param>
/// <param name="newResult"></param>
protected virtual void OnNewResult(object sender, ResultModel newResult)
{
Converted?.Invoke(this, newResult);
}
public bool Contains(ID id)
{
return(!ReferenceEquals(id, null) && Converted.ContainsKey(id));
}
