Remove.cs

using System;
using System.Reflection;
using System.Threading.Tasks;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Model;
using Waher.Script.Objects;
using Waher.Script.Operators.Membership;
 
namespace Waher.Script.Functions.Runtime
{
    public class Remove : FunctionOneVariable
    {
        private string variableName;
        private ScriptNode @object = null;
 
        public Remove(ScriptNode Argument, int Start, int Length, Expression Expression)
            : base(Argument, Start, Length, Expression)
        {
            this.CheckArgument();
        }
 
        private void CheckArgument()
        {
            if (this.Argument is null)
            {
                this.@object = null;
                this.variableName = string.Empty;
            }
            else
            {
                if (this.Argument is VariableReference Ref)
                {
                    this.@object = null;
                    this.variableName = Ref.VariableName;
                }
                else if (this.Argument is NamedMember Member)
                {
                    this.@object = Member.Operand;
                    this.variableName = Member.Name;
                }
                else
                    throw new SyntaxException("Variable reference or named property expected.", this.Argument.Start, string.Empty);
            }
        }
 
        public override string[] DefaultArgumentNames => new string[] { "var" };
 
        public string VariableName => this.variableName;
 
        public override string FunctionName => nameof(Remove);
 
        public override IElement Evaluate(Variables Variables)
        {
            if (this.@object is null)
            {
                if (Variables.TryGetVariable(this.variableName, out Variable v))
                {
                    Variables.Remove(this.variableName);
                    return v.ValueElement;
                }
                else
                    return ObjectValue.Null;
            }
            else
            {
                IElement Obj = this.@object.Evaluate(Variables);
                Type T = Obj.AssociatedObjectValue.GetType();
                MethodInfo MI = T.GetRuntimeMethod("Remove", stringArgument)
                    ?? throw new ScriptRuntimeException("Unable to remove property " + this.variableName + " from objects of type " + T.FullName + ".", this);
 
                object Result = MI.Invoke(Obj.AssociatedObjectValue, new object[] { this.variableName });
 
                return Expression.Encapsulate(UnnestPossibleTaskSync(Result));
            }
        }
 
        public override async Task<IElement> EvaluateAsync(Variables Variables)
        {
            if (this.@object is null)
            {
                if (Variables.TryGetVariable(this.variableName, out Variable v))
                {
                    Variables.Remove(this.variableName);
                    return v.ValueElement;
                }
                else
                    return ObjectValue.Null;
            }
            else
            {
                IElement Obj = await this.@object.EvaluateAsync(Variables);
                Type T = Obj.AssociatedObjectValue.GetType();
                MethodInfo MI = T.GetRuntimeMethod("Remove", stringArgument)
                    ?? throw new ScriptRuntimeException("Unable to remove property " + this.variableName + " from objects of type " + T.FullName + ".", this);
 
                object Result = MI.Invoke(Obj.AssociatedObjectValue, new object[] { this.variableName });
 
                return Expression.Encapsulate(await WaitPossibleTask(Result));
            }
        }
 
        internal static readonly Type[] stringArgument = new Type[] { typeof(string) };
 
        public override IElement Evaluate(IElement Argument, Variables Variables)
        {
            return Argument;
        }
 
        public override Task<IElement> EvaluateAsync(IElement Argument, Variables Variables)
        {
            return Task.FromResult<IElement>(Argument);
        }
 
        public override bool ForAllChildNodes(ScriptNodeEventHandler Callback, object State, SearchMethod Order)
        {
            ScriptNode Argument = this.Argument;
            bool Result = base.ForAllChildNodes(Callback, State, Order);
 
            if (Argument != this.Argument)
                this.CheckArgument();
 
            return Result;
        }
 
 
    }
}