/// <summary>
/// Reads from the stream until the external program is ended.
/// </summary>
private void StreamReaderThread_Error()
{
try
{
var reader = m_StdError;
while (true)
{
var logContents = reader.ReadLine();
if (logContents == null)
{
break;
}
// ensure only one thread writes to the log at any time
lock (LockObject)
{
if (Verbose)
{
ErrorWriter.WriteLine(logContents);
}
MemoryWriter.WriteLine(logContents);
}
}
lock (LockObject)
{
ErrorWriter.Flush();
MemoryWriter.Flush();
}
}
catch (Exception)
{
// just ignore any errors
}
}
// TODO: TBD: refactor this type of functionality to base class, i.e. ReportErrorLevel...
private bool TryReportErrorLevel(int level)
{
// TODO: TBD: perhaps an indexer would be great as well...
var descriptor = Levels.FirstOrDefault(x => x.ErrorLevel == level);
// TODO: TBD: perhaps, CanReport property?
// ReSharper disable once InvertIf
if (descriptor != null && !IsNullOrEmpty(descriptor.Description))
{
switch (level)
{
case Logger.CriticalLevel:
case Logger.ErrorLevel:
ErrorWriter.WriteLine(descriptor.Description);
break;
default:
Writer.WriteLine(descriptor.Description);
break;
}
}
// Error Level will have been Reported.
return(level != DefaultErrorLevel);
}
/// <summary>
/// Reads from the stream until the external program is ended.
/// </summary>
private void StreamReaderThread_Error()
{
StreamReader reader = _stdError;
bool doAppend = OutputAppend;
while (true)
{
string logContents = reader.ReadLine();
if (logContents == null)
{
break;
}
// ensure only one thread writes to the log at any time
lock (_lockObject) {
ErrorWriter.WriteLine(logContents);
if (Output != null)
{
StreamWriter writer = new StreamWriter(Output.FullName, doAppend);
writer.WriteLine(logContents);
doAppend = true;
writer.Close();
}
}
}
lock (_lockObject) {
ErrorWriter.Flush();
}
}
public void WriteError(string message)
{
HasLoggedErrors = true;
if (ErrorWriter != null)
{
ErrorWriter.WriteLine(message);
ErrorWriter.Flush();
}
}
private void WriteError(FileLineParseException pex)
{
if (ErrorWriter == null)
{
return;
}
ErrorWriter.WriteLine(pex.Context.FileName);
ErrorWriter.WriteLine(pex.Message);
}
public void Error(String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
errorCount++;
ErrorWriter.Write("compiler error: ");
ErrorWriter.WriteLine(contents, args);
}
public void Execute(ICommand command)
{
if (command != null)
{
SetUp(command);
HandleDependenciesOf(command);
command.Execute();
}
else
{
ErrorWriter.WriteLine(Messages.Error.NoCommandToExecute);
}
}
private void ReportException(Exception ex)
{
var exceptionLevel = 1;
while (ex != null)
{
ErrorWriter.WriteLine($"{exceptionLevel}: {ex.Message}");
ErrorWriter.WriteLine($"{exceptionLevel}: {ex.StackTrace}");
ex = ex.InnerException;
exceptionLevel++;
}
}
public override void Execute()
{
VerifyProperties();
InitializeAdapter();
var todaysPeople = Repository.Search(DateTime.Today.ToString());
if (todaysPeople.Any())
{
PresentTodaysPeople(todaysPeople);
}
else
{
ErrorWriter.WriteLine(Messages.Error.NoBirthdaysToday);
}
}
public override void Execute()
{
VerifyProperties();
var indexOfPersonToDelete = AskForIndexOfPersonToDelete();
var deleteSuccessful = DeletePersonOnIndex(indexOfPersonToDelete);
Writer.SkipLine();
if (deleteSuccessful)
{
Writer.WriteLine(Messages.Success.DeletedPerson, _deletedPersonName);
}
else
{
ErrorWriter.WriteLine(Messages.Error.DeleteFailed);
}
}
public ICommand AskForCommand()
{
try
{
TextWriter.Write(Messages.Instruction.ChooseCommand);
var command = CommandReader.ReadCommand();
TextWriter.WriteLine(Messages.Declaration.SelectedCommand, command.Name, command.Description);
TextWriter.SkipLine();
return(command);
}
catch (InvalidCommandException)
{
ErrorWriter.WriteLine(Messages.Error.InvalidCommand);
return(null);
}
}
/// <summary>
/// Parses arguments into settings and saves them.
/// </summary>
/// <param name="args">The arguments to parse.</param>
/// <param name="settings">The settings object.</param>
/// <returns>
/// Zero, if parsing was successful. Non-zero if there was an error while parsing.
/// </returns>
/// <exception cref="ArgumentNullException">
/// <paramref name="args"/> cannot be null.
/// </exception>
/// <exception cref="ArgumentNullException">
/// <paramref name="settings"/> cannot be null.
/// </exception>
public int Parse(string[] args, TSettings settings)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
if (settings == null)
{
throw new ArgumentNullException(nameof(settings));
}
var optionSet = new OptionSet();
var options = new TOptions();
OnParsing(settings.GetType(), optionSet, options);
try
{
var extraArgs = optionSet.Parse(args);
if (extraArgs.Any())
{
var first = extraArgs.First();
throw new OptionException($"'{first}' is not a valid option.", first);
}
}
catch (OptionException ex)
{
ErrorWriter.WriteLine($"{EntryAssemblyFileName}: {ex.Message}");
WriteUsage(optionSet);
return(1);
}
if (options.ShowHelp)
{
WriteUsage(optionSet);
return(0);
}
OnParsed(options, settings);
settings.Save();
Log.Info("Saved settings.");
return(0);
}
public override void Execute()
{
VerifyProperties();
InitializeAdapter();
var query = AskForSearchQuery();
var results = Repository.Search(query);
Writer.SkipLine();
if (results.Any())
{
Present(results);
}
else
{
ErrorWriter.WriteLine(Messages.Error.SearchGotNoResults);
}
}
public override void Execute()
{
VerifyProperties();
var name = GetPersonName();
var birthday = GetPersonBirthday();
var person = new Person(GenerateGuid(), name, birthday);
Repository.Insert(person, out bool successful);
Writer.SkipLine();
if (successful)
{
Writer.WriteLine(Messages.Success.AddedPerson);
}
else
{
ErrorWriter.WriteLine(Messages.Error.AddFailed);
}
}
public void Error(String filename, LexicalPosition pos, String contents, params object[] args)
{
if (enableLevel > 0)
{
return;
}
errorCount++;
if (pos.Column == 0)
{
ErrorWriter.Write("{0}:{1}\terror: ", filename, pos.Line);
}
else
{
ErrorWriter.Write("{0}:{1},{2}\terror: ", filename, pos.Line, pos.Column);
}
ErrorWriter.WriteLine(contents, args);
}
private void WriteUpdateFailedMessage()
{
ErrorWriter.WriteLine(Messages.Error.UpdateNameFailed);
}
/// <summary>
/// Writes an error to the log
/// </summary>
/// <param name="message">The message to be written</param>
public static void WriteError(ErrorData ED)
{
ErrorCount++;
ErrorWriter.WriteLine($"{ErrorCount}, {ED.FileName}, {ED.Sheet}, {ED.Table}, {ED.Message}, {ED.Severity}, {DateTime.Now}");
}
private void WriteEmptyRepositoryMessage()
{
ErrorWriter.WriteLine(Messages.Error.NoPeopleAdded);
}