GetCounters.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using Waher.Runtime.Counters;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators.Arithmetics;
 
namespace Waher.Script.Persistence.Functions
{
    public class GetCounters : FunctionMultiVariate
    {
        public GetCounters(int Start, int Length, Expression Expression)
            : base(Array.Empty<ScriptNode>(), argumentTypes0,
                  Start, Length, Expression)
        {
        }
 
        public GetCounters(ScriptNode KeyPrefix, int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { KeyPrefix }, argumentTypes1Scalar,
                  Start, Length, Expression)
        {
        }
 
        public GetCounters(ScriptNode KeyPrefix, ScriptNode Delimiter,
            int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { KeyPrefix, Delimiter }, argumentTypes2Scalar,
                  Start, Length, Expression)
        {
        }
 
        public GetCounters(ScriptNode KeyPrefix, ScriptNode Delimiter, ScriptNode Wildcard,
            int Start, int Length, Expression Expression)
            : base(new ScriptNode[] { KeyPrefix, Delimiter, Wildcard }, argumentTypes3Scalar,
                  Start, Length, Expression)
        {
        }
 
        public override string FunctionName => nameof(GetCounters);
 
        public override string[] DefaultArgumentNames => new string[] { "KeyPrefix", "Delimiter", "Wildcard" };
 
        public override bool IsAsynchronous => true;
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            return this.EvaluateAsync(Arguments, Variables).Result;
        }
 
        public override async Task<IElement> EvaluateAsync(IElement[] Arguments, Variables Variables)
        {
            string KeyPrefix = Arguments.Length > 0 ? ToString(Arguments[0]) : null;
            string Delimiter = Arguments.Length > 1 ? ToString(Arguments[1]) : null;
            string Wildcard = Arguments.Length > 2 ? ToString(Arguments[2]) : null;
            Dictionary<string, long> Counters;
 
            if (string.IsNullOrEmpty(KeyPrefix))
                Counters = await RuntimeCounters.GetWhereAsync();
            else
            {
                if (string.IsNullOrEmpty(Wildcard))
                {
                    Wildcard = "*";
                    while (KeyPrefix.Contains(Wildcard))
                        Wildcard += "*";
 
                    KeyPrefix += Wildcard;
                }
 
                Counters = await RuntimeCounters.GetWhereKeyLikeAsync(KeyPrefix, Wildcard);
            }
 
            Dictionary<string, IElement> Result = new Dictionary<string, IElement>();
 
            if (string.IsNullOrEmpty(Delimiter))
            {
                foreach (KeyValuePair<string, long> P in Counters)
                    Result[P.Key] = new DoubleNumber(P.Value);
            }
            else
            {
                string[] Delimiters = new string[] { Delimiter };
 
                foreach (KeyValuePair<string, long> P in Counters)
                {
                    Dictionary<string, IElement> Next, Loop = Result;
                    string Key = P.Key;
                    string[] Parts = Key.Split(Delimiters, StringSplitOptions.None);
                    int i, c = Parts.Length;
 
                    for (i = 0; i < c; i++)
                    {
                        Key = Parts[i];
 
                        if (Loop.TryGetValue(Key, out IElement E))
                        {
                            if (i < c - 1)
                            {
                                if (E.AssociatedObjectValue is Dictionary<string, IElement> Next2)
                                    Next = Next2;
                                else
                                {
                                    Next = new Dictionary<string, IElement>()
                                    {
                                        { string.Empty, E }
                                    };
 
                                    Loop[Key] = new ObjectValue(Next);
                                }
                            }
                            else
                            {
                                E = Add.EvaluateAddition(E, new DoubleNumber(P.Value), this);
                                Loop[Key] = E;
                                Next = null;
                            }
                        }
                        else
                        {
                            if (i < c - 1)
                            {
                                Next = new Dictionary<string, IElement>();
                                E = new ObjectValue(Next);
                            }
                            else
                            {
                                E = new DoubleNumber(P.Value);
                                Next = null;
                            }
 
                            Loop[Key] = E;
                        }
 
                        Loop = Next;
                    }
                }
            }
 
            return new ObjectValue(Result);
        }
    }
}