JD2022-TU1/main/tools/apps/PleoLab/CommandArguments.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using Argument = System.Collections.Generic.KeyValuePair<string, string>;

namespace PleoLab
{
    /// <summary>
    /// Allows to manipulate arguments for a command line.
    /// </summary>
    public class CommandArguments : IEnumerable<Argument>
    {
        private Dictionary<string, string> _arguments = new Dictionary<string, string>();

        public string ArgumentFormatString { get; set; }
        public string ArgumentWithNullValueFormatString { get; set; }
        public string ArrayValuesSeparator { get; set; }
        public bool EnumArgumentsInLowerCase { get; set; }
        public bool QuoteArgumentsWithWhiteSpaces { get; set; }

        public string Separator { get; set; }

        public CommandArguments()
        {
            ArgumentFormatString = "{0}={1}";
            ArgumentWithNullValueFormatString = "{0}";
            ArrayValuesSeparator = " ";
            QuoteArgumentsWithWhiteSpaces = true;
            Separator = ";";
        }

        /// <summary>
        /// Returns a copy of the arguments.
        /// </summary>
        public virtual CommandArguments Clone()
        {
            var clone = (CommandArguments)MemberwiseClone();
            clone._arguments = new Dictionary<string, string>(_arguments);
            return clone;
        }

        public T Get<T>(string parameterName)
        {
            string value;
            if (_arguments.TryGetValue(parameterName, out value))
            {
                return ConvertFromString<T>(value);
            }
            return default(T);
        }

        public T Get<T>(string parameterName, params string[] aliases)
        {
            string value;
            if (_arguments.TryGetValue(parameterName, out value))
            {
                return ConvertFromString<T>(value);
            }
            foreach (var alias in aliases)
            {
                if (_arguments.TryGetValue(alias, out value))
                {
                    return ConvertFromString<T>(value);
                }
            }
            return default(T);
        }

        public void Set<T>(string parameterName, T value)
        {
            _arguments[parameterName] = ConvertToString(value);
        }

        public void Reset(string parameterName)
        {
            _arguments.Remove(parameterName);
        }

        public void Set(string parameterName, string value)
        {
            if (!string.IsNullOrEmpty(value))
            {
                _arguments[parameterName] = ConvertToString(value);
            }
            else
            {
                _arguments.Remove(parameterName);
            }
        }

        public void Set<T>(string parameterName, T? value)
                where T : struct
        {
            if (value != null)
            {
                _arguments[parameterName] = ConvertToString(value);
            }
            else
            {
                _arguments.Remove(parameterName);
            }
        }

        public void SetFlag(string parameterName, bool isSet)
        {
            if (isSet)
            {
                _arguments[parameterName] = null;
            }
            else
            {
                _arguments.Remove(parameterName);
            }
        }

        public bool IsFlagSet(string parameterName)
        {
            return _arguments.ContainsKey(parameterName);
        }

        public void Set(IEnumerable<Argument> arguments)
        {
            foreach (var argument in arguments)
            {
                Set(argument.Key, argument.Value);
            }
        }

        public void Set(string parameterName)
        {
            _arguments[parameterName] = null;
        }


        protected virtual string ConvertToString(object value)
        {
            var result = (value ?? "").ToString();

            if (value is Enum && EnumArgumentsInLowerCase)
            {
                result = result.ToLower();
            }

            if (QuoteArgumentsWithWhiteSpaces && result.Contains(" "))
            {
                result = Quote(result);
            }

            if (value is string[])
            {
                result = string.Join(ArrayValuesSeparator, ((string[])value).Select(ConvertToString));
            }

            return result;
        }

        protected virtual T ConvertFromString<T>(string value)
        {
            var converter = TypeDescriptor.GetConverter(typeof(T));
            return (T)converter.ConvertFrom(value);
        }

        protected string Quote(object value)
        {
            const string quote = "\"";
            return string.Concat(quote, value, quote);
        }

        protected virtual string FormatArgument(Argument argument)
        {
            if (string.IsNullOrEmpty(argument.Value))
            {
                return string.Format(ArgumentWithNullValueFormatString, argument.Key);
            }
            return string.Format(ArgumentFormatString, argument.Key, argument.Value);
        }

        public override string ToString()
        {
            return string.Join(Separator, _arguments.Select(FormatArgument));
        }

        public IEnumerator<Argument> GetEnumerator()
        {
            return _arguments.GetEnumerator();
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }
    }
}