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)
            {
                IElement ValueElement = TryGetConstant(this.variableName, Variables, this);
                if (!(ValueElement is null))
                    return ValueElement;
            }
 
            throw new VariableNotFoundScriptException(this.variableName, this);
        }
 
        public static IElement TryGetConstant(string VariableName, Variables Variables, ScriptNode Node)
        {
            if (Expression.TryGetConstant(VariableName, Variables, out IElement ValueElement))
                return ValueElement;
 
            if (Types.IsRootNamespace(VariableName))
                return new Namespace(VariableName);
 
            ValueElement = Expression.GetFunctionLambdaDefinition(VariableName, Node.Start, Node.Length, Node.Expression);
            if (!(ValueElement is null))
                return ValueElement;
 
            if (Types.TryGetQualifiedNames(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 Variable v) &&
                v.ValueObject is Variables GlobalVariables &&
                GlobalVariables.TryGetVariable(VariableName, out v))
            {
                return v.ValueElement;
            }
 
            return null;
        }
 
        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;
        }
 
    }
}