Rule.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Mercury.Syntax
{
//=============================================================================
//  Rule
//=============================================================================

    public class Rule : IEquatable<Rule>, IComparable<Rule>
    {
        //--[  Private fields  ]-----------------------------------------------

        private int? memHash = null; // memoized hash value

        //--[  Private methods  ]----------------------------------------------

        private bool IsValid()
        {
            return ((LHS.Type == SymbolType.Nonterminal) && (RHS.Count > 0)
                    && ((RHS.Count == 1) || RHS.All(x => !x.IsEpsilon)));
        }

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

        public Rule(Symbol lhs, IEnumerable<Symbol> rhs)
        {
            if (lhs == null) throw new ArgumentNullException("lhs");
            if (rhs == null) throw new ArgumentNullException("rhs");

            LHS       = lhs;
            RHS       = rhs.ToList();
            IsEpsilon = (RHS.Count == 1) && (RHS[0].IsEpsilon);

            if (RHS.Count == 0) throw new InvalidRuleException(this, "Rule RHS is empty");
            if (!IsValid())     throw new InvalidRuleException(this);

            
        }

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

        public Symbol LHS { get; private set; }

        public IReadOnlyList<Symbol> RHS { get; private set; }

        public bool IsEpsilon { get; private set; }

        //--[  Overriden methods  ]--------------------------------------------

        #region [  Object       ]

        public override bool Equals(object obj)
        {
            Rule rule = obj as Rule;
            return rule == null ? false : Equals(rule);
        }

        public override int GetHashCode()
        {
            if (memHash.HasValue)
                return memHash.Value;

            int hash = LHS.GetHashCode();
            for (int ix = 0; ix < RHS.Count; ++ix)
                hash = (7919 * hash) + RHS[ix].GetHashCode(); 

            memHash = hash;
            return hash;
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            sb.Append(LHS);
            sb.Append(" ->");

            for (int ix = 0; ix < RHS.Count; ++ix)
                sb.Append(' ').Append(RHS[ix]);

            return sb.ToString();
        }

        #endregion

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

        #region [  IEquatable   ]

        public bool Equals(Rule other)
        {
            if ((other == null)
                || (GetHashCode() != other.GetHashCode())
                || (!LHS.Equals(other.LHS))
                || (RHS.Count     != other.RHS.Count))
                return false;

            for (int ix = 0; ix < RHS.Count; ++ix)
                if (!RHS[ix].Equals(other.RHS[ix]))
                    return false;

            return true;
        }

        #endregion

        #region [  IComparable  ]

        public int CompareTo(Rule other)
        {
            int temp = LHS.CompareTo(other.LHS);

            if (temp == 0) temp = RHS.Count.CompareTo(other.RHS.Count);

            for (int ix = 0; (temp == 0) && (ix < RHS.Count); ++ix)
                temp = RHS[ix].CompareTo(other.RHS[ix]);

            return temp;
        }

        #endregion

    }
}