RewriteRuleCollection.cs

Go to the documentation of this file.

using Mercury.Nucleus.Collections;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;

namespace Mercury.Interpreting
{
//=============================================================================
//  RewriteRuleCollection
//=============================================================================

    public class RewriteRuleCollection<T> : IReadOnlyCollection<RewriteRule<T>>
        where T : class
    {
        //--[  Private fields  ]-----------------------------------------------

        private IReadOnlyList<RewriteRule<T>>                    rules;
        private IReadOnlyMultiDictionary<Symbol, RewriteRule<T>> rulemap;
        private IReadOnlyList<RewriteRule<T>>                    wildrules;

        // This constructor should be called only by RewriteRuleCollectionBuilder
        internal RewriteRuleCollection(IEnumerable<RewriteRule<T>> rules,
            IReadOnlyMultiDictionary<Symbol, RewriteRule<T>> rulemap)
        {
            if (rules   == null) throw new ArgumentNullException("rules");
            if (rulemap == null) throw new ArgumentNullException("rulemap");

            this.rules   = rules.ToList();
            this.rulemap = rulemap;

            if (!rulemap.TryGetValue(new Symbol(), out wildrules))
                wildrules = new RewriteRule<T>[0];
        }

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

        public IEnumerable<RewriteRule<T>> RulesFor(Symbol head)
        {
            IReadOnlyList<RewriteRule<T>> tmp;

            if (!rulemap.TryGetValue(head, out tmp)) 
                tmp = new RewriteRule<T>[0];

            return tmp.Concat(wildrules);
        }

        //--[  Interface implementation  ]-------------------------------------

        #region [  IReadOnlyCollection  ]

        public int Count { get { return rules.Count; } }

        public IEnumerator<RewriteRule<T>> GetEnumerator()
        { return rules.GetEnumerator(); }

        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
        { return rules.GetEnumerator(); }

        #endregion

    }

//=============================================================================
//  RewriteRuleCollectionBuilder
//=============================================================================

    public class RewriteRuleCollectionBuilder<T>
        where T : class
    {
        //--[  Private fields  ]-----------------------------------------------

        private List<RewriteRule<T>> rules;
        private UniqueListMultiDictionary<Symbol, RewriteRule<T>> rulemap;

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

        public RewriteRuleCollectionBuilder()
        {
            rules   = new List<RewriteRule<T>>();
            rulemap = new UniqueListMultiDictionary<Symbol, RewriteRule<T>>();
        }

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

        public RewriteRuleCollectionBuilder<T> AddRewriteRule(RewriteRule<T> rule)
        {
            var alt = (Alternative) rule.Head;

            bool newrule = true;
            if (alt.Symbols.Count == 0)
                newrule  = rulemap.Add(new Symbol(), rule);
            else for (int ix = 0; ix < alt.Symbols.Count; ++ix)
                newrule &= rulemap.Add(alt.Symbols[ix], rule);

            if (newrule) rules.Add(rule);

            return this;
        }

        public RewriteRuleCollectionBuilder<T> AddRules(RewriteRuleCollection<T> rules)
        { foreach (var rule in rules) AddRewriteRule(rule); return this; }

        public RewriteRuleCollection<T> GetCollection()
        { return new RewriteRuleCollection<T>(rules, rulemap); }
    }

}