public bool Merge(OutWriter statusWriter)
{
if (statusWriter == null)
{
throw new ArgumentNullException(nameof(statusWriter));
}
var options = new ProgressBarOptions
{
ProgressCharacter = '─',
ProgressBarOnBottom = true
};
using (var finalDocument = new PdfDocument())
{
using (var progressBar = new ProgressBar(_inputs.Count, "progress bar is on the bottom now", options))
{
for (var inputIndex = 0; inputIndex < _inputs.Count; inputIndex++)
{
AdfPdfFromInput(progressBar, statusWriter, inputIndex, finalDocument);
}
}
return(SaveFinalPdfWithStatus(statusWriter, finalDocument));
}
}
public override void Flush()
{
if (LastXact != null)
{
Out.AppendLine("))");
}
OutWriter.Write(Out.ToString());
OutWriter.Flush();
}
public static TX DumpChars(TX a)
{
var sb = new StringBuilder();
for (int ich = 0; ich < a.Length; ich++)
{
sb.AppendFormat("{0:X4} ", (short)a.Span[ich]);
}
OutWriter.WriteLine("ExprDumpChars: {0}", sb);
return(a);
}
private bool SaveFinalPdfWithStatus(OutWriter statusWriter, PdfDocument finalDocument)
{
try
{
statusWriter.WriteLine($"Saving to {_output}...");
return(SaveFinalPdf(statusWriter, finalDocument));
}
finally
{
statusWriter.WriteLine($"Done.");
}
}
private static void AddPageFromPdf(OutWriter statusWriter, PdfDocument finalDocument, PdfDocument pdfDoc, int pageIndex)
{
try
{
finalDocument.AddPage(pdfDoc.Pages[pageIndex]);
}
catch (Exception ex)
{
statusWriter.WriteLine(
$"[ERROR] An error occured while merging page {pageIndex + 1}: {ex.Message}. This page will be skipped.");
}
}
/// <summary>
/// Reads an option from <see cref="InReader"/>.
/// </summary>
/// <param name="prompt">A message to prompt the user with.</param>
/// <returns>
/// The option read from <see cref="InReader"/>.
/// </returns>
protected string ReadOption(string prompt)
{
string option;
do
{
OutWriter.Write($"{prompt}: ");
option = InReader.ReadLine();
} while (string.IsNullOrEmpty(option));
return(option);
}
public void Warning(String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
warningCount++;
OutWriter.Write("warning: ");
OutWriter.WriteLine(contents, args);
}
private static void AddPagesFromPdf(ProgressBar progressBar, OutWriter statusWriter, string pdf, PdfDocument finalDocument)
{
using (var pdfDoc = PdfReader.Open(pdf, PdfDocumentOpenMode.Import))
using (var childProgressBar = progressBar.Spawn(pdfDoc.PageCount, "Processing pages"))
{
for (var i = 0; i < pdfDoc.PageCount; i++)
{
childProgressBar.Tick($"Processing page {i+1}/{pdfDoc.PageCount}");
AddPageFromPdf(statusWriter, finalDocument, pdfDoc, i);
Thread.Sleep(50);
}
}
}
private void AdfPdfFromInput(ProgressBar progressBar, OutWriter statusWriter, int inputIndex, PdfDocument finalDocument)
{
var pdf = _inputs.ElementAt(inputIndex);
progressBar.Tick($"Processing {inputIndex + 1}/{_inputs.Count}: {pdf}..");
try
{
AddPagesFromPdf(progressBar, statusWriter, pdf, finalDocument);
}
catch (Exception ex)
{
statusWriter.WriteLine(
$"[ERROR] An error occured while merging: {ex.Message}. This pdf or some of its pages will be skipped.");
}
}
public void Warning(String filename, LexicalPosition pos, Severity severity, String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
warningCount++;
if (pos.Column == 0)
{
OutWriter.Write("{0}:{1}\twarning: ", filename, pos.Line);
}
else
{
OutWriter.Write("{0}:{1},{2}\twarning: ", filename, pos.Line, pos.Column);
}
OutWriter.WriteLine(contents, args);
}
private bool SaveFinalPdf(OutWriter statusWriter, PdfDocument finalDocument)
{
if (File.Exists(_output) && AskForOverride != null)
{
if (!AskForOverride(_output))
{
return(true);
}
}
try
{
finalDocument.Save(_output);
return(true);
}
catch (Exception ex)
{
statusWriter.WriteLine($"[ERROR] Unable to save final file: {ex.Message}");
return(false);
}
}
public static T Dump <T>(TX fmt, T a)
{
OutWriter.WriteLine(fmt.ToString(), a);
return(a);
}
public static T Dump <T>(T a)
{
OutWriter.WriteLine("ExprDump: {0}", a);
return(a);
}
public void HandleCommand(string cmd, string method, string argString)
{
if (string.IsNullOrEmpty(method) || method == "ToString")
{
OutWriter.WriteLine(ToString());
return;
}
if (method == "Cancel")
{
if (TokenSource == null)
{
throw new CommandException("No task to cancel.");
}
else if (Task?.IsCompleted == true)
{
throw new CommandException("Task has already completed.");
}
else if (TokenSource.IsCancellationRequested)
{
throw new CommandException("Task has already had cancellation requested.");
}
else
{
TokenSource.Cancel();
}
return;
}
if (Task?.IsCompleted == false)
{
throw new CommandException($"Programmer is busy. Current task: {LastCommand}");
}
var args = argString.Split(' ', StringSplitOptions.RemoveEmptyEntries);
Task t = null;
TokenSource = new CancellationTokenSource();
byte?stationID = args.Length >= 1 ? ParseStationID(args[0]) : null;
bool demandRelay = args.Length >= 2 && bool.TryParse(args[1], out var tmpDemandRelay) && tmpDemandRelay;
switch (method)
{
case "BulkUpload":
case "Bulk":
case "B":
case nameof(RemoteProgrammer.BulkUploadToStation):
if (stationID == null)
{
throw new CommandException($"BulkUpload requires station ID as first parameter (can be zero).");
}
t = Programmer.BulkUploadToStation(stationID.Value, demandRelay, TokenSource.Token);
break;
case "Complete":
case "CompleteUpload":
case "CU":
case nameof(RemoteProgrammer.CompleteUploadToStationAsync):
if (stationID == null)
{
throw new CommandException("CompleteUpload requires station ID as first parameter (cannot be zero).");
}
t = Programmer.CompleteUploadToStationAsync(stationID.Value, TokenSource.Token);
break;
case "Confirm":
case "CP":
case nameof(RemoteProgrammer.ConfirmProgramming):
if (stationID == null)
{
throw new CommandException("ConfirmProgramming requires stationID as first parameter (cannot be zero).");
}
Programmer.ConfirmProgramming(stationID.Value);
break;
case "Go":
case nameof(RemoteProgrammer.GoAsync):
if (args.Length < 1)
{
throw new CommandException("Go requires stationID list as first parameter (cannot contain zero).");
}
var stationIDs = args[0].Split(',').Select(str => byte.Parse(str));
TimeSpan timeout = TimeSpan.FromMinutes(5);
if (args.Length >= 2)
{
timeout = TimeSpan.FromSeconds(double.Parse(args[1]));
}
bool confirm = false;
if (args.Length >= 3)
{
confirm = bool.Parse(args[2]);
}
t = Programmer.GoAsync(stationIDs, demandRelay, timeout, confirm);
break;
case "Init":
case "I":
case nameof(RemoteProgrammer.InitUploadToStation):
if (stationID == null)
{
throw new CommandException("InitUpload requires stationID as first parameter (can be zero).");
}
Programmer.InitUploadToStation(stationID.Value, demandRelay);
break;
case "Query":
case "Q":
case nameof(RemoteProgrammer.QueryStationProgramming):
Programmer.QueryStationProgramming(stationID ?? 0);
break;
case "Timeout":
case nameof(RemoteProgrammer.ResponseTimeout):
if (args.Length < 1 || !double.TryParse(args[0], out var timeoutSeconds))
{
throw new CommandException("Cannot parse timeout seconds.");
}
Programmer.ResponseTimeout = TimeSpan.FromSeconds(timeoutSeconds);
break;
case "Interval":
case nameof(RemoteProgrammer.PacketInterval):
if (args.Length < 1 || !double.TryParse(args[0], out var intervalSeconds))
{
throw new CommandException("Cannot parse interval seconds.");
}
Programmer.PacketInterval = TimeSpan.FromSeconds(intervalSeconds);
break;
case "ReadRemote":
case nameof(RemoteProgrammer.ReadRemoteImageAsync):
if (stationID == null)
{
throw new CommandException("ReadRemote requires stationID as first parameter");
}
t = Programmer.ReadRemoteImageAsync(stationID.Value, TokenSource.Token)
.ContinueWith(task => File.WriteAllText(Path.ChangeExtension(Programmer.Fn, ".remote"),
task.Result.ToCsv(b => b.ToString("X2"), Environment.NewLine)));
break;
default:
throw new CommandException($"Command {cmd} not recognised.");
}
if (t == null)
{
TokenSource = null;
}
Task = t;
t?.ContinueWith(T =>
{
if (T.IsFaulted)
{
OutWriter.WriteLine($"{ID}: Exception performing: {LastCommand}");
OutWriter.WriteLine(T.Exception);
}
else if (T.IsCanceled)
{
OutWriter.WriteLine($"{ID}: Task canceled: {LastCommand}");
}
else
{
OutWriter.WriteLine($"{ID}: Task completed: {LastCommand}");
}
});
LastCommand = cmd;
}
