Coalesce.cs

using System;
using System.Runtime.ExceptionServices;
using System.Threading.Tasks;
using Waher.Script;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
 
namespace Waher.Content.Semantic.Functions
{
    public class Coalesce : FunctionMultiVariate
    {
        public Coalesce(ScriptNode Argument1, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode Argument1, ScriptNode Argument2, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1, Argument2 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode Argument1, ScriptNode Argument2, ScriptNode Argument3, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1, Argument2, Argument3 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode Argument1, ScriptNode Argument2, ScriptNode Argument3, 
            ScriptNode Argument4, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1, Argument2, Argument3, Argument4 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode Argument1, ScriptNode Argument2, ScriptNode Argument3,
            ScriptNode Argument4, ScriptNode Argument5, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1, Argument2, Argument3, Argument4, Argument5 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode Argument1, ScriptNode Argument2, ScriptNode Argument3,
            ScriptNode Argument4, ScriptNode Argument5, ScriptNode Argument6, int Start, int Length, Expression Expression)
            : this(new ScriptNode[] { Argument1, Argument2, Argument3, Argument4, Argument5, Argument6 }, Start, Length, Expression)
        {
        }
 
        public Coalesce(ScriptNode[] Arguments, int Start, int Length, Expression Expression)
            : base(Arguments, NormalTypes(Arguments), Start, Length, Expression)
        {
        }
 
        private static ArgumentType[] NormalTypes(ScriptNode[] Arguments)
        {
            int i, c = Arguments.Length;
            ArgumentType[] Types = new ArgumentType[c];
 
            for (i = 0; i < c; i++)
                Types[i] = ArgumentType.Normal;
 
            return Types;
        }
 
        public override string FunctionName => nameof(Coalesce);
 
        public override string[] DefaultArgumentNames => new string[] { "Exp", "..." };
 
        public override IElement Evaluate(Variables Variables)
        {
            Exception LastException = null;
 
            foreach (ScriptNode Argument in this.Arguments)
            {
                try
                {
                    return Argument.Evaluate(Variables);
                }
                catch (ScriptReturnValueException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    throw new ScriptReturnValueException(ex.ReturnValue);
                }
                catch (ScriptBreakLoopException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    if (ex.HasLoopValue)
                        throw new ScriptBreakLoopException(ex.LoopValue);
                    else
                        throw new ScriptBreakLoopException();
                }
                catch (ScriptContinueLoopException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    if (ex.HasLoopValue)
                        throw new ScriptContinueLoopException(ex.LoopValue);
                    else
                        throw new ScriptContinueLoopException();
                }
                catch (Exception ex)
                {
                    LastException = ex;
                }
            }
 
            if (!(LastException is null))
                ExceptionDispatchInfo.Capture(LastException).Throw();
 
            throw new ScriptRuntimeException("No valid result found.", this);
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            Exception LastException = null;
 
            foreach (ScriptNode Argument in this.Arguments)
            {
                try
                {
                    return await Argument.EvaluateAsync(Variables);
                }
                catch (ScriptReturnValueException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    throw new ScriptReturnValueException(ex.ReturnValue);
                }
                catch (ScriptBreakLoopException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    if (ex.HasLoopValue)
                        throw new ScriptBreakLoopException(ex.LoopValue);
                    else
                        throw new ScriptBreakLoopException();
                }
                catch (ScriptContinueLoopException ex)
                {
                    ExceptionDispatchInfo.Capture(ex).Throw();
                    if (ex.HasLoopValue)
                        throw new ScriptContinueLoopException(ex.LoopValue);
                    else
                        throw new ScriptContinueLoopException();
                }
                catch (Exception ex)
                {
                    LastException = ex;
                }
            }
 
            if (!(LastException is null))
                ExceptionDispatchInfo.Capture(LastException).Throw();
 
            throw new ScriptRuntimeException("No valid result found.", this);
        }
 
        public override IElement Evaluate(IElement[] Arguments, Variables Variables)
        {
            return Arguments[0];
        }
 
        public override Task<IElement> EvaluateAsync(IElement[] Arguments, Variables Variables)
        {
            return Task.FromResult(this.Evaluate(Arguments, Variables));
        }
    }
}