ConsoleIn.cs

using System;
using System.Threading.Tasks;
using Waher.Runtime.Console.Worker;
 
namespace Waher.Runtime.Console
{
    public static class ConsoleIn
    {
        public static int Peek()
        {
            return PeekAsync().Result;
        }
 
        public static async Task<int> PeekAsync()
        {
            TaskCompletionSource<int> Result = new TaskCompletionSource<int>();
            if (await ConsoleWorker.Queue(new ConsoleInPeekCharacter(Result)))
                return await Result.Task;
            else
                return -1;
        }
 
        public static int Read()
        {
            return ReadAsync().Result;
        }
 
        public static async Task<int> ReadAsync()
        {
            TaskCompletionSource<int> Result = new TaskCompletionSource<int>();
            if (await ConsoleWorker.Queue(new ConsoleInReadCharacter(Result)))
                return await Result.Task;
            else
                return -1;
        }
 
        public static int Read(char[] buffer, int index, int count)
        {
            return ReadAsync(buffer, index, count).Result;
        }
 
        public static async Task<int> ReadAsync(char[] buffer, int index, int count)
        {
            CheckArguments(buffer, index, count);
 
            TaskCompletionSource<int> Result = new TaskCompletionSource<int>();
            if (await ConsoleWorker.Queue(new ConsoleInRead(buffer, index, count, Result)))
                return await Result.Task;
            else
                return 0;
        }
 
        private static void CheckArguments(Array buffer, int index, int count)
        {
            if (buffer is null)
                throw new ArgumentNullException(nameof(buffer));
 
            if (index < 0)
                throw new ArgumentOutOfRangeException(nameof(index));
 
            if (count < 0)
                throw new ArgumentOutOfRangeException(nameof(count));
 
            if (index > buffer.Length)
                throw new ArgumentException(nameof(index));
 
            if (index + count > buffer.Length)
                throw new ArgumentException(nameof(count));
        }
 
        public static int ReadBlock(char[] buffer, int index, int count)
        {
            return ReadBlockAsync(buffer, index, count).Result;
        }
 
        public static async Task<int> ReadBlockAsync(char[] buffer, int index, int count)
        {
            CheckArguments(buffer, index, count);
 
            TaskCompletionSource<int> Result = new TaskCompletionSource<int>();
            if (await ConsoleWorker.Queue(new ConsoleInReadBlock(buffer, index, count, Result)))
                return await Result.Task;
            else
                return 0;
        }
 
        public static string ReadLine()
        {
            return ReadLineAsync().Result;
        }
 
        public static async Task<string> ReadLineAsync()
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
            if (await ConsoleWorker.Queue(new ConsoleInReadLine(Result)))
                return await Result.Task;
            else
                return null;
        }
 
        public static string ReadToEnd()
        {
            return ReadToEndAsync().Result;
        }
 
        public static async Task<string> ReadToEndAsync()
        {
            TaskCompletionSource<string> Result = new TaskCompletionSource<string>();
            if (await ConsoleWorker.Queue(new ConsoleInReadToEnd(Result)))
                return await Result.Task;
            else
                return string.Empty;
        }
 
        public static ConsoleKeyInfo ReadKey()
        {
            return ReadKeyAsync().Result;
        }
 
        public static ConsoleKeyInfo ReadKey(bool intercept)
        {
            return ReadKeyAsync(intercept).Result;
        }
 
        public static Task<ConsoleKeyInfo> ReadKeyAsync()
        {
            return ReadKeyAsync(false);
        }
 
        public static async Task<ConsoleKeyInfo> ReadKeyAsync(bool intercept)
        {
            TaskCompletionSource<ConsoleKeyInfo> Result = new TaskCompletionSource<ConsoleKeyInfo>();
            if (await ConsoleWorker.Queue(new ConsoleInReadKey(intercept, Result)))
                return await Result.Task;
            else
                return new ConsoleKeyInfo();
        }
 
    }
}