ConsoleOut.cs

using System;
using System.IO;
using System.Text;
using System.Threading.Tasks;
using Waher.Runtime.Console.Worker;
using Waher.Runtime.Queue;
 
namespace Waher.Runtime.Console
{
    public delegate void CustomWriter(TextWriter Output);
 
    public delegate Task CustomAsyncWriter(TextWriter Output);
 
    public static class ConsoleOut
    {
        private static ConsoleColor foregroundColor = System.Console.ForegroundColor;
        private static ConsoleColor backgroundColor = System.Console.BackgroundColor;
 
        public static Encoding Encoding => System.Console.Out.Encoding;
 
        public static IFormatProvider FormatProvider => System.Console.Out.FormatProvider;
 
        public static string NewLine => System.Console.Out.NewLine;
 
        public static bool HasConsole
        {
            get
            {
                return !(
                    System.Console.IsOutputRedirected ||
                    System.Console.IsErrorRedirected ||
                    System.Console.IsInputRedirected ||
                    !Environment.UserInteractive);
            }
        }
 
        public static int WindowWidth => System.Console.WindowWidth;
 
        public static int WindowLeft => System.Console.WindowLeft;
 
        public static int WindowTop => System.Console.WindowTop;
 
        public static int WindowHeight => System.Console.WindowHeight;
 
        public static int CursorLeft => System.Console.CursorLeft;
 
        public static int CursorTop => System.Console.CursorTop;
 
        public static int CursorSize => System.Console.CursorSize;
 
        public static ConsoleColor ForegroundColor
        {
            get => foregroundColor;
            set
            {
                foregroundColor = value;
                ConsoleWorker.Forward(new ConsoleForegroundColor(value));
            }
        }
 
        public static ConsoleColor BackgroundColor
        {
            get => backgroundColor;
            set
            {
                backgroundColor = value;
                ConsoleWorker.Forward(new ConsoleBackgroundColor(value));
            }
        }
 
        public static void Write(string value)
        {
            if (!string.IsNullOrEmpty(value))
                ConsoleWorker.Forward(new ConsoleOutWriteString(value));
        }
 
        public static void Write(CustomWriter Writer)
        {
            Write(Writer, null, null);
        }
 
        public static void Write(CustomWriter Writer, ConsoleColor? ForegroundColor, ConsoleColor? BackgroundColor)
        {
            ConsoleWorker.Forward(new ConsoleOutCustomWriter(Writer, ForegroundColor, BackgroundColor));
        }
 
        public static void Write(ulong value)
        {
            Write(value.ToString());
        }
 
        public static void Write(uint value)
        {
            Write(value.ToString());
        }
 
        public static void Write(string format, params object[] arg)
        {
            Write(string.Format(format, arg));
        }
 
        public static void Write(string format, object arg0, object arg1, object arg2)
        {
            Write(string.Format(format, arg0, arg1, arg2));
        }
 
        public static void Write(string format, object arg0, object arg1)
        {
            Write(string.Format(format, arg0, arg1));
        }
 
        public static void Write(string format, object arg0)
        {
            Write(string.Format(format, arg0));
        }
 
        public static void Write(float value)
        {
            Write(value.ToString());
        }
 
        public static void Write(long value)
        {
            Write(value.ToString());
        }
 
        public static void Write(int value)
        {
            Write(value.ToString());
        }
 
        public static void Write(double value)
        {
            Write(value.ToString());
        }
 
        public static void Write(decimal value)
        {
            Write(value.ToString());
        }
 
        public static void Write(char[] buffer, int index, int count)
        {
            Write(new string(buffer, index, count));
        }
 
        public static void Write(char[] buffer)
        {
            Write(new string(buffer));
        }
 
        public static void Write(char value)
        {
            Write(new string(value, 1));
        }
 
        public static void Write(bool value)
        {
            Write(value.ToString());
        }
 
        public static void Write(object value)
        {
            if (!(value is null))
                Write(value.ToString());
        }
 
        public static async Task WriteAsync(string value)
        {
            if (!string.IsNullOrEmpty(value))
            {
                WorkItem Item = new ConsoleOutWriteString(value.ToString());
 
                if (!await ConsoleWorker.Forward(Item))
                    return;
 
                await Item.Wait();
            }
        }
 
        public static Task WriteAsync(char[] buffer, int index, int count)
        {
            return WriteAsync(new string(buffer, index, count));
        }
 
        public static Task WriteAsync(char[] buffer)
        {
            return WriteAsync(new string(buffer));
        }
 
        public static Task WriteAsync(char value)
        {
            return WriteAsync(new string(value, 1));
        }
 
        public static Task WriteAsync(CustomAsyncWriter Writer)
        {
            return WriteAsync(Writer, null, null);
        }
 
        public static async Task WriteAsync(CustomAsyncWriter Writer, ConsoleColor? ForegroundColor, ConsoleColor? BackgroundColor)
        {
            WorkItem Item = new ConsoleOutCustomAsyncWriter(Writer, ForegroundColor, BackgroundColor);
 
            if (!await ConsoleWorker.Forward(Item))
                return;
 
            await Item.Wait();
        }
 
        public static void WriteLine()
        {
            WriteLine(string.Empty);
        }
 
        public static void WriteLine(string value)
        {
            ConsoleWorker.Forward(new ConsoleOutWriteLineString(value));
        }
 
        public static void WriteLine(ulong value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(uint value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(string format, params object[] arg)
        {
            WriteLine(string.Format(format, arg));
        }
 
        public static void WriteLine(string format, object arg0, object arg1, object arg2)
        {
            WriteLine(string.Format(format, arg0, arg1, arg2));
        }
 
        public static void WriteLine(string format, object arg0, object arg1)
        {
            WriteLine(string.Format(format, arg0, arg1));
        }
 
        public static void WriteLine(float value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(string format, object arg0)
        {
            WriteLine(string.Format(format, arg0));
        }
 
        public static void WriteLine(long value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(int value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(double value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(decimal value)
        {
            WriteLine(value.ToString());
        }
 
        public static void WriteLine(char[] buffer, int index, int count)
        {
            WriteLine(new string(buffer, index, count));
        }
 
        public static void WriteLine(char[] buffer)
        {
            WriteLine(new string(buffer));
        }
 
        public static void WriteLine(char value)
        {
            WriteLine(new string(value, 1));
        }
 
        public static void WriteLine(object value)
        {
            if (!(value is null))
                WriteLine(value.ToString());
        }
 
        public static void WriteLine(bool value)
        {
            WriteLine(value.ToString());
        }
 
        public static async Task WriteLineAsync(string value)
        {
            WorkItem Item = new ConsoleOutWriteLineString(value ?? string.Empty);
 
            if (!await ConsoleWorker.Forward(Item))
                return;
 
            await Item.Wait();
        }
 
        public static Task WriteLineAsync()
        {
            return WriteLineAsync(string.Empty);
        }
 
        public static Task WriteLineAsync(char value)
        {
            return WriteLineAsync(new string(value, 1));
        }
 
        public static Task WriteLineAsync(char[] buffer)
        {
            return WriteLineAsync(new string(buffer));
        }
 
        public static Task WriteLineAsync(char[] buffer, int index, int count)
        {
            return WriteLineAsync(new string(buffer, index, count));
        }
 
        public static void Beep()
        {
            ConsoleWorker.Forward(new ConsoleBeep());
        }
 
        public static void Flush()
        {
            Flush(false);
        }
 
        public static void Flush(bool Terminate)
        {
            FlushAsync(Terminate).Wait();
        }
 
        public static Task FlushAsync()
        {
            return FlushAsync(false);
        }
 
        public static async Task FlushAsync(bool Terminate)
        {
            if (!ConsoleWorker.Terminating)
            {
                TaskCompletionSource<bool> Result = new TaskCompletionSource<bool>();
                if (await ConsoleWorker.Forward(new ConsoleFlush(Terminate, Result)))
                    await Result.Task;
            }
        }
 
        public static TextWriter Writer
        {
            get => new ConsoleOutTextWriter();
        }
 
        private class ConsoleOutTextWriter : TextWriter
        {
            public ConsoleOutTextWriter()
            {
            }
 
            public override Encoding Encoding => ConsoleOut.Encoding;
            public override void Flush() => ConsoleOut.Flush();
            public override Task FlushAsync() => ConsoleOut.FlushAsync();
            public override void Write(char value) => ConsoleOut.Write(value);
            public override void Write(ulong value) => ConsoleOut.Write(value);
            public override void Write(uint value) => ConsoleOut.Write(value);
            public override void Write(string format, params object[] arg) => ConsoleOut.Write(format, arg);
            public override void Write(string format, object arg0, object arg1, object arg2) => ConsoleOut.Write(format, arg0, arg1, arg2);
            public override void Write(string format, object arg0, object arg1) => ConsoleOut.Write(format, arg0, arg1);
            public override void Write(string format, object arg0) => ConsoleOut.Write(format, arg0);
            public override void Write(string value) => ConsoleOut.Write(value);
            public override void Write(float value) => ConsoleOut.Write(value);
            public override void Write(long value) => ConsoleOut.Write(value);
            public override void Write(int value) => ConsoleOut.Write(value);
            public override void Write(double value) => ConsoleOut.Write(value);
            public override void Write(decimal value) => ConsoleOut.Write(value);
            public override void Write(char[] buffer, int index, int count) => ConsoleOut.Write(buffer, index, count);
            public override void Write(char[] buffer) => ConsoleOut.Write(buffer);
            public override void Write(bool value) => ConsoleOut.Write(value);
            public override void Write(object value) => ConsoleOut.Write(value);
            public override Task WriteAsync(string value) => ConsoleOut.WriteAsync(value);
            public override Task WriteAsync(char[] buffer, int index, int count) => ConsoleOut.WriteAsync(buffer, index, count);
            public override Task WriteAsync(char value) => ConsoleOut.WriteAsync(value);
            public override void WriteLine() => ConsoleOut.WriteLine();
            public override void WriteLine(ulong value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(uint value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(string format, params object[] arg) => ConsoleOut.WriteLine(format, arg);
            public override void WriteLine(string format, object arg0, object arg1, object arg2) => ConsoleOut.WriteLine(format, arg0, arg1, arg2);
            public override void WriteLine(string format, object arg0, object arg1) => ConsoleOut.WriteLine(format, arg0, arg1);
            public override void WriteLine(string value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(float value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(string format, object arg0) => ConsoleOut.WriteLine(format, arg0);
            public override void WriteLine(long value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(int value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(double value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(decimal value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(char[] buffer, int index, int count) => ConsoleOut.WriteLine(buffer, index, count);
            public override void WriteLine(char[] buffer) => ConsoleOut.WriteLine(buffer);
            public override void WriteLine(char value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(object value) => ConsoleOut.WriteLine(value);
            public override void WriteLine(bool value) => ConsoleOut.WriteLine(value);
            public override Task WriteLineAsync() => ConsoleOut.WriteLineAsync();
            public override Task WriteLineAsync(char value) => ConsoleOut.WriteLineAsync(value);
            public override Task WriteLineAsync(char[] buffer, int index, int count) => ConsoleOut.WriteLineAsync(buffer, index, count);
            public override Task WriteLineAsync(string value) => ConsoleOut.WriteLineAsync(value);
        }
    }
}