InterpreterContext.cs

Go to the documentation of this file.

using Mercury.Nucleus.Trees;
using Mercury.Syntax;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Runtime.Caching;

namespace Mercury.Interpreting
{
//=============================================================================
//  InterpreterContext
//=============================================================================

    public abstract class InterpreterContext<T>
        where T : class
    {
        //--[  Internal  ]-----------------------------------------------------

        internal TreeEntry<T> hroot;
        internal RuleEntry<T> cnode;

        internal Dictionary<string, Argument> bindings;
        internal MemoryCache cache = null; // results cache

        internal string       action;
        internal ArgumentType reqtp;

        internal InterpreterContext<T> InternalClone(RuleEntry<T> current)
        {
            var cx = DeepClone();
            cx.hroot = hroot;
            cx.cnode = current;
            cx.cache = cache;
            return cx;
        }

        internal void InternalCopy(InterpreterContext<T> cxtx)
        { CopyFrom(cxtx); }

        internal void LogEntryEx(string hdr, string msg, params object[] args)
        {
            if (cnode == null) throw new InvalidOperationException();
            cnode.Entries.Add(new TextEntry(hdr, msg, args));
        }

        //--[  Constructors  ]-------------------------------------------------

        public InterpreterContext()
        { bindings = new Dictionary<string, Argument>(); }

        //--[  Properties  ]---------------------------------------------------

        public TreeEntry<T> RootEntry { get { return hroot; } }

        //--[  Methods  ]------------------------------------------------------

        public abstract InterpreterContext<T> DeepClone();

        public abstract void CopyFrom(InterpreterContext<T> other);

        public void LogEntry(string text, params object[] args)
        { LogEntryEx(action, text, args); }
    }

//=============================================================================
//  IInterpreterContextFactory
//=============================================================================

    public interface IInterpreterContextFactory
    {
        InterpreterContext<T> CreateContext<T>() 
            where T : class;
    }

//=============================================================================
//  InternalContext
//=============================================================================

//==<<  InternalContext  >>====================================================

    internal class InternalContext<T> : InterpreterContext<T>
        where T : class
    {
        public override InterpreterContext<T> DeepClone()
        { return new InternalContext<T>(); }

        public override void CopyFrom(InterpreterContext<T> other)
        { }
    }

//==<<  InternalContextFactory  >>=============================================

    public class EmptyContextFactory : IInterpreterContextFactory
    {
        //--[  Interface Implementation  ]-------------------------------------

        public InterpreterContext<T> CreateContext<T>()
            where T : class
        { return new InternalContext<T>(); }

    }

}