chylex/Query
1
0
Fork 0
mirror of https://github.com/chylex/Query.git synced 2025-05-05 02:34:08 +02:00
Code

Fix Rider inspections

Browse Source
This commit is contained in:
chylex 2024-07-29 18:09:24 +02:00
parent 356d66121b
commit 4e950b73a3
Signed by: chylex
GPG Key ID: 4DE42C8F19A80548
35 changed files with 1429 additions and 1450 deletions

389
AppCalc/App.cs
View File

@ -6,236 +6,243 @@ using System.Text;
using System.Text.RegularExpressions;
using Base;
namespace AppCalc {
public sealed class App : IApp {
private static readonly Regex RegexValidCharacters = new Regex(@"^[\s\d\.\-+*/%^]+$", RegexOptions.Compiled);
private static readonly Regex RegexTokenSeparator = new Regex(@"((?<!\d)-?(((\d+)?\.\d+(\.\.\.)?)|\d+))|[^\d\s]", RegexOptions.ExplicitCapture | RegexOptions.Compiled);
private static readonly Regex RegexRecurringDecimal = new Regex(@"\b(?:(\d+?\.\d{0,}?)(\d+?)\2+|([\d+?\.]*))\b", RegexOptions.Compiled);
namespace AppCalc;
private static readonly char[] SplitSpace = { ' ' };
public sealed partial class App : IApp {
private static readonly Regex RegexValidCharacters = GetRegexValidCharacters();
private static readonly Regex RegexTokenSeparator = GetRegexTokenSeparator();
private static readonly Regex RegexRecurringDecimal = GetRegexRecurringDecimal();
public string[] RecognizedNames => new string[] {
"calc",
"calculate",
"calculator"
};
[GeneratedRegex(@"^[\s\d\.\-+*/%^]+$", RegexOptions.Compiled)]
private static partial Regex GetRegexValidCharacters();
public MatchConfidence GetConfidence(Command cmd) {
return RegexValidCharacters.IsMatch(cmd.Text) ? MatchConfidence.Possible : MatchConfidence.None;
[GeneratedRegex(@"((?<!\d)-?(((\d+)?\.\d+(\.\.\.)?)|\d+))|[^\d\s]", RegexOptions.ExplicitCapture | RegexOptions.Compiled)]
private static partial Regex GetRegexTokenSeparator();
[GeneratedRegex(@"\b(?:(\d+?\.\d{0,}?)(\d+?)\2+|([\d+?\.]*))\b", RegexOptions.Compiled)]
private static partial Regex GetRegexRecurringDecimal();
private static readonly char[] SplitSpace = [ ' ' ];
public string[] RecognizedNames => [
"calc",
"calculate",
"calculator"
];
public MatchConfidence GetConfidence(Command cmd) {
return RegexValidCharacters.IsMatch(cmd.Text) ? MatchConfidence.Possible : MatchConfidence.None;
}
string IApp.ProcessCommand(Command cmd) {
return ParseAndProcessExpression(cmd.Text);
}
private static string ParseAndProcessExpression(string text) {
// text = RegexBalancedParentheses.Replace(text, match => " "+ParseAndProcessExpression(match.Groups[1].Value)+" "); // parens are handled as apps
string expression = RegexTokenSeparator.Replace(text, static match => " " + match.Value + " ");
string[] tokens = expression.Split(SplitSpace, StringSplitOptions.RemoveEmptyEntries);
decimal result = ProcessExpression(tokens);
if (Math.Abs(result - decimal.Round(result)) < 0.0000000000000000000000000010M) {
return decimal.Round(result).ToString(CultureInfo.InvariantCulture);
}
string IApp.ProcessCommand(Command cmd) {
return ParseAndProcessExpression(cmd.Text);
string res = result.ToString(CultureInfo.InvariantCulture);
bool hasDecimalPoint = decimal.Round(result) != result;
if (res.Length == 30 && hasDecimalPoint && res.IndexOf('.') < 15) { // Length 30 uses all available bytes
res = res[..^1];
Match match = RegexRecurringDecimal.Match(res);
if (match.Groups[2].Success) {
string repeating = match.Groups[2].Value;
StringBuilder build = new StringBuilder(34);
build.Append(match.Groups[1].Value);
do {
build.Append(repeating);
} while (build.Length + repeating.Length <= res.Length);
return build.Append(repeating[..(1 + build.Length - res.Length)]).Append("...").ToString();
}
}
else if (hasDecimalPoint) {
res = res.TrimEnd('0');
}
private static string ParseAndProcessExpression(string text) {
// text = RegexBalancedParentheses.Replace(text, match => " "+ParseAndProcessExpression(match.Groups[1].Value)+" "); // parens are handled as apps
return res;
}
string expression = RegexTokenSeparator.Replace(text, match => " " + match.Value + " ");
string[] tokens = expression.Split(SplitSpace, StringSplitOptions.RemoveEmptyEntries);
private static decimal ProcessExpression(string[] tokens) {
bool isPostfix;
decimal result = ProcessExpression(tokens);
if (Math.Abs(result - decimal.Round(result)) < 0.0000000000000000000000000010M) {
return decimal.Round(result).ToString(CultureInfo.InvariantCulture);
}
string res = result.ToString(CultureInfo.InvariantCulture);
bool hasDecimalPoint = decimal.Round(result) != result;
if (res.Length == 30 && hasDecimalPoint && res.IndexOf('.') < 15) { // Length 30 uses all available bytes
res = res.Substring(0, res.Length - 1);
Match match = RegexRecurringDecimal.Match(res);
if (match.Groups[2].Success) {
string repeating = match.Groups[2].Value;
StringBuilder build = new StringBuilder(34);
build.Append(match.Groups[1].Value);
do {
build.Append(repeating);
} while (build.Length + repeating.Length <= res.Length);
return build.Append(repeating.Substring(0, 1 + build.Length - res.Length)).Append("...").ToString();
}
}
else if (hasDecimalPoint) {
res = res.TrimEnd('0');
}
return res;
if (tokens.Length < 3) {
isPostfix = false;
}
else {
try {
ParseNumberToken(tokens[0]);
} catch (CommandException) {
throw new CommandException("Prefix notation is not supported.");
}
private static decimal ProcessExpression(string[] tokens) {
bool isPostfix;
if (tokens.Length < 3) {
try {
ParseNumberToken(tokens[1]);
isPostfix = true;
} catch (CommandException) {
isPostfix = false;
}
else {
try {
ParseNumberToken(tokens[0]);
} catch (CommandException) {
throw new CommandException("Prefix notation is not supported.");
}
if (isPostfix) {
return ProcessPostfixExpression(tokens);
}
else {
return ProcessPostfixExpression(ConvertInfixToPostfix(tokens));
}
}
private static IEnumerable<string> ConvertInfixToPostfix(IEnumerable<string> tokens) {
Stack<string> operators = new Stack<string>();
foreach (string token in tokens) {
if (Operators.With2Operands.Contains(token)) {
int currentPrecedence = Operators.GetPrecedence(token);
bool currentRightAssociative = Operators.IsRightAssociative(token);
while (operators.Count > 0) {
int topPrecedence = Operators.GetPrecedence(operators.Peek());
if ((currentRightAssociative && currentPrecedence < topPrecedence) || (!currentRightAssociative && currentPrecedence <= topPrecedence)) {
yield return operators.Pop();
}
else {
break;
}
}
try {
ParseNumberToken(tokens[1]);
isPostfix = true;
} catch (CommandException) {
isPostfix = false;
}
}
if (isPostfix) {
return ProcessPostfixExpression(tokens);
operators.Push(token);
}
else {
return ProcessPostfixExpression(ConvertInfixToPostfix(tokens));
yield return ParseNumberToken(token).ToString(CultureInfo.InvariantCulture);
}
}
private static IEnumerable<string> ConvertInfixToPostfix(IEnumerable<string> tokens) {
Stack<string> operators = new Stack<string>();
while (operators.Count > 0) {
yield return operators.Pop();
}
}
foreach (string token in tokens) {
if (Operators.With2Operands.Contains(token)) {
int currentPrecedence = Operators.GetPrecedence(token);
bool currentRightAssociative = Operators.IsRightAssociative(token);
private static decimal ProcessPostfixExpression(IEnumerable<string> tokens) {
Stack<decimal> stack = new Stack<decimal>();
while (operators.Count > 0) {
int topPrecedence = Operators.GetPrecedence(operators.Peek());
foreach (string token in tokens) {
decimal operand1, operand2;
if ((currentRightAssociative && currentPrecedence < topPrecedence) || (!currentRightAssociative && currentPrecedence <= topPrecedence)) {
yield return operators.Pop();
}
else {
break;
}
if (token == "-" && stack.Count == 1) {
operand2 = stack.Pop();
operand1 = 0M;
}
else if (Operators.With2Operands.Contains(token)) {
if (stack.Count < 2) {
throw new CommandException("Incorrect syntax, not enough numbers in stack.");
}
operand2 = stack.Pop();
operand1 = stack.Pop();
}
else {
operand1 = operand2 = 0M;
}
switch (token) {
case "+":
stack.Push(operand1 + operand2);
break;
case "-":
stack.Push(operand1 - operand2);
break;
case "*":
stack.Push(operand1 * operand2);
break;
case "/":
if (operand2 == 0M) {
throw new CommandException("Cannot divide by zero.");
}
operators.Push(token);
}
else {
yield return ParseNumberToken(token).ToString(CultureInfo.InvariantCulture);
}
}
stack.Push(operand1 / operand2);
break;
while (operators.Count > 0) {
yield return operators.Pop();
}
}
private static decimal ProcessPostfixExpression(IEnumerable<string> tokens) {
Stack<decimal> stack = new Stack<decimal>();
foreach (string token in tokens) {
decimal operand1, operand2;
if (token == "-" && stack.Count == 1) {
operand2 = stack.Pop();
operand1 = 0M;
}
else if (Operators.With2Operands.Contains(token)) {
if (stack.Count < 2) {
throw new CommandException("Incorrect syntax, not enough numbers in stack.");
case "%":
if (operand2 == 0M) {
throw new CommandException("Cannot divide by zero.");
}
operand2 = stack.Pop();
operand1 = stack.Pop();
}
else {
operand1 = operand2 = 0M;
}
stack.Push(operand1 % operand2);
break;
switch (token) {
case "+":
stack.Push(operand1 + operand2);
break;
case "-":
stack.Push(operand1 - operand2);
break;
case "*":
stack.Push(operand1 * operand2);
break;
case "^":
if (operand1 == 0M && operand2 == 0M) {
throw new CommandException("Cannot evaluate 0 to the power of 0.");
}
else if (operand1 < 0M && Math.Abs(operand2) < 1M) {
throw new CommandException("Cannot evaluate a root of a negative number.");
}
case "/":
if (operand2 == 0M) {
throw new CommandException("Cannot divide by zero.");
}
try {
stack.Push((decimal) Math.Pow((double) operand1, (double) operand2));
} catch (OverflowException ex) {
throw new CommandException("Number overflow.", ex);
}
stack.Push(operand1 / operand2);
break;
break;
case "%":
if (operand2 == 0M) {
throw new CommandException("Cannot divide by zero.");
}
stack.Push(operand1 % operand2);
break;
case "^":
if (operand1 == 0M && operand2 == 0M) {
throw new CommandException("Cannot evaluate 0 to the power of 0.");
}
else if (operand1 < 0M && Math.Abs(operand2) < 1M) {
throw new CommandException("Cannot evaluate a root of a negative number.");
}
try {
stack.Push((decimal) Math.Pow((double) operand1, (double) operand2));
} catch (OverflowException ex) {
throw new CommandException("Number overflow.", ex);
}
break;
default:
stack.Push(ParseNumberToken(token));
break;
}
default:
stack.Push(ParseNumberToken(token));
break;
}
if (stack.Count != 1) {
throw new CommandException("Incorrect syntax, too many numbers in stack.");
}
return stack.Pop();
}
private static decimal ParseNumberToken(string token) {
string str = token;
if (stack.Count != 1) {
throw new CommandException("Incorrect syntax, too many numbers in stack.");
}
if (str.StartsWith("-.")) {
str = "-0" + str.Substring(1);
return stack.Pop();
}
private static decimal ParseNumberToken(string token) {
string str = token;
if (str.StartsWith("-.")) {
str = "-0" + str[1..];
}
else if (str[0] == '.') {
str = "0" + str;
}
if (str.EndsWith("...")) {
string truncated = str[..^3];
if (truncated.Contains('.')) {
str = truncated;
}
else if (str[0] == '.') {
str = "0" + str;
}
if (decimal.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture, out decimal value)) {
if (value.ToString(CultureInfo.InvariantCulture) != str) {
throw new CommandException("Provided number is outside of decimal range: " + token);
}
if (str.EndsWith("...")) {
string truncated = str.Substring(0, str.Length - 3);
if (truncated.IndexOf('.') != -1) {
str = truncated;
}
}
decimal value;
if (decimal.TryParse(str, NumberStyles.Float, CultureInfo.InvariantCulture, out value)) {
if (value.ToString(CultureInfo.InvariantCulture) != str) {
throw new CommandException("Provided number is outside of decimal range: " + token);
}
return value;
}
else {
throw new CommandException("Invalid token, expected a number: " + token);
}
return value;
}
else {
throw new CommandException("Invalid token, expected a number: " + token);
}
}
}

36
AppCalc/Operators.cs
View File

@ -1,28 +1,18 @@
namespace AppCalc {
static class Operators {
internal static readonly string[] With2Operands = { "+", "-", "*", "/", "%", "^" };
namespace AppCalc;
internal static int GetPrecedence(string token) {
switch (token) {
case "^":
return 4;
static class Operators {
internal static readonly string[] With2Operands = [ "+", "-", "*", "/", "%", "^" ];
case "*":
case "/":
case "%":
return 3;
internal static int GetPrecedence(string token) {
return token switch {
"^" => 4,
"*" or "/" or "%" => 3,
"+" or "-" => 2,
_ => 1
};
}
case "+":
case "-":
return 2;
default:
return 1;
}
}
internal static bool IsRightAssociative(string token) {
return token == "^";
}
internal static bool IsRightAssociative(string token) {
return token == "^";
}
}

70
AppConv/App.cs
View File

@ -4,46 +4,46 @@ using AppConv.General;
using AppConv.Units;
using Base;
namespace AppConv {
public sealed class App : IApp {
private static readonly IUnitType[] Processors = {
new Temperature(),
new Weight(),
new Length(),
new Area(),
new Volume(),
new Angle(),
new Storage(),
new Radix()
};
namespace AppConv;
public string[] RecognizedNames => new string[] {
"conv",
"convert"
};
public sealed class App : IApp {
private static readonly IUnitType[] Processors = [
new Temperature(),
new Weight(),
new Length(),
new Area(),
new Volume(),
new Angle(),
new Storage(),
new Radix()
];
public MatchConfidence GetConfidence(Command cmd) {
return cmd.Text.IndexOf(" to ", StringComparison.InvariantCultureIgnoreCase) != -1 ? MatchConfidence.Possible : MatchConfidence.None;
public string[] RecognizedNames => [
"conv",
"convert"
];
public MatchConfidence GetConfidence(Command cmd) {
return cmd.Text.Contains(" to ", StringComparison.InvariantCultureIgnoreCase) ? MatchConfidence.Possible : MatchConfidence.None;
}
public string ProcessCommand(Command cmd) {
string[] data = cmd.Text.Split([ " to " ], 2, StringSplitOptions.None);
string src = data[0].Trim();
string dst = data[1].Trim();
if (src.Length == 0 || dst.Length == 0) {
throw new CommandException("Unrecognized conversion app syntax.");
}
public string ProcessCommand(Command cmd) {
string[] data = cmd.Text.Split(new string[] { " to " }, 2, StringSplitOptions.None);
string result = string.Empty;
IUnitType used = Processors.FirstOrDefault(processor => processor.TryProcess(src, dst, out result));
string src = data[0].Trim();
string dst = data[1].Trim();
if (src.Length == 0 || dst.Length == 0) {
throw new CommandException("Unrecognized conversion app syntax.");
}
string result = string.Empty;
IUnitType used = Processors.FirstOrDefault(processor => processor.TryProcess(src, dst, out result));
if (used == null) {
throw new CommandException("Could not recognize conversion units.");
}
return result;
if (used == null) {
throw new CommandException("Could not recognize conversion units.");
}
return result;
}
}

158
AppConv/General/DecimalUnitConverterBase.cs
View File

@ -3,112 +3,110 @@ using System.Collections.Generic;
using System.Globalization;
using System.Linq;
namespace AppConv.General {
abstract class DecimalUnitConverterBase<T> : IUnitType where T : struct {
internal sealed class DecimalFuncMap : Dictionary<T, Func<decimal, decimal>> {
public DecimalFuncMap() {}
public DecimalFuncMap(int capacity) : base(capacity) {}
}
namespace AppConv.General;
internal sealed class NameMap : Dictionary<string, T> {
public NameMap() {}
public NameMap(int capacity) : base(capacity) {}
}
abstract class DecimalUnitConverterBase<T> : IUnitType where T : struct {
internal sealed class DecimalFuncMap : Dictionary<T, Func<decimal, decimal>> {
public DecimalFuncMap() {}
public DecimalFuncMap(int capacity) : base(capacity) {}
}
protected abstract NameMap Names { get; }
protected abstract DecimalFuncMap ConvertTo { get; }
protected abstract DecimalFuncMap ConvertFrom { get; }
internal sealed class NameMap : Dictionary<string, T> {
public NameMap() {}
public NameMap(int capacity) : base(capacity) {}
}
protected virtual int Precision => 0;
protected abstract NameMap Names { get; }
protected abstract DecimalFuncMap ConvertTo { get; }
protected abstract DecimalFuncMap ConvertFrom { get; }
protected virtual bool CaseCheck => false;
protected virtual int Precision => 0;
protected virtual NumberStyles NumberStyle => NumberStyles.Float & ~NumberStyles.AllowLeadingSign;
protected virtual bool CaseCheck => false;
protected virtual string ProcessSrc(string src) {
return src;
}
protected virtual NumberStyles NumberStyle => NumberStyles.Float & ~NumberStyles.AllowLeadingSign;
protected virtual string ProcessDst(string dst) {
return dst;
}
protected virtual string ProcessSrc(string src) {
return src;
}
protected abstract bool IsValueInvalid(T value);
protected virtual string ProcessDst(string dst) {
return dst;
}
protected virtual decimal Convert(decimal value, T from, T to) {
return ConvertFrom[to](ConvertTo[from](value));
}
protected abstract bool IsValueInvalid(T value);
protected virtual string Format(decimal value) {
if (Precision > 0) {
decimal truncated = decimal.Truncate(value);
protected virtual decimal Convert(decimal value, T from, T to) {
return ConvertFrom[to](ConvertTo[from](value));
}
if (value == truncated) {
return truncated.ToString(CultureInfo.InvariantCulture);
}
protected virtual string Format(decimal value) {
if (Precision > 0) {
decimal truncated = decimal.Truncate(value);
if (value == truncated) {
return truncated.ToString(CultureInfo.InvariantCulture);
}
int decimalPlaces = Precision;
if (Math.Abs(value) < 1M) {
double fractionalPart = (double) Math.Abs(value % 1M);
int fractionalZeroCount = -(int) Math.Ceiling(Math.Log(fractionalPart, 10D));
decimalPlaces = Math.Min(28, fractionalZeroCount + Precision);
}
string result = decimal.Round(value, decimalPlaces, MidpointRounding.ToEven).ToString(CultureInfo.InvariantCulture);
if (decimalPlaces > 0) {
result = result.TrimEnd('0').TrimEnd('.');
}
return result;
}
public bool TryProcess(string src, string dst, out string result) {
src = ProcessSrc(src);
dst = ProcessDst(dst);
int decimalPlaces = Precision;
var pairs = new KeyValuePair<string, T>[2];
if (Math.Abs(value) < 1M) {
double fractionalPart = (double) Math.Abs(value % 1M);
int fractionalZeroCount = -(int) Math.Ceiling(Math.Log(fractionalPart, 10D));
for (int index = 0; index < 2; index++) {
string str = index == 0 ? src : dst;
decimalPlaces = Math.Min(28, fractionalZeroCount + Precision);
}
if (CaseCheck) {
List<KeyValuePair<string, T>> list = Names.Where(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase) && (str.Length == kvp.Key.Length || !char.IsLetter(str[str.Length - kvp.Key.Length - 1]))).ToList();
string result = decimal.Round(value, decimalPlaces, MidpointRounding.ToEven).ToString(CultureInfo.InvariantCulture);
if (list.Count == 1) {
pairs[index] = list[0];
}
else {
pairs[index] = list.FirstOrDefault(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCulture));
}
if (decimalPlaces > 0) {
result = result.TrimEnd('0').TrimEnd('.');
}
return result;
}
public bool TryProcess(string src, string dst, out string result) {
src = ProcessSrc(src);
dst = ProcessDst(dst);
var pairs = new KeyValuePair<string, T>[2];
for (int index = 0; index < 2; index++) {
string str = index == 0 ? src : dst;
if (CaseCheck) {
List<KeyValuePair<string, T>> list = Names.Where(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase) && (str.Length == kvp.Key.Length || !char.IsLetter(str[str.Length - kvp.Key.Length - 1]))).ToList();
if (list.Count == 1) {
pairs[index] = list[0];
}
else {
pairs[index] = Names.FirstOrDefault(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase) && (str.Length == kvp.Key.Length || !char.IsLetter(str[str.Length - kvp.Key.Length - 1])));
pairs[index] = list.FirstOrDefault(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCulture));
}
if (IsValueInvalid(pairs[index].Value)) {
result = string.Empty;
return false;
}
if (index == 0) {
src = src.Substring(0, src.Length - pairs[index].Key.Length).TrimEnd();
}
}
decimal value;
if (decimal.TryParse(src, NumberStyle, CultureInfo.InvariantCulture, out value)) {
result = Format(Convert(value, pairs[0].Value, pairs[1].Value));
return true;
}
else {
pairs[index] = Names.FirstOrDefault(kvp => str.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase) && (str.Length == kvp.Key.Length || !char.IsLetter(str[str.Length - kvp.Key.Length - 1])));
}
if (IsValueInvalid(pairs[index].Value)) {
result = string.Empty;
return false;
}
if (index == 0) {
src = src[..^pairs[index].Key.Length].TrimEnd();
}
}
if (decimal.TryParse(src, NumberStyle, CultureInfo.InvariantCulture, out decimal value)) {
result = Format(Convert(value, pairs[0].Value, pairs[1].Value));
return true;
}
else {
result = string.Empty;
return false;
}
}
}

57
AppConv/General/DecimalUnitConverterSimple.cs
View File

@ -1,46 +1,45 @@
using System;
namespace AppConv.General {
abstract class DecimalUnitConverterSimple<T> : DecimalUnitConverterBase<T> where T : struct {
// ReSharper disable once StaticMemberInGenericType
private static readonly Func<decimal, decimal> FuncNoChange = val => val;
namespace AppConv.General;
private readonly NameMap UnitNames = new NameMap();
private readonly DecimalFuncMap MapFrom = new DecimalFuncMap();
private readonly DecimalFuncMap MapTo = new DecimalFuncMap();
abstract class DecimalUnitConverterSimple<T> : DecimalUnitConverterBase<T> where T : struct {
// ReSharper disable once StaticMemberInGenericType
private static readonly Func<decimal, decimal> FuncNoChange = static val => val;
private int invalidUnitObject = -1;
private readonly DecimalFuncMap MapFrom = new ();
private readonly DecimalFuncMap MapTo = new ();
protected sealed override NameMap Names => UnitNames;
private int invalidUnitObject = -1;
protected sealed override DecimalFuncMap ConvertFrom => MapFrom;
protected sealed override NameMap Names { get ; } = new ();
protected sealed override DecimalFuncMap ConvertTo => MapTo;
protected sealed override DecimalFuncMap ConvertFrom => MapFrom;
protected override int Precision => 3;
protected sealed override DecimalFuncMap ConvertTo => MapTo;
protected override bool CaseCheck => true;
protected override int Precision => 3;
protected void AddUnit(T unitObject, params string[] names) {
foreach (string name in names) {
UnitNames.Add(name, unitObject);
}
protected override bool CaseCheck => true;
ConvertFrom.Add(unitObject, FuncNoChange);
ConvertTo.Add(unitObject, FuncNoChange);
protected void AddUnit(T unitObject, params string[] names) {
foreach (string name in names) {
Names.Add(name, unitObject);
}
protected void SetUnitFactor(T unitObject, decimal factor) {
ConvertFrom[unitObject] = val => val * factor;
ConvertTo[unitObject] = val => val / factor;
}
ConvertFrom.Add(unitObject, FuncNoChange);
ConvertTo.Add(unitObject, FuncNoChange);
}
protected void SetInvalidUnitObject(T unitObject) {
invalidUnitObject = (int) (object) unitObject;
}
protected void SetUnitFactor(T unitObject, decimal factor) {
ConvertFrom[unitObject] = val => val * factor;
ConvertTo[unitObject] = val => val / factor;
}
protected sealed override bool IsValueInvalid(T value) {
return (int) (object) value == invalidUnitObject;
}
protected void SetInvalidUnitObject(T unitObject) {
invalidUnitObject = (int) (object) unitObject;
}
protected sealed override bool IsValueInvalid(T value) {
return (int) (object) value == invalidUnitObject;
}
}

8
AppConv/General/IUnitType.cs
View File

@ -1,5 +1,5 @@
namespace AppConv.General {
interface IUnitType {
bool TryProcess(string src, string dst, out string result);
}
namespace AppConv.General;
interface IUnitType {
bool TryProcess(string src, string dst, out string result);
}

44
AppConv/Units/Angle.cs
View File

@ -1,28 +1,28 @@
using System;
using AppConv.General;
namespace AppConv.Units {
class Angle : DecimalUnitConverterSimple<Angle.Units> {
internal enum Units {
Invalid = 0,
Degree,
Radian,
Gradian
}
namespace AppConv.Units;
protected override int Precision => 4;
public Angle() {
AddUnit(Units.Degree, "deg", "degree", "degrees", "arc degree", "arc degrees", "arcdegree", "arcdegrees", "°");
AddUnit(Units.Radian, "rad", "radian", "radians");
AddUnit(Units.Gradian, "grad", "grade", "gon", "gradian", "gradians");
SetUnitFactor(Units.Radian, (decimal) Math.PI / 180M);
SetUnitFactor(Units.Gradian, 10M / 9M);
SetInvalidUnitObject(Units.Invalid);
}
// TODO convert degree notation 15°24'9"
sealed class Angle : DecimalUnitConverterSimple<Angle.Units> {
internal enum Units {
Invalid = 0,
Degree,
Radian,
Gradian
}
protected override int Precision => 4;
public Angle() {
AddUnit(Units.Degree, "deg", "degree", "degrees", "arc degree", "arc degrees", "arcdegree", "arcdegrees", "°");
AddUnit(Units.Radian, "rad", "radian", "radians");
AddUnit(Units.Gradian, "grad", "grade", "gon", "gradian", "gradians");
SetUnitFactor(Units.Radian, (decimal) Math.PI / 180M);
SetUnitFactor(Units.Gradian, 10M / 9M);
SetInvalidUnitObject(Units.Invalid);
}
// TODO convert degree notation 15°24'9"
}

102
AppConv/Units/Area.cs
View File

@ -1,58 +1,58 @@
using AppConv.General;
namespace AppConv.Units {
class Area : DecimalUnitConverterSimple<Area.Units> {
internal enum Units {
Invalid = 0,
SquareMM,
SquareCM,
SquareDM,
SquareM,
SquareKM,
SquareMile,
SquareYard,
SquareFoot,
SquareInch,
Acre,
Centiare,
Deciare,
Are,
Decare,
Hectare
}
namespace AppConv.Units;
public Area() {
AddUnit(Units.SquareMM, "mm2", "square mm", "square millimeter", "square millimeters", "square millimetre", "square millimetres");
AddUnit(Units.SquareCM, "cm2", "square cm", "square centimeter", "square centimeters", "square centimetre", "square centimetres");
AddUnit(Units.SquareDM, "dm2", "square dm", "square decimeter", "square decimeters", "square decimetre", "square decimetres");
AddUnit(Units.SquareM, "m2", "square m", "square meter", "square meters", "square metre", "square metres");
AddUnit(Units.SquareKM, "km2", "square km", "square kilometer", "square kilometers", "square kilometre", "square kilometres");
AddUnit(Units.SquareMile, "mi2", "sq mi", "sq mile", "sq miles", "square mi", "square mile", "square miles");
AddUnit(Units.SquareYard, "yd2", "sq yd", "sq yard", "sq yards", "square yd", "square yard", "square yards");
AddUnit(Units.SquareFoot, "ft2", "sq ft", "sq foot", "sq feet", "square ft", "square foot", "square feet");
AddUnit(Units.SquareInch, "in2", "sq in", "sq inch", "sq inches", "square in", "square inch", "square inches");
AddUnit(Units.Acre, "ac", "acre", "acres");
AddUnit(Units.Centiare, "ca", "centiare", "centiares");
AddUnit(Units.Deciare, "da", "deciare", "deciares"); // da is not canon but w/e
AddUnit(Units.Are, "a", "are", "ares");
AddUnit(Units.Decare, "daa", "decare", "decares");
AddUnit(Units.Hectare, "ha", "hectare", "hectares");
sealed class Area : DecimalUnitConverterSimple<Area.Units> {
internal enum Units {
Invalid = 0,
SquareMM,
SquareCM,
SquareDM,
SquareM,
SquareKM,
SquareMile,
SquareYard,
SquareFoot,
SquareInch,
Acre,
Centiare,
Deciare,
Are,
Decare,
Hectare
}
SetUnitFactor(Units.SquareMM, 1E+6M);
SetUnitFactor(Units.SquareCM, 1E+4M);
SetUnitFactor(Units.SquareDM, 1E+2M);
SetUnitFactor(Units.SquareKM, 1E-6M);
SetUnitFactor(Units.SquareMile, 3.8610215854245E-7M);
SetUnitFactor(Units.SquareYard, 1.1959900463011M);
SetUnitFactor(Units.SquareFoot, 10.76391041671M);
SetUnitFactor(Units.SquareInch, 1550.0031000062M);
SetUnitFactor(Units.Acre, 2.4710538146717E-4M);
SetUnitFactor(Units.Deciare, 1E-1M);
SetUnitFactor(Units.Are, 1E-2M);
SetUnitFactor(Units.Decare, 1E-3M);
SetUnitFactor(Units.Hectare, 1E-4M);
public Area() {
AddUnit(Units.SquareMM, "mm2", "square mm", "square millimeter", "square millimeters", "square millimetre", "square millimetres");
AddUnit(Units.SquareCM, "cm2", "square cm", "square centimeter", "square centimeters", "square centimetre", "square centimetres");
AddUnit(Units.SquareDM, "dm2", "square dm", "square decimeter", "square decimeters", "square decimetre", "square decimetres");
AddUnit(Units.SquareM, "m2", "square m", "square meter", "square meters", "square metre", "square metres");
AddUnit(Units.SquareKM, "km2", "square km", "square kilometer", "square kilometers", "square kilometre", "square kilometres");
AddUnit(Units.SquareMile, "mi2", "sq mi", "sq mile", "sq miles", "square mi", "square mile", "square miles");
AddUnit(Units.SquareYard, "yd2", "sq yd", "sq yard", "sq yards", "square yd", "square yard", "square yards");
AddUnit(Units.SquareFoot, "ft2", "sq ft", "sq foot", "sq feet", "square ft", "square foot", "square feet");
AddUnit(Units.SquareInch, "in2", "sq in", "sq inch", "sq inches", "square in", "square inch", "square inches");
AddUnit(Units.Acre, "ac", "acre", "acres");
AddUnit(Units.Centiare, "ca", "centiare", "centiares");
AddUnit(Units.Deciare, "da", "deciare", "deciares"); // da is not canon but w/e
AddUnit(Units.Are, "a", "are", "ares");
AddUnit(Units.Decare, "daa", "decare", "decares");
AddUnit(Units.Hectare, "ha", "hectare", "hectares");
SetInvalidUnitObject(Units.Invalid);
}
SetUnitFactor(Units.SquareMM, 1E+6M);
SetUnitFactor(Units.SquareCM, 1E+4M);
SetUnitFactor(Units.SquareDM, 1E+2M);
SetUnitFactor(Units.SquareKM, 1E-6M);
SetUnitFactor(Units.SquareMile, 3.8610215854245E-7M);
SetUnitFactor(Units.SquareYard, 1.1959900463011M);
SetUnitFactor(Units.SquareFoot, 10.76391041671M);
SetUnitFactor(Units.SquareInch, 1550.0031000062M);
SetUnitFactor(Units.Acre, 2.4710538146717E-4M);
SetUnitFactor(Units.Deciare, 1E-1M);
SetUnitFactor(Units.Are, 1E-2M);
SetUnitFactor(Units.Decare, 1E-3M);
SetUnitFactor(Units.Hectare, 1E-4M);
SetInvalidUnitObject(Units.Invalid);
}
}

140
AppConv/Units/Length.cs
View File

@ -4,86 +4,86 @@ using System.Linq;
using AppConv.General;
using AppConv.Utils;
namespace AppConv.Units {
class Length : DecimalUnitConverterSimple<Length.Units> {
internal enum Units {
Invalid = 0,
Meter,
Inch,
Foot,
Yard,
Mile
namespace AppConv.Units;
sealed class Length : DecimalUnitConverterSimple<Length.Units> {
internal enum Units {
Invalid = 0,
Meter,
Inch,
Foot,
Yard,
Mile
}
private static readonly string[] NamesInch = [ "in", "inch", "inches", "\"", "''" ];
private static readonly string[] NamesFoot = [ "ft", "foot", "feet", "'" ];
private static readonly char[] Separator = [ ' ' ];
public Length() {
AddUnit(Units.Meter, "m", "meter", "metre", "meters", "metres");
AddUnit(Units.Inch, NamesInch);
AddUnit(Units.Foot, NamesFoot);
AddUnit(Units.Yard, "yd", "yard", "yards");
AddUnit(Units.Mile, "mi", "mile", "miles");
SetUnitFactor(Units.Inch, 39.37007874M);
SetUnitFactor(Units.Foot, 3.280839895M);
SetUnitFactor(Units.Yard, 1.093613298M);
SetUnitFactor(Units.Mile, 0.0006213711922M);
SetInvalidUnitObject(Units.Invalid);
SI.AddSupport(Units.Meter, [ "m" ], [ "meter", "metre", "meters", "metres" ], ConvertFrom, ConvertTo, Names);
}
protected override string ProcessSrc(string src) {
string updatedStr = src;
updatedStr = updatedStr.Replace("&", " ");
updatedStr = updatedStr.Replace(",", " ");
string inchName = NamesInch.FirstOrDefault(name => src.Contains(name, StringComparison.OrdinalIgnoreCase));
if (inchName == null) {
return src;
}
private static readonly string[] NamesInch = { "in", "inch", "inches", "\"", "''" };
private static readonly string[] NamesFoot = { "ft", "foot", "feet", "'" };
int inchIndex = src.IndexOf(inchName, StringComparison.OrdinalIgnoreCase);
updatedStr = updatedStr.Remove(inchIndex, inchName.Length).Insert(inchIndex, new string(' ', inchName.Length));
public Length() {
AddUnit(Units.Meter, "m", "meter", "metre", "meters", "metres");
AddUnit(Units.Inch, NamesInch);
AddUnit(Units.Foot, NamesFoot);
AddUnit(Units.Yard, "yd", "yard", "yards");
AddUnit(Units.Mile, "mi", "mile", "miles");
string footName = NamesFoot.FirstOrDefault(name => updatedStr.Contains(name, StringComparison.OrdinalIgnoreCase));
SetUnitFactor(Units.Inch, 39.37007874M);
SetUnitFactor(Units.Foot, 3.280839895M);
SetUnitFactor(Units.Yard, 1.093613298M);
SetUnitFactor(Units.Mile, 0.0006213711922M);
SetInvalidUnitObject(Units.Invalid);
SI.AddSupport(typeof(Units), Units.Meter, new [] { "m" }, new [] { "meter", "metre", "meters", "metres" }, ConvertFrom, ConvertTo, Names);
if (footName == null) {
return src;
}
protected override string ProcessSrc(string src) {
string updatedStr = src;
int footIndex = updatedStr.IndexOf(footName, StringComparison.OrdinalIgnoreCase);
updatedStr = updatedStr.Remove(footIndex, footName.Length).Insert(footIndex, new string(' ', footName.Length));
updatedStr = updatedStr.Replace("&", " ");
updatedStr = updatedStr.Replace(",", " ");
string[] tokens = updatedStr.Split(Separator, StringSplitOptions.RemoveEmptyEntries);
decimal[] numbers = new decimal[2];
int numberIndex = 0;
string inchName = NamesInch.FirstOrDefault(name => src.IndexOf(name, StringComparison.OrdinalIgnoreCase) != -1);
if (inchName == null) {
return src;
}
int inchIndex = src.IndexOf(inchName, StringComparison.OrdinalIgnoreCase);
updatedStr = updatedStr.Remove(inchIndex, inchName.Length).Insert(inchIndex, new string(' ', inchName.Length));
string footName = NamesFoot.FirstOrDefault(name => updatedStr.IndexOf(name, StringComparison.OrdinalIgnoreCase) != -1);
if (footName == null) {
return src;
}
int footIndex = updatedStr.IndexOf(footName, StringComparison.OrdinalIgnoreCase);
updatedStr = updatedStr.Remove(footIndex, footName.Length).Insert(footIndex, new string(' ', footName.Length));
string[] tokens = updatedStr.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
decimal[] numbers = new decimal[2];
int numberIndex = 0;
foreach (string token in tokens) {
decimal number;
if (decimal.TryParse(token.Trim(), NumberStyle, CultureInfo.InvariantCulture, out number)) {
if (numberIndex < numbers.Length) {
numbers[numberIndex++] = number;
}
else {
return src;
}
foreach (string token in tokens) {
if (decimal.TryParse(token.Trim(), NumberStyle, CultureInfo.InvariantCulture, out decimal number)) {
if (numberIndex < numbers.Length) {
numbers[numberIndex++] = number;
}
else {
return src;
}
}
if (numberIndex != numbers.Length) {
return src;
}
decimal srcFeet = numbers[footIndex < inchIndex ? 0 : 1];
decimal srcInches = numbers[inchIndex < footIndex ? 0 : 1];
return srcInches + srcFeet * 12M + " in";
}
if (numberIndex != numbers.Length) {
return src;
}
decimal srcFeet = numbers[footIndex < inchIndex ? 0 : 1];
decimal srcInches = numbers[inchIndex < footIndex ? 0 : 1];
return srcInches + srcFeet * 12M + " in";
}
}

207
AppConv/Units/Radix.cs
View File

@ -5,120 +5,115 @@ using AppConv.General;
using AppConv.Utils;
using Base;
namespace AppConv.Units {
class Radix : IUnitType {
private static readonly Dictionary<string, int> RadixDescriptions = new Dictionary<string, int> {
{ "UNARY", 1 },
{ "BINARY", 2 },
{ "BIN", 2 },
{ "TERNARY", 3 },
{ "QUATERNARY", 4 },
{ "QUINARY", 5 },
{ "SENARY", 6 },
{ "OCTAL", 8 },
{ "OCT", 8 },
{ "DECIMAL", 10 },
{ "DEC", 10 },
{ "UNDECIMAL", 11 },
{ "DUODECIMAL", 12 },
{ "DOZENAL", 12 },
{ "TRIDECIMAL", 13 },
{ "TETRADECIMAL", 14 },
{ "PENTADECIMAL", 15 },
{ "HEXADECIMAL", 16 },
{ "HEX", 16 }
};
namespace AppConv.Units;
static Radix() {
for (int baseNumber = 1; baseNumber <= 16; baseNumber++) {
RadixDescriptions.Add("RADIX " + baseNumber, baseNumber);
RadixDescriptions.Add("BASE " + baseNumber, baseNumber);
}
sealed class Radix : IUnitType {
private static readonly Dictionary<string, int> RadixDescriptions = new () {
{ "UNARY", 1 },
{ "BINARY", 2 },
{ "BIN", 2 },
{ "TERNARY", 3 },
{ "QUATERNARY", 4 },
{ "QUINARY", 5 },
{ "SENARY", 6 },
{ "OCTAL", 8 },
{ "OCT", 8 },
{ "DECIMAL", 10 },
{ "DEC", 10 },
{ "UNDECIMAL", 11 },
{ "DUODECIMAL", 12 },
{ "DOZENAL", 12 },
{ "TRIDECIMAL", 13 },
{ "TETRADECIMAL", 14 },
{ "PENTADECIMAL", 15 },
{ "HEXADECIMAL", 16 },
{ "HEX", 16 }
};
static Radix() {
for (int baseNumber = 1; baseNumber <= 16; baseNumber++) {
RadixDescriptions.Add("RADIX " + baseNumber, baseNumber);
RadixDescriptions.Add("BASE " + baseNumber, baseNumber);
}
}
public bool TryProcess(string src, string dst, out string result) {
if (!RadixDescriptions.TryGetValue(dst.ToUpperInvariant(), out int targetBase)) {
result = string.Empty;
return false;
}
public bool TryProcess(string src, string dst, out string result) {
int targetBase;
if (!ParseSrc(src, out string contents, out int sourceBase)) {
result = string.Empty;
return false;
}
if (!RadixDescriptions.TryGetValue(dst.ToUpperInvariant(), out targetBase)) {
result = string.Empty;
return false;
}
string contents;
int sourceBase;
if (!ParseSrc(src, out contents, out sourceBase)) {
result = string.Empty;
return false;
}
if (contents[0] == '-') {
throw new CommandException("Negative numbers are not supported.");
}
else if (!RadixConversion.IsBaseValid(sourceBase) || !RadixConversion.IsBaseValid(targetBase)) {
throw new CommandException("Only bases between 1 and 16 allowed.");
}
else if (!RadixConversion.IsNumberValid(contents, sourceBase)) {
throw new CommandException("The input is not a valid base " + sourceBase + " number: " + contents);
}
if (sourceBase == targetBase) {
result = src;
return true;
}
try {
result = RadixConversion.Do(contents, sourceBase, targetBase);
} catch (OverflowException) {
throw new CommandException("The number has overflown.");
}
if (contents[0] == '-') {
throw new CommandException("Negative numbers are not supported.");
}
else if (!RadixConversion.IsBaseValid(sourceBase) || !RadixConversion.IsBaseValid(targetBase)) {
throw new CommandException("Only bases between 1 and 16 allowed.");
}
else if (!RadixConversion.IsNumberValid(contents, sourceBase)) {
throw new CommandException("The input is not a valid base " + sourceBase + " number: " + contents);
}
if (sourceBase == targetBase) {
result = src;
return true;
}
private static bool ParseSrc(string src, out string sourceContent, out int sourceBase) {
if (src.All(chr => chr >= '0' && chr <= '9')) {
sourceContent = src;
sourceBase = 10;
return true;
}
string upper = src.ToUpperInvariant();
if (upper.StartsWith("0X")) {
sourceContent = upper.Substring(2);
sourceBase = 16;
return true;
}
if (upper.StartsWith("0B")) {
sourceContent = upper.Substring(2);
sourceBase = 2;
return true;
}
int fromIndex = src.IndexOf("FROM", StringComparison.InvariantCultureIgnoreCase);
if (fromIndex != -1) {
src = src.Remove(fromIndex, 4);
}
foreach (KeyValuePair<string, int> kvp in RadixDescriptions) {
if (src.StartsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase)) {
sourceContent = src.Substring(kvp.Key.Length).Trim();
sourceBase = kvp.Value;
return true;
}
else if (src.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase)) {
sourceContent = src.Substring(0, src.Length - kvp.Key.Length).Trim();
sourceBase = kvp.Value;
return true;
}
}
sourceContent = string.Empty;
sourceBase = 0;
return false;
try {
result = RadixConversion.Do(contents, sourceBase, targetBase);
} catch (OverflowException) {
throw new CommandException("The number has overflown.");
}
return true;
}
private static bool ParseSrc(string src, out string sourceContent, out int sourceBase) {
if (src.All(static chr => chr is >= '0' and <= '9')) {
sourceContent = src;
sourceBase = 10;
return true;
}
string upper = src.ToUpperInvariant();
if (upper.StartsWith("0X")) {
sourceContent = upper[2..];
sourceBase = 16;
return true;
}
if (upper.StartsWith("0B")) {
sourceContent = upper[2..];
sourceBase = 2;
return true;
}
int fromIndex = src.IndexOf("FROM", StringComparison.InvariantCultureIgnoreCase);
if (fromIndex != -1) {
src = src.Remove(fromIndex, 4);
}
foreach (KeyValuePair<string, int> kvp in RadixDescriptions) {
if (src.StartsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase)) {
sourceContent = src[kvp.Key.Length..].Trim();
sourceBase = kvp.Value;
return true;
}
else if (src.EndsWith(kvp.Key, StringComparison.InvariantCultureIgnoreCase)) {
sourceContent = src[..^kvp.Key.Length].Trim();
sourceBase = kvp.Value;
return true;
}
}
sourceContent = string.Empty;
sourceBase = 0;
return false;
}
}

42
AppConv/Units/Storage.cs
View File

@ -1,31 +1,33 @@
using System;
using System.Diagnostics.CodeAnalysis;
using AppConv.General;
using AppConv.Utils;
namespace AppConv.Units {
class Storage : DecimalUnitConverterSimple<Storage.Units> {
internal enum Units {
Invalid = 0,
Byte,
Bit
}
namespace AppConv.Units;
public Storage() {
AddUnit(Units.Byte, "B", "byte", "bytes");
AddUnit(Units.Bit, "b", "bit", "bits");
sealed class Storage : DecimalUnitConverterSimple<Storage.Units> {
internal enum Units {
Invalid = 0,
Byte,
Bit
}
SetUnitFactor(Units.Bit, 8M);
[SuppressMessage("ReSharper", "PossibleLossOfFraction")]
public Storage() {
AddUnit(Units.Byte, "B", "byte", "bytes");
AddUnit(Units.Bit, "b", "bit", "bits");
SetInvalidUnitObject(Units.Invalid);
SetUnitFactor(Units.Bit, 8M);
var bitConversionProperties = new SI.ExtededProperties {
FactorPredicate = factor => factor > 0 && factor % 3 == 0,
FromFunctionGenerator = exponent => () => (decimal) Math.Pow(1024, -(int) (exponent / 3)),
ToFunctionGenerator = exponent => () => (decimal) Math.Pow(1024, (int) (exponent / 3))
};
SetInvalidUnitObject(Units.Invalid);
SI.AddSupportCustom(typeof(Units), Units.Byte, new [] { "B" }, new [] { "byte", "bytes" }, ConvertFrom, ConvertTo, Names, bitConversionProperties);
SI.AddSupportCustom(typeof(Units), Units.Bit, new [] { "b" }, new [] { "bit", "bits" }, ConvertFrom, ConvertTo, Names, bitConversionProperties);
}
var bitConversionProperties = new SI.ExtededProperties {
FactorPredicate = static factor => factor > 0 && factor % 3 == 0,
FromFunctionGenerator = static exponent => () => (decimal) Math.Pow(1024, -(exponent / 3)),
ToFunctionGenerator = static exponent => () => (decimal) Math.Pow(1024, exponent / 3)
};
SI.AddSupportCustom(Units.Byte, [ "B" ], [ "byte", "bytes" ], ConvertFrom, ConvertTo, Names, bitConversionProperties);
SI.AddSupportCustom(Units.Bit, [ "b" ], [ "bit", "bits" ], ConvertFrom, ConvertTo, Names, bitConversionProperties);
}
}

146
AppConv/Units/Temperature.cs
View File

@ -1,90 +1,92 @@
using System.Globalization;
using System.Text.RegularExpressions;
using AppConv.General;
using Base.Utils;
namespace AppConv.Units {
class Temperature : DecimalUnitConverterBase<Temperature.Units> {
internal enum Units {
Invalid = 0,
Celsius,
Kelvin,
Fahrenheit,
Rankine,
Delisle,
Newton,
Reaumur,
Romer
}
namespace AppConv.Units;
private static readonly NameMap UnitNames = new NameMap(21) {
{ "C", Units.Celsius },
{ "Celsius", Units.Celsius },
{ "K", Units.Kelvin },
{ "Kelvin", Units.Kelvin },
{ "F", Units.Fahrenheit },
{ "Fahrenheit", Units.Fahrenheit },
{ "R", Units.Rankine },
{ "Ra", Units.Rankine },
{ "Rankine", Units.Rankine },
{ "De", Units.Delisle },
{ "Delisle", Units.Delisle },
{ "N", Units.Newton },
{ "Newton", Units.Newton },
{ "Re", Units.Reaumur },
{ "Ré", Units.Reaumur },
{ "Reaumur", Units.Reaumur },
{ "Réaumur", Units.Reaumur },
{ "Ro", Units.Romer },
{ "Rø", Units.Romer },
{ "Romer", Units.Romer },
{ "Rømer", Units.Romer }
};
sealed partial class Temperature : DecimalUnitConverterBase<Temperature.Units> {
internal enum Units {
Invalid = 0,
Celsius,
Kelvin,
Fahrenheit,
Rankine,
Delisle,
Newton,
Reaumur,
Romer
}
private static readonly DecimalFuncMap FromCelsius = new DecimalFuncMap(8) {
{ Units.Celsius, val => val },
{ Units.Kelvin, val => val + 273.15M },
{ Units.Fahrenheit, val => val * 1.8M + 32M },
{ Units.Rankine, val => (val + 273.15M) * 1.8M },
{ Units.Delisle, val => (100M - val) * 1.5M },
{ Units.Newton, val => val * 0.33M },
{ Units.Reaumur, val => val * 0.8M },
{ Units.Romer, val => val * 0.525M + 7.5M }
};
private static readonly NameMap UnitNames = new (21) {
{ "C", Units.Celsius },
{ "Celsius", Units.Celsius },
{ "K", Units.Kelvin },
{ "Kelvin", Units.Kelvin },
{ "F", Units.Fahrenheit },
{ "Fahrenheit", Units.Fahrenheit },
{ "R", Units.Rankine },
{ "Ra", Units.Rankine },
{ "Rankine", Units.Rankine },
{ "De", Units.Delisle },
{ "Delisle", Units.Delisle },
{ "N", Units.Newton },
{ "Newton", Units.Newton },
{ "Re", Units.Reaumur },
{ "Ré", Units.Reaumur },
{ "Reaumur", Units.Reaumur },
{ "Réaumur", Units.Reaumur },
{ "Ro", Units.Romer },
{ "Rø", Units.Romer },
{ "Romer", Units.Romer },
{ "Rømer", Units.Romer }
};
private static readonly DecimalFuncMap ToCelsius = new DecimalFuncMap(8) {
{ Units.Celsius, val => val },
{ Units.Kelvin, val => val - 273.15M },
{ Units.Fahrenheit, val => (val - 32M) * 5M / 9M },
{ Units.Rankine, val => (val - 491.67M) * 5M / 9M },
{ Units.Delisle, val => 100M - val * 2M / 3M },
{ Units.Newton, val => val * 100M / 33M },
{ Units.Reaumur, val => val * 1.25M },
{ Units.Romer, val => (val - 7.5M) * 40M / 21M }
};
private static readonly DecimalFuncMap FromCelsius = new (8) {
{ Units.Celsius, static val => val },
{ Units.Kelvin, static val => val + 273.15M },
{ Units.Fahrenheit, static val => val * 1.8M + 32M },
{ Units.Rankine, static val => (val + 273.15M) * 1.8M },
{ Units.Delisle, static val => (100M - val) * 1.5M },
{ Units.Newton, static val => val * 0.33M },
{ Units.Reaumur, static val => val * 0.8M },
{ Units.Romer, static val => val * 0.525M + 7.5M }
};
private static readonly Regex RegexCleanup = new Regex("deg(?:rees?)?|°", RegexUtils.Text);
private static readonly DecimalFuncMap ToCelsius = new (8) {
{ Units.Celsius, static val => val },
{ Units.Kelvin, static val => val - 273.15M },
{ Units.Fahrenheit, static val => (val - 32M) * 5M / 9M },
{ Units.Rankine, static val => (val - 491.67M) * 5M / 9M },
{ Units.Delisle, static val => 100M - val * 2M / 3M },
{ Units.Newton, static val => val * 100M / 33M },
{ Units.Reaumur, static val => val * 1.25M },
{ Units.Romer, static val => (val - 7.5M) * 40M / 21M }
};
protected override NameMap Names => UnitNames;
private static readonly Regex RegexCleanup = GetRegexCleanup();
protected override DecimalFuncMap ConvertFrom => FromCelsius;
[GeneratedRegex("deg(?:rees?)?|°", RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled | RegexOptions.CultureInvariant)]
private static partial Regex GetRegexCleanup();
protected override DecimalFuncMap ConvertTo => ToCelsius;
protected override NameMap Names => UnitNames;
protected override int Precision => 2;
protected override DecimalFuncMap ConvertFrom => FromCelsius;
protected override NumberStyles NumberStyle => NumberStyles.Float;
protected override DecimalFuncMap ConvertTo => ToCelsius;
protected override string ProcessSrc(string src) {
return RegexCleanup.Replace(src, "");
}
protected override int Precision => 2;
protected override string ProcessDst(string dst) {
return RegexCleanup.Replace(dst, "");
}
protected override NumberStyles NumberStyle => NumberStyles.Float;
protected override bool IsValueInvalid(Units value) {
return value == Units.Invalid;
}
protected override string ProcessSrc(string src) {
return RegexCleanup.Replace(src, "");
}
protected override string ProcessDst(string dst) {
return RegexCleanup.Replace(dst, "");
}
protected override bool IsValueInvalid(Units value) {
return value == Units.Invalid;
}
}

50
AppConv/Units/Volume.cs
View File

@ -1,34 +1,34 @@
using AppConv.General;
using AppConv.Utils;
namespace AppConv.Units {
class Volume : DecimalUnitConverterSimple<Volume.Units> {
internal enum Units {
Invalid = 0,
Liter,
CubicMM,
CubicCM,
CubicDM,
CubicM,
CubicKM
}
namespace AppConv.Units;
public Volume() {
AddUnit(Units.Liter, "l", "liter", "liters", "litre", "litres");
AddUnit(Units.CubicMM, "mm3", "cubic mm", "cubic millimeter", "cubic millimeters", "cubic millimetre", "cubic millimetres");
AddUnit(Units.CubicCM, "cm3", "cubic cm", "cubic centimeter", "cubic centimeters", "cubic centimetre", "cubic centimetres");
AddUnit(Units.CubicDM, "dm3", "cubic dm", "cubic decimeter", "cubic decimeters", "cubic decimetre", "cubic decimetres");
AddUnit(Units.CubicM, "m3", "cubic m", "cubic meter", "cubic meters", "cubic metre", "cubic metres");
AddUnit(Units.CubicKM, "km3", "cubic km", "cubic kilometer", "cubic kilometers", "cubic kilometre", "cubic kilometres");
sealed class Volume : DecimalUnitConverterSimple<Volume.Units> {
internal enum Units {
Invalid = 0,
Liter,
CubicMM,
CubicCM,
CubicDM,
CubicM,
CubicKM
}
SetUnitFactor(Units.CubicMM, 1000000M);
SetUnitFactor(Units.CubicCM, 1000M);
SetUnitFactor(Units.CubicM, 0.001M);
SetUnitFactor(Units.CubicKM, 1E-12M);
public Volume() {
AddUnit(Units.Liter, "l", "liter", "liters", "litre", "litres");
AddUnit(Units.CubicMM, "mm3", "cubic mm", "cubic millimeter", "cubic millimeters", "cubic millimetre", "cubic millimetres");
AddUnit(Units.CubicCM, "cm3", "cubic cm", "cubic centimeter", "cubic centimeters", "cubic centimetre", "cubic centimetres");
AddUnit(Units.CubicDM, "dm3", "cubic dm", "cubic decimeter", "cubic decimeters", "cubic decimetre", "cubic decimetres");
AddUnit(Units.CubicM, "m3", "cubic m", "cubic meter", "cubic meters", "cubic metre", "cubic metres");
AddUnit(Units.CubicKM, "km3", "cubic km", "cubic kilometer", "cubic kilometers", "cubic kilometre", "cubic kilometres");
SetInvalidUnitObject(Units.Invalid);
SetUnitFactor(Units.CubicMM, 1000000M);
SetUnitFactor(Units.CubicCM, 1000M);
SetUnitFactor(Units.CubicM, 0.001M);
SetUnitFactor(Units.CubicKM, 1E-12M);
SI.AddSupport(typeof(Units), Units.Liter, new [] { "l" }, new [] { "liter", "litre", "liters", "litres" }, ConvertFrom, ConvertTo, Names);
}
SetInvalidUnitObject(Units.Invalid);
SI.AddSupport(Units.Liter, [ "l" ], [ "liter", "litre", "liters", "litres" ], ConvertFrom, ConvertTo, Names);
}
}

40
AppConv/Units/Weight.cs
View File

@ -1,29 +1,29 @@
using AppConv.General;
using AppConv.Utils;
namespace AppConv.Units {
class Weight : DecimalUnitConverterSimple<Weight.Units> {
internal enum Units {
Invalid = 0,
Gram,
Pound,
Ounce,
Stone
}
namespace AppConv.Units;
public Weight() {
AddUnit(Units.Gram, "g", "gram", "grams");
AddUnit(Units.Pound, "lb", "lbs", "pound", "pounds");
AddUnit(Units.Ounce, "oz", "ounce", "ounces");
AddUnit(Units.Stone, "st", "stone", "stones");
sealed class Weight : DecimalUnitConverterSimple<Weight.Units> {
internal enum Units {
Invalid = 0,
Gram,
Pound,
Ounce,
Stone
}
SetUnitFactor(Units.Pound, 0.0022046226218M);
SetUnitFactor(Units.Ounce, 0.03527396195M);
SetUnitFactor(Units.Stone, 0.0001574730444177697M);
public Weight() {
AddUnit(Units.Gram, "g", "gram", "grams");
AddUnit(Units.Pound, "lb", "lbs", "pound", "pounds");
AddUnit(Units.Ounce, "oz", "ounce", "ounces");
AddUnit(Units.Stone, "st", "stone", "stones");
SetInvalidUnitObject(Units.Invalid);
SetUnitFactor(Units.Pound, 0.0022046226218M);
SetUnitFactor(Units.Ounce, 0.03527396195M);
SetUnitFactor(Units.Stone, 0.0001574730444177697M);
SI.AddSupport(typeof(Units), Units.Gram, new [] { "g" }, new [] { "gram", "grams" }, ConvertFrom, ConvertTo, Names);
}
SetInvalidUnitObject(Units.Invalid);
SI.AddSupport(Units.Gram, [ "g" ], [ "gram", "grams" ], ConvertFrom, ConvertTo, Names);
}
}

106
AppConv/Utils/RadixConversion.cs
View File

@ -3,76 +3,76 @@ using System.Globalization;
using System.Linq;
using System.Text;
namespace AppConv.Utils {
static class RadixConversion {
private const string Characters = "0123456789ABCDEF";
namespace AppConv.Utils;
public static bool IsBaseValid(int checkedBase) {
return checkedBase >= 1 && checkedBase <= 16;
static class RadixConversion {
private const string Characters = "0123456789ABCDEF";
public static bool IsBaseValid(int checkedBase) {
return checkedBase is >= 1 and <= 16;
}
public static bool IsNumberValid(string contents, int checkedBase) {
if (checkedBase == 1) {
return contents.All(static chr => chr == '1');
}
public static bool IsNumberValid(string contents, int checkedBase) {
if (checkedBase == 1) {
return contents.All(chr => chr == '1');
}
if (IsBaseValid(checkedBase)) {
return contents.Select(chr => Characters.IndexOf(char.ToUpper(chr))).All(index => index != -1 && index < checkedBase);
}
return false;
if (IsBaseValid(checkedBase)) {
return contents.Select(static chr => Characters.IndexOf(char.ToUpper(chr))).All(index => index != -1 && index < checkedBase);
}
public static string Do(string contents, int fromBase, int toBase) { // TODO biginteger
if (fromBase == 1) {
contents = contents.Length.ToString(CultureInfo.InvariantCulture);
fromBase = 10;
}
return false;
}
long wip;
public static string Do(string contents, int fromBase, int toBase) { // TODO biginteger
if (fromBase == 1) {
contents = contents.Length.ToString(CultureInfo.InvariantCulture);
fromBase = 10;
}
if (fromBase == 10) {
wip = long.Parse(contents, NumberStyles.None, CultureInfo.InvariantCulture);
}
else {
wip = 0;
long wip;
for (int chr = 0; chr < contents.Length; chr++) {
int index = Characters.IndexOf(char.ToUpperInvariant(contents[chr]));
if (fromBase == 10) {
wip = long.Parse(contents, NumberStyles.None, CultureInfo.InvariantCulture);
}
else {
wip = 0;
if (index > 0) {
wip += index * (long) Math.Pow(fromBase, contents.Length - chr - 1);
for (int chr = 0; chr < contents.Length; chr++) {
int index = Characters.IndexOf(char.ToUpperInvariant(contents[chr]));
if (wip < 0) {
throw new OverflowException();
}
if (index > 0) {
wip += index * (long) Math.Pow(fromBase, contents.Length - chr - 1);
if (wip < 0) {
throw new OverflowException();
}
}
}
}
if (toBase == 1) {
if (wip <= int.MaxValue) {
return new string('1', (int) wip);
}
else {
throw new OverflowException();
}
}
else if (wip < toBase) {
return Characters[(int) wip].ToString();
if (toBase == 1) {
if (wip <= int.MaxValue) {
return new string('1', (int) wip);
}
else {
var converted = new StringBuilder();
while (wip >= toBase) {
int index = (int) (wip % toBase);
converted.Insert(0, Characters[index]);
wip = wip / toBase;
}
return converted.Insert(0, Characters[(int) wip]).ToString();
throw new OverflowException();
}
}
else if (wip < toBase) {
return Characters[(int) wip].ToString();
}
else {
var converted = new StringBuilder();
while (wip >= toBase) {
int index = (int) (wip % toBase);
converted.Insert(0, Characters[index]);
wip /= toBase;
}
return converted.Insert(0, Characters[(int) wip]).ToString();
}
}
}

144
AppConv/Utils/SI.cs
View File

@ -2,88 +2,86 @@
using System.Collections.Generic;
using AppConv.General;
namespace AppConv.Utils {
static class SI {
private static readonly List<Tuple<string, string, int>> Factors = new List<Tuple<string, string, int>> {
new Tuple<string, string, int>("yotta", "Y", 24),
new Tuple<string, string, int>("zetta", "Z", 21),
new Tuple<string, string, int>("exa", "E", 18),
new Tuple<string, string, int>("peta", "P", 15),
new Tuple<string, string, int>("tera", "T", 12),
new Tuple<string, string, int>("giga", "G", 9),
new Tuple<string, string, int>("mega", "M", 6),
new Tuple<string, string, int>("kilo", "k", 3),
new Tuple<string, string, int>("hecto", "h", 2),
new Tuple<string, string, int>("deca", "da", 1),
new Tuple<string, string, int>("deci", "d", -1),
new Tuple<string, string, int>("centi", "c", -2),
new Tuple<string, string, int>("milli", "m", -3),
new Tuple<string, string, int>("micro", "μ", -6),
new Tuple<string, string, int>("nano", "n", -9),
new Tuple<string, string, int>("pico", "p", -12),
new Tuple<string, string, int>("femto", "f", -15),
new Tuple<string, string, int>("atto", "a", -18),
new Tuple<string, string, int>("zepto", "z", -21),
new Tuple<string, string, int>("yocto", "y", -24)
};
namespace AppConv.Utils;
public static void AddSupport<T>(Type enumType, T unitObject, string[] unitShortNames, string[] unitLongNames, DecimalUnitConverterBase<T>.DecimalFuncMap funcFrom, DecimalUnitConverterBase<T>.DecimalFuncMap funcTo, DecimalUnitConverterBase<T>.NameMap nameMap) where T : struct {
int enumCounter = 1000 + Factors.Count * (int) (object) unitObject;
static class SI {
private static readonly List<Tuple<string, string, int>> Factors = [
new Tuple<string, string, int>("yotta", "Y", 24),
new Tuple<string, string, int>("zetta", "Z", 21),
new Tuple<string, string, int>("exa", "E", 18),
new Tuple<string, string, int>("peta", "P", 15),
new Tuple<string, string, int>("tera", "T", 12),
new Tuple<string, string, int>("giga", "G", 9),
new Tuple<string, string, int>("mega", "M", 6),
new Tuple<string, string, int>("kilo", "k", 3),
new Tuple<string, string, int>("hecto", "h", 2),
new Tuple<string, string, int>("deca", "da", 1),
new Tuple<string, string, int>("deci", "d", -1),
new Tuple<string, string, int>("centi", "c", -2),
new Tuple<string, string, int>("milli", "m", -3),
new Tuple<string, string, int>("micro", "μ", -6),
new Tuple<string, string, int>("nano", "n", -9),
new Tuple<string, string, int>("pico", "p", -12),
new Tuple<string, string, int>("femto", "f", -15),
new Tuple<string, string, int>("atto", "a", -18),
new Tuple<string, string, int>("zepto", "z", -21),
new Tuple<string, string, int>("yocto", "y", -24)
];
Func<decimal, decimal> convertFrom = funcFrom[unitObject];
Func<decimal, decimal> convertTo = funcTo[unitObject];
public static void AddSupport<T>(T unitObject, string[] unitShortNames, string[] unitLongNames, DecimalUnitConverterBase<T>.DecimalFuncMap funcFrom, DecimalUnitConverterBase<T>.DecimalFuncMap funcTo, DecimalUnitConverterBase<T>.NameMap nameMap) where T : struct {
int enumCounter = 1000 + Factors.Count * (int) (object) unitObject;
foreach (Tuple<string, string, int> factor in Factors) {
T enumObject = (T) (object) enumCounter++;
int exponent = factor.Item3;
Func<decimal, decimal> convertFrom = funcFrom[unitObject];
Func<decimal, decimal> convertTo = funcTo[unitObject];
foreach (string unitShortName in unitShortNames) {
nameMap.Add(factor.Item2 + unitShortName, enumObject);
}
foreach ((string unitLongNamePrefix, string unitShotNamePrefix, int exponent) in Factors) {
T enumObject = (T) (object) enumCounter++;
foreach (string unitLongName in unitLongNames) {
nameMap.Add(factor.Item1 + unitLongName, enumObject);
}
funcFrom.Add(enumObject, val => convertFrom(val) * (decimal) Math.Pow(10, -exponent));
funcTo.Add(enumObject, val => convertTo(val) * (decimal) Math.Pow(10, exponent));
foreach (string unitShortName in unitShortNames) {
nameMap.Add(unitShotNamePrefix + unitShortName, enumObject);
}
}
public static void AddSupportCustom<T>(Type enumType, T unitObject, string[] unitShortNames, string[] unitLongNames, DecimalUnitConverterBase<T>.DecimalFuncMap funcFrom, DecimalUnitConverterBase<T>.DecimalFuncMap funcTo, DecimalUnitConverterBase<T>.NameMap nameMap, ExtededProperties extendedProps) where T : struct {
int enumCounter = 1000 + Factors.Count * (int) (object) unitObject;
Func<decimal, decimal> convertFrom = funcFrom[unitObject];
Func<decimal, decimal> convertTo = funcTo[unitObject];
foreach (Tuple<string, string, int> factor in Factors) {
if (extendedProps.FactorPredicate != null && !extendedProps.FactorPredicate(factor.Item3)) {
continue;
}
T enumObject = (T) (object) enumCounter++;
int exponent = factor.Item3;
foreach (string unitShortName in unitShortNames) {
nameMap.Add(factor.Item2 + unitShortName, enumObject);
}
foreach (string unitLongName in unitLongNames) {
nameMap.Add(factor.Item1 + unitLongName, enumObject);
}
Func<decimal> genFrom = extendedProps.FromFunctionGenerator(exponent);
Func<decimal> genTo = extendedProps.ToFunctionGenerator(exponent);
funcFrom.Add(enumObject, val => convertFrom(val) * genFrom());
funcTo.Add(enumObject, val => convertTo(val) * genTo());
foreach (string unitLongName in unitLongNames) {
nameMap.Add(unitLongNamePrefix + unitLongName, enumObject);
}
}
internal class ExtededProperties {
public Predicate<int> FactorPredicate { get; set; }
public Func<int, Func<decimal>> FromFunctionGenerator { get; set; }
public Func<int, Func<decimal>> ToFunctionGenerator { get; set; }
funcFrom.Add(enumObject, val => convertFrom(val) * (decimal) Math.Pow(10, -exponent));
funcTo.Add(enumObject, val => convertTo(val) * (decimal) Math.Pow(10, exponent));
}
}
public static void AddSupportCustom<T>(T unitObject, string[] unitShortNames, string[] unitLongNames, DecimalUnitConverterBase<T>.DecimalFuncMap funcFrom, DecimalUnitConverterBase<T>.DecimalFuncMap funcTo, DecimalUnitConverterBase<T>.NameMap nameMap, ExtededProperties extendedProps) where T : struct {
int enumCounter = 1000 + Factors.Count * (int) (object) unitObject;
Func<decimal, decimal> convertFrom = funcFrom[unitObject];
Func<decimal, decimal> convertTo = funcTo[unitObject];
foreach ((string unitLongNamePrefix, string unitShortNamePrefix, int exponent) in Factors) {
if (extendedProps.FactorPredicate != null && !extendedProps.FactorPredicate(exponent)) {
continue;
}
T enumObject = (T) (object) enumCounter++;
foreach (string unitShortName in unitShortNames) {
nameMap.Add(unitShortNamePrefix + unitShortName, enumObject);
}
foreach (string unitLongName in unitLongNames) {
nameMap.Add(unitLongNamePrefix + unitLongName, enumObject);
}
Func<decimal> genFrom = extendedProps.FromFunctionGenerator(exponent);
Func<decimal> genTo = extendedProps.ToFunctionGenerator(exponent);
funcFrom.Add(enumObject, val => convertFrom(val) * genFrom());
funcTo.Add(enumObject, val => convertTo(val) * genTo());
}
}
internal sealed class ExtededProperties {
public Predicate<int> FactorPredicate { get; init; }
public Func<int, Func<decimal>> FromFunctionGenerator { get; init; }
public Func<int, Func<decimal>> ToFunctionGenerator { get; init; }
}
}

34
AppMeme/App.cs
View File

@ -1,25 +1,25 @@
using System.Collections.Generic;
using Base;
namespace AppMeme {
public sealed class App : IApp {
private static readonly Dictionary<string, string> Map = new Dictionary<string, string> {
{ "shrug", @"¯\_(ツ)_/¯" },
{ "lenny", @"( ͡° ͜ʖ ͡°)" },
{ "flip", @"(╯°□°）╯︵ ┻━┻" },
{ "tableflip", @"(╯°□°）╯︵ ┻━┻" }
};
namespace AppMeme;
public string[] RecognizedNames => new string[] {
"meme"
};
public sealed class App : IApp {
private static readonly Dictionary<string, string> Map = new () {
{ "shrug", @"¯\_(ツ)_/¯" },
{ "lenny", @"( ͡° ͜ʖ ͡°)" },
{ "flip", @"(╯°□°）╯︵ ┻━┻" },
{ "tableflip", @"(╯°□°）╯︵ ┻━┻" }
};
public MatchConfidence GetConfidence(Command cmd) {
return Map.ContainsKey(cmd.Text) ? MatchConfidence.Full : MatchConfidence.None;
}
public string[] RecognizedNames => [
"meme"
];
public string ProcessCommand(Command cmd) {
return Map[cmd.Text];
}
public MatchConfidence GetConfidence(Command cmd) {
return Map.ContainsKey(cmd.Text) ? MatchConfidence.Full : MatchConfidence.None;
}
public string ProcessCommand(Command cmd) {
return Map[cmd.Text];
}
}

34
AppWindows/App.cs
View File

@ -2,25 +2,25 @@
using AppSys.Handlers;
using Base;
namespace AppSys {
public sealed class App : IApp {
private static readonly IHandler[] Handlers = {
new HandlerProcesses(),
new HandlerApps()
};
namespace AppSys;
public string[] RecognizedNames => new string[] {
"sys",
"os",
"win"
};
public sealed class App : IApp {
private static readonly IHandler[] Handlers = [
new HandlerProcesses(),
new HandlerApps()
];
public MatchConfidence GetConfidence(Command cmd) {
return Handlers.Any(handler => handler.Matches(cmd)) ? MatchConfidence.Full : MatchConfidence.None;
}
public string[] RecognizedNames => [
"sys",
"os",
"win"
];
public string ProcessCommand(Command cmd) {
return Handlers.First(handler => handler.Matches(cmd)).Handle(cmd);
}
public MatchConfidence GetConfidence(Command cmd) {
return Handlers.Any(handler => handler.Matches(cmd)) ? MatchConfidence.Full : MatchConfidence.None;
}
public string ProcessCommand(Command cmd) {
return Handlers.First(handler => handler.Matches(cmd)).Handle(cmd);
}
}

90
AppWindows/Handlers/HandlerApps.cs
View File

@ -4,58 +4,56 @@ using System.Diagnostics;
using System.IO;
using Base;
namespace AppSys.Handlers {
class HandlerApps : IHandler {
private static readonly string PathSystem = Environment.GetFolderPath(Environment.SpecialFolder.System);
namespace AppSys.Handlers;
private static readonly Dictionary<string, ProcessStartInfo> Mappings = new Dictionary<string, ProcessStartInfo> {
{
"audio", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "mmsys.cpl"
}
}, {
"programs", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "appwiz.cpl"
}
}, {
"system", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "sysdm.cpl"
}
}, {
"environment", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "rundll32.exe"),
Arguments = "sysdm.cpl,EditEnvironmentVariables"
}
sealed class HandlerApps : IHandler {
private static readonly string PathSystem = Environment.GetFolderPath(Environment.SpecialFolder.System);
private static readonly Dictionary<string, ProcessStartInfo> Mappings = new () {
{
"audio", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "mmsys.cpl"
}
};
}, {
"programs", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "appwiz.cpl"
}
}, {
"system", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "control.exe"),
Arguments = "sysdm.cpl"
}
}, {
"environment", new ProcessStartInfo {
FileName = Path.Combine(PathSystem, "rundll32.exe"),
Arguments = "sysdm.cpl,EditEnvironmentVariables"
}
}
};
private static readonly Dictionary<string, string> Substitutions = new Dictionary<string, string> {
{ "sounds", "audio" },
{ "apps", "programs" },
{ "appwiz", "programs" },
{ "env", "environment" },
{ "envvars", "environment" },
{ "vars", "environment" },
{ "variables", "environment" }
};
private static readonly Dictionary<string, string> Substitutions = new () {
{ "sounds", "audio" },
{ "apps", "programs" },
{ "appwiz", "programs" },
{ "env", "environment" },
{ "envvars", "environment" },
{ "vars", "environment" },
{ "variables", "environment" }
};
public bool Matches(Command cmd) {
return Mappings.ContainsKey(cmd.Text) || Substitutions.ContainsKey(cmd.Text);
public bool Matches(Command cmd) {
return Mappings.ContainsKey(cmd.Text) || Substitutions.ContainsKey(cmd.Text);
}
public string Handle(Command cmd) {
if (!Substitutions.TryGetValue(cmd.Text, out string key)) {
key = cmd.Text;
}
public string Handle(Command cmd) {
string key;
using (Process.Start(Mappings[key])) {}
if (!Substitutions.TryGetValue(cmd.Text, out key)) {
key = cmd.Text;
}
using (Process.Start(Mappings[key])) {}
return null;
}
return null;
}
}

68
AppWindows/Handlers/HandlerProcesses.cs
View File

@ -3,47 +3,47 @@ using System.Diagnostics;
using System.Text;
using Base;
namespace AppSys.Handlers {
class HandlerProcesses : IHandler {
public bool Matches(Command cmd) {
return cmd.Text.StartsWith("kill ", StringComparison.InvariantCultureIgnoreCase);
}
namespace AppSys.Handlers;
public string Handle(Command cmd) {
string[] processNames = cmd.Text.Substring("kill ".Length).Split(',', ';');
int succeeded = 0, failed = 0;
sealed class HandlerProcesses : IHandler {
public bool Matches(Command cmd) {
return cmd.Text.StartsWith("kill ", StringComparison.InvariantCultureIgnoreCase);
}
foreach (string processName in processNames) {
try {
Process[] processes = Process.GetProcessesByName(processName.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase) ? processName.Substring(0, processName.Length - 4) : processName);
public string Handle(Command cmd) {
string[] processNames = cmd.Text["kill ".Length..].Split(',', ';');
int succeeded = 0, failed = 0;
foreach (Process process in processes) {
try {
process.Kill();
++succeeded;
} catch {
++failed;
}
foreach (string processName in processNames) {
try {
Process[] processes = Process.GetProcessesByName(processName.EndsWith(".exe", StringComparison.InvariantCultureIgnoreCase) ? processName[..^4] : processName);
process.Close();
foreach (Process process in processes) {
try {
process.Kill();
++succeeded;
} catch {
++failed;
}
} catch {
++failed;
process.Close();
}
} catch {
++failed;
}
if (succeeded == 0 && failed == 0 && (cmd.Text.Equals("kill me", StringComparison.InvariantCultureIgnoreCase) || cmd.Text.StartsWith("kill me ", StringComparison.InvariantCultureIgnoreCase) || cmd.Text.StartsWith("kill me,", StringComparison.InvariantCultureIgnoreCase))) {
return "No.";
}
var build = new StringBuilder();
build.Append("Killed ").Append(succeeded).Append(" process").Append(succeeded == 1 ? "" : "es");
if (failed > 0) {
build.Append(", failed ").Append(failed);
}
return build.Append('.').ToString();
}
if (succeeded == 0 && failed == 0 && (cmd.Text.Equals("kill me", StringComparison.InvariantCultureIgnoreCase) || cmd.Text.StartsWith("kill me ", StringComparison.InvariantCultureIgnoreCase) || cmd.Text.StartsWith("kill me,", StringComparison.InvariantCultureIgnoreCase))) {
return "No.";
}
var build = new StringBuilder();
build.Append("Killed ").Append(succeeded).Append(" process").Append(succeeded == 1 ? "" : "es");
if (failed > 0) {
build.Append(", failed ").Append(failed);
}
return build.Append('.').ToString();
}
}

10
AppWindows/IHandler.cs
View File

@ -1,8 +1,8 @@
using Base;
namespace AppSys {
interface IHandler {
bool Matches(Command cmd);
string Handle(Command cmd);
}
namespace AppSys;
interface IHandler {
bool Matches(Command cmd);
string Handle(Command cmd);
}

46
Base/Command.cs
View File

@ -2,39 +2,35 @@
using System.Text.RegularExpressions;
using Base.Utils;
namespace Base {
public sealed class Command {
private static readonly Regex RegexBalancedBrackets = new Regex(RegexUtils.Balance(@"\[", @"\]"), RegexOptions.Compiled);
private static readonly Regex RegexBalancedParentheses = new Regex(RegexUtils.Balance(@"\(", @"\)"), RegexOptions.Compiled);
namespace Base;
public string Text { get; private set; }
public sealed class Command(string text) {
private static readonly Regex RegexBalancedBrackets = new (RegexUtils.Balance(@"\[", @"\]"), RegexOptions.Compiled);
private static readonly Regex RegexBalancedParentheses = new (RegexUtils.Balance(@"\(", @"\)"), RegexOptions.Compiled);
public string PotentialAppName {
get {
int firstSpace = Text.IndexOf(' ');
public string Text { get; } = text;
if (firstSpace == -1) {
return null;
}
public string PotentialAppName {
get {
int firstSpace = Text.IndexOf(' ');
string firstToken = Text.Substring(0, firstSpace);
if (!firstToken.All(char.IsLetter)) {
return null;
}
return firstToken;
if (firstSpace == -1) {
return null;
}
}
public bool IsSingleToken => Text.IndexOf(' ') == -1;
string firstToken = Text[..firstSpace];
public Command(string text) {
Text = text;
}
if (!firstToken.All(char.IsLetter)) {
return null;
}
public Command ReplaceBrackets(MatchEvaluator evaluator) {
return new Command(RegexBalancedParentheses.Replace(RegexBalancedBrackets.Replace(Text, evaluator), evaluator));
return firstToken;
}
}
public bool IsSingleToken => !Text.Contains(' ');
public Command ReplaceBrackets(MatchEvaluator evaluator) {
return new Command(RegexBalancedParentheses.Replace(RegexBalancedBrackets.Replace(Text, evaluator), evaluator));
}
}

10
Base/CommandEventArgs.cs
View File

@ -1,11 +1,7 @@
using System;
namespace Base {
public class CommandEventArgs : EventArgs {
public Command Command { get; private set; }
namespace Base;
public CommandEventArgs(string text) {
Command = new Command(text);
}
}
public sealed class CommandEventArgs(string text) : EventArgs {
public Command Command { get; private set; } = new (text);
}

10
Base/CommandException.cs
View File

@ -1,8 +1,8 @@
using System;
namespace Base {
public class CommandException : Exception {
public CommandException(string message) : base(message) {}
public CommandException(string message, Exception innerException) : base(message, innerException) {}
}
namespace Base;
public sealed class CommandException : Exception {
public CommandException(string message) : base(message) {}
public CommandException(string message, Exception innerException) : base(message, innerException) {}
}

12
Base/IApp.cs
View File

@ -1,8 +1,8 @@
namespace Base {
public interface IApp {
string[] RecognizedNames { get; }
namespace Base;
MatchConfidence GetConfidence(Command cmd);
string ProcessCommand(Command cmd);
}
public interface IApp {
string[] RecognizedNames { get; }
MatchConfidence GetConfidence(Command cmd);
string ProcessCommand(Command cmd);
}

14
Base/MatchConfidence.cs
View File

@ -1,8 +1,8 @@
namespace Base {
public enum MatchConfidence {
None = 0,
Low = 1,
Possible = 2,
Full = 3
}
namespace Base;
public enum MatchConfidence {
None = 0,
Low = 1,
Possible = 2,
Full = 3
}

34
Base/Utils/RegexUtils.cs
View File

@ -1,23 +1,23 @@
using System.Text;
using System.Text.RegularExpressions;
namespace Base.Utils {
public static class RegexUtils {
public static readonly RegexOptions Text = RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled;
namespace Base.Utils;
public static string Balance(string escapedStart, string escapedEnd) { // \(((?>[^()]+|\((?<n>)|\)(?<-n>))+(?(n)(?!)))\)
return new StringBuilder()
.Append(escapedStart)
.Append(@"((?>[^")
.Append(escapedStart)
.Append(escapedEnd)
.Append(@"]+|")
.Append(escapedStart)
.Append(@"(?<n>)|")
.Append(escapedEnd)
.Append(@"(?<-n>))+(?(n)(?!)))")
.Append(escapedEnd)
.ToString();
}
public static class RegexUtils {
public const RegexOptions Text = RegexOptions.CultureInvariant | RegexOptions.IgnoreCase | RegexOptions.ExplicitCapture | RegexOptions.Compiled;
internal static string Balance(string escapedStart, string escapedEnd) { // \(((?>[^()]+|\((?<n>)|\)(?<-n>))+(?(n)(?!)))\)
return new StringBuilder()
.Append(escapedStart)
.Append("((?>[^")
.Append(escapedStart)
.Append(escapedEnd)
.Append("]+|")
.Append(escapedStart)
.Append("(?<n>)|")
.Append(escapedEnd)
.Append("(?<-n>))+(?(n)(?!)))")
.Append(escapedEnd)
.ToString();
}
}

72
Query/Controls/QueryHistoryLog.cs
View File

@ -2,45 +2,45 @@
using System.Drawing;
using System.Windows.Forms;
namespace Query.Controls {
sealed partial class QueryHistoryLog : UserControl {
public enum EntryType {
UserInput,
CommandResult,
Information,
Error
}
namespace Query.Controls;
private static readonly Dictionary<EntryType, Color> EntryColorMap = new Dictionary<EntryType, Color> {
{ EntryType.UserInput, Color.FromArgb(160, 160, 160) },
{ EntryType.CommandResult, Color.FromArgb(240, 240, 240) },
{ EntryType.Information, Color.FromArgb(160, 255, 140) },
{ EntryType.Error, Color.FromArgb(255, 40, 40) }
sealed partial class QueryHistoryLog : UserControl {
public enum EntryType {
UserInput,
CommandResult,
Information,
Error
}
private static readonly Dictionary<EntryType, Color> EntryColorMap = new () {
{ EntryType.UserInput, Color.FromArgb(160, 160, 160) },
{ EntryType.CommandResult, Color.FromArgb(240, 240, 240) },
{ EntryType.Information, Color.FromArgb(160, 255, 140) },
{ EntryType.Error, Color.FromArgb(255, 40, 40) }
};
public QueryHistoryLog() {
InitializeComponent();
}
public void AddEntry(string text, EntryType type) {
int width = container.Width - SystemInformation.VerticalScrollBarWidth;
Label label = new Label {
AutoSize = true,
Font = container.Font,
ForeColor = EntryColorMap[type],
Text = text,
Margin = new Padding(0, 1, 0, 1),
MaximumSize = new Size(width, 0),
Width = width
};
public QueryHistoryLog() {
InitializeComponent();
}
container.Controls.Add(label);
container.AutoScrollPosition = new Point(0, container.VerticalScroll.Maximum);
}
public void AddEntry(string text, EntryType type) {
int width = container.Width - SystemInformation.VerticalScrollBarWidth;
Label label = new Label {
AutoSize = true,
Font = container.Font,
ForeColor = EntryColorMap[type],
Text = text,
Margin = new Padding(0, 1, 0, 1),
MaximumSize = new Size(width, 0),
Width = width
};
container.Controls.Add(label);
container.AutoScrollPosition = new Point(0, container.VerticalScroll.Maximum);
}
public void ClearEntries() {
container.Controls.Clear();
}
public void ClearEntries() {
container.Controls.Clear();
}
}

242
Query/Controls/QueryTextBox.cs
View File

@ -5,154 +5,154 @@ using System.Windows.Forms;
using Base;
using Query.Core;
namespace Query.Controls {
sealed partial class QueryTextBox : UserControl {
public event EventHandler<CommandEventArgs> CommandRan;
namespace Query.Controls;
private CommandHistory history;
private Action<string> log;
sealed partial class QueryTextBox : UserControl {
public event EventHandler<CommandEventArgs> CommandRan;
public QueryTextBox() {
InitializeComponent();
private CommandHistory history;
private Action<string> log;
public QueryTextBox() {
InitializeComponent();
}
public void Setup(CommandHistory historyObj, Action<string> logFunc) {
history = historyObj;
log = logFunc;
}
private void OnCommandRan() {
CommandRan?.Invoke(this, new CommandEventArgs(tb.Text));
}
private sealed class CustomTextBox : TextBox {
private string lastInputStr = string.Empty;
private int lastInputPos = 0;
private bool doResetHistoryMemory;
private bool lastArrowShift;
private int historyOffset;
public CustomTextBox() {
TextChanged += CustomTextBox_TextChanged;
}
public void Setup(CommandHistory historyObj, Action<string> logFunc) {
history = historyObj;
log = logFunc;
}
protected override void OnKeyDown(KeyEventArgs e) {
QueryTextBox input = (QueryTextBox) Parent;
CommandHistory history = input!.history;
private void OnCommandRan() {
CommandRan?.Invoke(this, new CommandEventArgs(tb.Text));
}
Keys key = e.KeyCode;
bool handled = false;
private sealed class CustomTextBox : TextBox {
private string lastInputStr = string.Empty;
private int lastInputPos = 0;
switch (key) {
case Keys.Enter:
if (Text != string.Empty) {
input.OnCommandRan();
private bool doResetHistoryMemory;
private bool lastArrowShift;
private int historyOffset;
Text = string.Empty;
doResetHistoryMemory = true;
handled = true;
}
public CustomTextBox() {
TextChanged += CustomTextBox_TextChanged;
}
break;
protected override void OnKeyDown(KeyEventArgs e) {
QueryTextBox input = (QueryTextBox) Parent;
CommandHistory history = input.history;
case Keys.Up:
if (lastArrowShift != e.Shift) {
lastArrowShift = e.Shift;
historyOffset = 0;
}
Keys key = e.KeyCode;
bool handled = false;
--historyOffset;
switch (key) {
case Keys.Enter:
if (Text != string.Empty) {
input.OnCommandRan();
if (InsertFromHistory(e.Shift ? history.Results : history.Queries)) {
++historyOffset;
}
Text = string.Empty;
doResetHistoryMemory = true;
handled = true;
break;
case Keys.Down:
if (lastArrowShift != e.Shift) {
lastArrowShift = e.Shift;
historyOffset = 0;
}
++historyOffset;
if (InsertFromHistory(e.Shift ? history.Results : history.Queries)) {
--historyOffset;
}
handled = true;
break;
case Keys.C:
if (e.Modifiers == Keys.Control) {
if (SelectionLength == 0 && history.Results.Count > 0) {
Clipboard.SetText(history.Results.Last(), TextDataFormat.UnicodeText);
input.log("Copied to clipboard.");
handled = true;
}
}
break;
case Keys.Up:
if (lastArrowShift != e.Shift) {
lastArrowShift = e.Shift;
historyOffset = 0;
}
--historyOffset;
if (InsertFromHistory(e.Shift ? history.Results : history.Queries)) {
++historyOffset;
}
handled = true;
break;
case Keys.Down:
if (lastArrowShift != e.Shift) {
lastArrowShift = e.Shift;
historyOffset = 0;
}
++historyOffset;
if (InsertFromHistory(e.Shift ? history.Results : history.Queries)) {
--historyOffset;
}
handled = true;
break;
case Keys.C:
if (e.Modifiers == Keys.Control) {
if (SelectionLength == 0 && history.Results.Count > 0) {
Clipboard.SetText(history.Results.Last(), TextDataFormat.UnicodeText);
input.log("Copied to clipboard.");
handled = true;
}
}
break;
}
if (!handled && key != Keys.ControlKey && key != Keys.ShiftKey && key != Keys.Menu) {
doResetHistoryMemory = true;
}
e.Handled = e.SuppressKeyPress = handled;
base.OnKeyDown(e);
break;
}
protected override void OnKeyUp(KeyEventArgs e) {
base.OnKeyUp(e);
if (doResetHistoryMemory) {
doResetHistoryMemory = false;
ResetHistoryMemory();
}
if (!handled && key != Keys.ControlKey && key != Keys.ShiftKey && key != Keys.Menu) {
doResetHistoryMemory = true;
}
private void CustomTextBox_TextChanged(object sender, EventArgs e) {
e.Handled = e.SuppressKeyPress = handled;
base.OnKeyDown(e);
}
protected override void OnKeyUp(KeyEventArgs e) {
base.OnKeyUp(e);
if (doResetHistoryMemory) {
doResetHistoryMemory = false;
ResetHistoryMemory();
}
}
// Management
private void CustomTextBox_TextChanged(object sender, EventArgs e) {
ResetHistoryMemory();
}
private void ResetHistoryMemory() {
lastInputStr = Text;
lastInputPos = SelectionStart;
historyOffset = 0;
// Management
private void ResetHistoryMemory() {
lastInputStr = Text;
lastInputPos = SelectionStart;
historyOffset = 0;
}
private bool InsertFromHistory(IList<string> collection) {
if (collection.Count == 0) {
return true;
}
private bool InsertFromHistory(IList<string> collection) {
if (collection.Count == 0) {
return true;
}
int index = collection.Count + historyOffset;
bool wasClamped = false;
int index = collection.Count + historyOffset;
bool wasClamped = false;
if (index < 0) {
index = 0;
wasClamped = true;
}
else if (index >= collection.Count) {
index = collection.Count - 1;
wasClamped = true;
}
TextChanged -= CustomTextBox_TextChanged;
Text = lastInputStr.Insert(lastInputPos, collection[index]);
SelectionStart = lastInputPos + collection[index].Length;
SelectionLength = 0;
TextChanged += CustomTextBox_TextChanged;
return wasClamped;
if (index < 0) {
index = 0;
wasClamped = true;
}
else if (index >= collection.Count) {
index = collection.Count - 1;
wasClamped = true;
}
TextChanged -= CustomTextBox_TextChanged;
Text = lastInputStr.Insert(lastInputPos, collection[index]);
SelectionStart = lastInputPos + collection[index].Length;
SelectionLength = 0;
TextChanged += CustomTextBox_TextChanged;
return wasClamped;
}
}
}

32
Query/Core/CommandHistory.cs
View File

@ -1,25 +1,25 @@
using System.Collections.Generic;
namespace Query.Core {
sealed class CommandHistory {
private readonly List<string> queries = new List<string>();
private readonly List<string> results = new List<string>();
namespace Query.Core;
public IList<string> Queries => queries;
sealed class CommandHistory {
private readonly List<string> queries = [];
private readonly List<string> results = [];
public IList<string> Results => results;
public IList<string> Queries => queries;
public void AddQuery(string text) {
queries.Add(text);
}
public IList<string> Results => results;
public void AddResult(string text) {
results.Add(text);
}
public void AddQuery(string text) {
queries.Add(text);
}
public void Clear() {
queries.Clear();
results.Clear();
}
public void AddResult(string text) {
results.Add(text);
}
public void Clear() {
queries.Clear();
results.Clear();
}
}

105
Query/Core/CommandProcessor.cs
View File

@ -3,63 +3,62 @@ using System.Collections.Generic;
using System.Linq;
using Base;
namespace Query.Core {
sealed class CommandProcessor {
private readonly Dictionary<string, IApp> appNames = new Dictionary<string, IApp>(8);
private readonly HashSet<IApp> appSet = new HashSet<IApp>();
namespace Query.Core;
public Func<string, bool> SingleTokenProcessor { get; set; }
sealed class CommandProcessor {
private readonly Dictionary<string, IApp> appNames = new (8);
private readonly HashSet<IApp> appSet = [];
public void AddApp<T>() where T : IApp, new() {
IApp app = new T();
public Func<string, bool> SingleTokenProcessor { get; init; }
foreach (string name in app.RecognizedNames) {
appNames.Add(name, app);
appSet.Add(app);
}
}
public void AddApp<T>() where T : IApp, new() {
IApp app = new T();
public string Run(Command cmd) {
cmd = cmd.ReplaceBrackets(match => Run(new Command(match.Groups[1].Value)));
string appName = cmd.PotentialAppName;
IApp app;
if (appName != null && appNames.TryGetValue(appName.ToLowerInvariant(), out app)) {
return app.ProcessCommand(new Command(cmd.Text.Substring(appName.Length + 1)));
}
if (cmd.IsSingleToken && SingleTokenProcessor != null && SingleTokenProcessor(cmd.Text)) {
return null;
}
var list = appSet.Select(iapp => new { App = iapp, Confidence = iapp.GetConfidence(cmd) }).OrderByDescending(obj => obj.Confidence).Where(obj => obj.Confidence != MatchConfidence.None).ToList();
if (list.Count == 0) {
throw new CommandException("Could not find any suitable app, please write the app name and press Up Arrow.");
}
else if (list.Count == 1) {
app = list[0].App;
}
else {
List<IApp> plausible = new List<IApp> { list[0].App };
MatchConfidence topConfidence = list[0].Confidence;
for (int index = 1; index < list.Count; index++) {
if (list[index].Confidence == topConfidence) {
plausible.Add(list[index].App);
}
}
if (plausible.Count == 1) {
app = plausible.First();
}
else {
throw new CommandException("Command is ambiguous, please write the app name and press Up Arrow. Suggested apps: " + string.Join(", ", plausible.Select(iapp => iapp.RecognizedNames.First())));
}
}
return app.ProcessCommand(cmd);
foreach (string name in app.RecognizedNames) {
appNames.Add(name, app);
appSet.Add(app);
}
}
public string Run(Command cmd) {
cmd = cmd.ReplaceBrackets(match => Run(new Command(match.Groups[1].Value)));
string appName = cmd.PotentialAppName;
if (appName != null && appNames.TryGetValue(appName.ToLowerInvariant(), out IApp app)) {
return app.ProcessCommand(new Command(cmd.Text[(appName.Length + 1)..]));
}
if (cmd.IsSingleToken && SingleTokenProcessor != null && SingleTokenProcessor(cmd.Text)) {
return null;
}
var list = appSet.Select(iapp => new { App = iapp, Confidence = iapp.GetConfidence(cmd) }).OrderByDescending(static obj => obj.Confidence).Where(static obj => obj.Confidence != MatchConfidence.None).ToList();
if (list.Count == 0) {
throw new CommandException("Could not find any suitable app, please write the app name and press Up Arrow.");
}
else if (list.Count == 1) {
app = list[0].App;
}
else {
List<IApp> plausible = [list[0].App];
MatchConfidence topConfidence = list[0].Confidence;
for (int index = 1; index < list.Count; index++) {
if (list[index].Confidence == topConfidence) {
plausible.Add(list[index].App);
}
}
if (plausible.Count == 1) {
app = plausible.First();
}
else {
throw new CommandException("Command is ambiguous, please write the app name and press Up Arrow. Suggested apps: " + string.Join(", ", plausible.Select(static iapp => iapp.RecognizedNames.First())));
}
}
return app.ProcessCommand(cmd);
}
}

103
Query/Core/KeyboardHook.cs
View File

@ -2,63 +2,62 @@
using System.Runtime.InteropServices;
using System.Windows.Forms;
namespace Query.Core {
sealed class KeyboardHook {
public event EventHandler Triggered;
namespace Query.Core;
// ReSharper disable once PrivateFieldCanBeConvertedToLocalVariable
private readonly NativeMethods.HookProc keyboardHookDelegate;
private IntPtr keyboardHook;
sealed class KeyboardHook {
public event EventHandler Triggered;
public KeyboardHook() {
keyboardHookDelegate = KeyboardHookProc;
// ReSharper disable once PrivateFieldCanBeConvertedToLocalVariable
private readonly NativeMethods.HookProc keyboardHookDelegate;
private IntPtr keyboardHook;
public KeyboardHook() {
keyboardHookDelegate = KeyboardHookProc;
}
public void StartHook() {
if (keyboardHook != IntPtr.Zero) {
NativeMethods.UnhookWindowsHookEx(keyboardHook);
}
public void StartHook() {
if (keyboardHook != IntPtr.Zero) {
NativeMethods.UnhookWindowsHookEx(keyboardHook);
}
keyboardHook = NativeMethods.SetWindowsHookEx(NativeMethods.WH_KEYBOARD_LL, keyboardHookDelegate, IntPtr.Zero, 0);
}
keyboardHook = NativeMethods.SetWindowsHookEx(NativeMethods.WH_KEYBOARD_LL, keyboardHookDelegate, IntPtr.Zero, 0);
}
public void StopHook() {
if (keyboardHook != IntPtr.Zero) {
NativeMethods.UnhookWindowsHookEx(keyboardHook);
keyboardHook = IntPtr.Zero;
}
}
private IntPtr KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) {
if (wParam == (IntPtr) NativeMethods.WM_KEYDOWN) {
Keys key = (Keys) Marshal.ReadInt32(lParam);
if ((key == Keys.LWin || key == Keys.RWin) && Control.ModifierKeys.HasFlag(Keys.Control)) {
Triggered?.Invoke(this, EventArgs.Empty);
return NativeMethods.HookHandled;
}
}
return NativeMethods.CallNextHookEx(keyboardHook, nCode, wParam, lParam);
}
private static class NativeMethods {
public const int WH_KEYBOARD_LL = 13;
public const int WM_KEYDOWN = 0x0100;
public const int WM_KEYUP = 0x0101;
public static readonly IntPtr HookHandled = new IntPtr(-1);
public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
[DllImport("user32.dll")]
public static extern bool UnhookWindowsHookEx(IntPtr idHook);
[DllImport("user32.dll")]
public static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, IntPtr wParam, IntPtr lParam);
public void StopHook() {
if (keyboardHook != IntPtr.Zero) {
NativeMethods.UnhookWindowsHookEx(keyboardHook);
keyboardHook = IntPtr.Zero;
}
}
private IntPtr KeyboardHookProc(int nCode, IntPtr wParam, IntPtr lParam) {
if (wParam == NativeMethods.WM_KEYDOWN) {
Keys key = (Keys) Marshal.ReadInt32(lParam);
if (key is Keys.LWin or Keys.RWin && Control.ModifierKeys.HasFlag(Keys.Control)) {
Triggered?.Invoke(this, EventArgs.Empty);
return NativeMethods.HookHandled;
}
}
return NativeMethods.CallNextHookEx(keyboardHook, nCode, wParam, lParam);
}
private static class NativeMethods {
public const int WH_KEYBOARD_LL = 13;
public const int WM_KEYDOWN = 0x0100;
public static readonly IntPtr HookHandled = new (-1);
public delegate IntPtr HookProc(int nCode, IntPtr wParam, IntPtr lParam);
[DllImport("user32.dll")]
public static extern IntPtr SetWindowsHookEx(int idHook, HookProc lpfn, IntPtr hInstance, int threadId);
[DllImport("user32.dll")]
public static extern bool UnhookWindowsHookEx(IntPtr idHook);
[DllImport("user32.dll")]
public static extern IntPtr CallNextHookEx(IntPtr idHook, int nCode, IntPtr wParam, IntPtr lParam);
}
}

2
Query/MainForm.Designer.cs generated
View File

@ -1,5 +1,5 @@
namespace Query {
partial class MainForm {
sealed partial class MainForm {
/// <summary>
/// Required designer variable.
/// </summary>

206
Query/MainForm.cs
View File

@ -5,142 +5,142 @@ using Base;
using Query.Controls;
using Query.Core;
namespace Query {
partial class MainForm : Form {
private readonly CommandProcessor processor;
private readonly CommandHistory history;
namespace Query;
private readonly Timer focusTimer;
private readonly KeyboardHook keyboardHook;
sealed partial class MainForm : Form {
private readonly CommandProcessor processor;
private readonly CommandHistory history;
private bool isLoaded;
private readonly Timer focusTimer;
private readonly KeyboardHook keyboardHook;
public MainForm() {
InitializeComponent();
private bool isLoaded;
processor = new CommandProcessor {
SingleTokenProcessor = ProcessSingleToken
};
public MainForm() {
InitializeComponent();
processor.AddApp<AppCalc.App>();
processor.AddApp<AppConv.App>();
processor.AddApp<AppMeme.App>();
processor.AddApp<AppSys.App>();
processor = new CommandProcessor {
SingleTokenProcessor = ProcessSingleToken
};
history = new CommandHistory();
queryBox.Setup(history, str => queryLog.AddEntry(str, QueryHistoryLog.EntryType.Information));
processor.AddApp<AppCalc.App>();
processor.AddApp<AppConv.App>();
processor.AddApp<AppMeme.App>();
processor.AddApp<AppSys.App>();
keyboardHook = new KeyboardHook();
keyboardHook.Triggered += keyboardHook_Triggered;
history = new CommandHistory();
queryBox.Setup(history, str => queryLog.AddEntry(str, QueryHistoryLog.EntryType.Information));
focusTimer = new Timer {
Interval = 1
};
keyboardHook = new KeyboardHook();
keyboardHook.Triggered += keyboardHook_Triggered;
focusTimer.Tick += focusTimer_Tick;
focusTimer = new Timer {
Interval = 1
};
Disposed += MainForm_Disposed;
queryBox.CommandRan += queryBox_CommandRan;
focusTimer.Tick += focusTimer_Tick;
Disposed += MainForm_Disposed;
queryBox.CommandRan += queryBox_CommandRan;
}
private void SetShown(bool show) {
if (show) {
focusTimer.Start();
}
private void SetShown(bool show) {
if (show) {
focusTimer.Start();
}
else {
Hide();
}
else {
Hide();
}
}
private void MainForm_Shown(object sender, EventArgs e) {
Rectangle screenRect = Screen.PrimaryScreen.WorkingArea;
Location = new Point(screenRect.X + screenRect.Width - Width, screenRect.Y + screenRect.Height - Height);
private void MainForm_Shown(object sender, EventArgs e) {
Rectangle screenRect = Screen.PrimaryScreen.WorkingArea;
Location = new Point(screenRect.X + screenRect.Width - Width, screenRect.Y + screenRect.Height - Height);
if (!isLoaded) {
isLoaded = true;
keyboardHook.StartHook();
}
}
private void MainForm_Deactivate(object sender, EventArgs e) {
SetShown(false);
}
private void MainForm_Disposed(object sender, EventArgs e) {
keyboardHook.StopHook();
}
private void trayIcon_Click(object sender, EventArgs e) {
if (((MouseEventArgs) e).Button == MouseButtons.Left) {
SetShown(true);
}
}
private void showToolStripMenuItem_Click(object sender, EventArgs e) {
SetShown(true);
}
private void hookToolStripMenuItem_Click(object sender, EventArgs e) {
keyboardHook.StopHook();
if (!isLoaded) {
isLoaded = true;
keyboardHook.StartHook();
}
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e) {
Application.Exit();
private void MainForm_Deactivate(object sender, EventArgs e) {
SetShown(false);
}
private void MainForm_Disposed(object sender, EventArgs e) {
keyboardHook.StopHook();
}
private void trayIcon_Click(object sender, EventArgs e) {
if (((MouseEventArgs) e).Button == MouseButtons.Left) {
SetShown(true);
}
}
private void keyboardHook_Triggered(object sender, EventArgs e) {
SetShown(!Visible);
}
private void showToolStripMenuItem_Click(object sender, EventArgs e) {
SetShown(true);
}
private void focusTimer_Tick(object sender, EventArgs e) {
WindowState = FormWindowState.Minimized;
Show();
Activate();
WindowState = FormWindowState.Normal;
private void hookToolStripMenuItem_Click(object sender, EventArgs e) {
keyboardHook.StopHook();
keyboardHook.StartHook();
}
queryBox.Focus();
focusTimer.Stop();
}
private void exitToolStripMenuItem_Click(object sender, EventArgs e) {
Application.Exit();
}
private void queryBox_CommandRan(object sender, CommandEventArgs e) {
try {
string result = processor.Run(e.Command);
private void keyboardHook_Triggered(object sender, EventArgs e) {
SetShown(!Visible);
}
if (result != null) {
queryLog.AddEntry("> " + e.Command.Text, QueryHistoryLog.EntryType.UserInput);
history.AddQuery(e.Command.Text);
private void focusTimer_Tick(object sender, EventArgs e) {
WindowState = FormWindowState.Minimized;
Show();
Activate();
WindowState = FormWindowState.Normal;
queryLog.AddEntry(result, QueryHistoryLog.EntryType.CommandResult);
history.AddResult(result);
}
} catch (CommandException ex) {
queryBox.Focus();
focusTimer.Stop();
}
private void queryBox_CommandRan(object sender, CommandEventArgs e) {
try {
string result = processor.Run(e.Command);
if (result != null) {
queryLog.AddEntry("> " + e.Command.Text, QueryHistoryLog.EntryType.UserInput);
history.AddQuery(e.Command.Text);
queryLog.AddEntry(ex.Message, QueryHistoryLog.EntryType.Error);
queryLog.AddEntry(result, QueryHistoryLog.EntryType.CommandResult);
history.AddResult(result);
}
} catch (CommandException ex) {
queryLog.AddEntry("> " + e.Command.Text, QueryHistoryLog.EntryType.UserInput);
history.AddQuery(e.Command.Text);
queryLog.AddEntry(ex.Message, QueryHistoryLog.EntryType.Error);
}
}
private bool ProcessSingleToken(string token) {
switch (token) {
case "exit":
case "quit":
Application.Exit();
return true;
private bool ProcessSingleToken(string token) {
switch (token) {
case "exit":
case "quit":
Application.Exit();
return true;
case "clear":
queryLog.ClearEntries();
history.Clear();
return true;
case "clear":
queryLog.ClearEntries();
history.Clear();
return true;
case "hide":
Hide();
return true;
case "hide":
Hide();
return true;
default:
return false;
}
default:
return false;
}
}
}

16
Query/Program.cs
View File

@ -1,13 +1,13 @@
using System;
using System.Windows.Forms;
namespace Query {
static class Program {
[STAThread]
private static void Main() {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
namespace Query;
static class Program {
[STAThread]
private static void Main() {
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
}