public bool CanParse(IArgumentPack pack, Type targetType)
 {
     if (targetType != typeof(bool))
     {
         return(false);
     }
     return(bool.TryParse(pack.Peek(), out _) ||
            int.TryParse(pack.Peek(), out _));
 }
        public object Parse(IArgumentPack pack, Type targetType)
        {
            var arg = pack.Peek().Unwrap();

            if (!arg.StartsWithAny("\"", "“", "”"))
            {
                return(pack.Take());
            }

            var allItems = new List <string>();

            do
            {
                allItems.Add(pack.Take());
            } while(!allItems[^ 1].EndsWithAny("\"", "“", "”"));
        /// <inheritdoc/>
        public bool CanParse(IArgumentPack pack, Type targetType)
        {
            if (targetType != typeof(int))
            {
                return(false);
            }

            var value = pack.Peek();

            if (!value.HasValue)
            {
                return(false);
            }

            var argument = value.Unwrap();

            return(suffixes.ContainsKey(char.ToLowerInvariant(argument.Last())) &&
                   int.TryParse(argument[..^ 1], out _));
예제 #4
0
        public virtual Node FindCommand(IArgumentPack pack)
        {
            if (!pack.CanTake)
            {
                return(null);
            }

            var arg = pack.Peek().Unwrap()
                      .ToLowerInvariant();

            // Take if this module starts.
            if (Metadata.Identifiers?.Any(x => x.ToLowerInvariant() == arg.ToLowerInvariant()) ?? false)
            {
                pack.Take();
            }

            foreach (var c in Children)
            {
                if (c is NodeContainer nc)
                {
                    var foundNode = nc.FindCommand(pack);
                    if (foundNode != null)
                    {
                        return(foundNode);
                    }
                }
                else
                {
                    if (c.Metadata.Identifiers.Any(x => x == arg))
                    {
                        pack.Take();
                        return(c);
                    }
                }
            }
            return(null);
        }
예제 #5
0
        /// <summary>
        /// Query a command recursively
        /// </summary>
        /// <param name="pack">Argument pack to iterate over.</param>
        /// <returns>Nullable node</returns>
        public override Node FindCommand(IArgumentPack pack)
        {
            var arg = pack.Peek().Unwrap()
                      .ToLowerInvariant();

            if (Metadata.Identifiers == null || !Metadata.Identifiers.Any())
            {
                return(null);
            }

            if (Metadata.Identifiers.All(x => x != arg))
            {
                return(null);
            }

            pack.Take();
            var cmd = base.FindCommand(pack);

            if (cmd != null)
            {
                return(cmd);
            }
            return(this);
        }
예제 #6
0
 /// <inheritdoc />
 public bool CanParse(IArgumentPack pack, Type targetType)
 {
     return(Enum.TryParse(targetType, pack.Peek(), true, out _));
 }