VariableReference.cs

using System;
using System.Collections.Generic;
using Waher.Runtime.Inventory;
using Waher.Script.Abstraction.Elements;
using Waher.Script.Exceptions;
using Waher.Script.Objects;
using Waher.Script.Objects.VectorSpaces;
 
namespace Waher.Script.Model
{
    public sealed class VariableReference : ScriptLeafNodeVariableReference, IDifferentiable
    {
        private readonly bool onlyVariables;
 
        public VariableReference(string VariableName, int Start, int Length, Expression Expression)
            : base(VariableName, Start, Length, Expression)
        {
            this.onlyVariables = false;
        }
 
        public VariableReference(string VariableName, bool OnlyVariables, int Start, int Length, Expression Expression)
            : base(VariableName, Start, Length, Expression)
        {
            this.onlyVariables = OnlyVariables;
        }
 
        public bool OnlyVariables => this.onlyVariables;
 
        public override IElement Evaluate(Variables Variables)
        {
            if (Variables.TryGetVariable(this.variableName, out Variable v))
                return v.ValueElement;
 
            if (!this.onlyVariables)
            {
                if (Expression.TryGetConstant(this.variableName, Variables, out IElement ValueElement))
                    return ValueElement;
 
                if (Types.IsRootNamespace(this.variableName))
                    return new Namespace(this.variableName);
 
                ValueElement = Expression.GetFunctionLambdaDefinition(this.variableName, this.Start, this.Length, this.Expression);
                if (!(ValueElement is null))
                    return ValueElement;
 
                if (Types.TryGetQualifiedNames(this.variableName, out string[] QualifiedNames))
                {
                    if (QualifiedNames.Length == 1)
                    {
                        Type T = Types.GetType(QualifiedNames[0]);
 
                        if (!(T is null))
                            return new TypeValue(T);
                        else
                            return new Namespace(QualifiedNames[0]);
                    }
                    else
                    {
                        int i, c = QualifiedNames.Length;
                        IElement[] Elements = new IElement[c];
 
                        for (i = 0; i < c; i++)
                            Elements[i] = new StringValue(QualifiedNames[i]);
 
                        return new ObjectVector(Elements);
                    }
                }
 
                if (Variables.TryGetVariable("Global", out v) &&
                    v.ValueObject is Variables GlobalVariables &&
                    GlobalVariables.TryGetVariable(this.variableName, out v))
                {
                    return v.ValueElement;
                }
            }
 
            throw new ScriptRuntimeException("Variable not found: " + this.variableName, this);
        }
 
        public override PatternMatchResult PatternMatch(IElement CheckAgainst, Dictionary<string, IElement> AlreadyFound)
        {
            if (AlreadyFound.TryGetValue(this.variableName, out IElement E) && !E.Equals(CheckAgainst))
                return PatternMatchResult.NoMatch;
 
            AlreadyFound[this.variableName] = CheckAgainst;
 
            return PatternMatchResult.Match;
        }
 
        public ScriptNode Differentiate(string VariableName, Variables Variables)
        {
            if (VariableName == this.variableName)
                return new ConstantElement(DoubleNumber.OneElement, this.Start, this.Length, this.Expression);
            else
                return new ConstantElement(DoubleNumber.ZeroElement, this.Start, this.Length, this.Expression);
        }
 
        public string DefaultVariableName => this.variableName;
 
        public override bool Equals(object obj)
        {
            return obj is VariableReference O &&
                this.onlyVariables.Equals(O.onlyVariables) &&
                base.Equals(obj);
        }
 
        public override int GetHashCode()
        {
            int Result = base.GetHashCode();
            Result ^= Result << 5 ^ this.onlyVariables.GetHashCode();
            return Result;
        }
 
    }
}