Element.cs

Go to the documentation of this file.

using Mercury.Exceptions;
using Mercury.Nucleus.Trees;
using Mercury.Syntax;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Mercury.Interpreting
{

//==<<  ElementType  >>========================================================

    public enum ElementType
    {
        Constant,
        Variable,
        Wildcard,
        Structure, 
    }

//=============================================================================
//  IElement
//=============================================================================

    public interface IElement : IEquatable<IElement>
    {
        //--[  Properties  ]---------------------------------------------------

        ElementType Type { get; }
    }

//=============================================================================
//  Alternative
//=============================================================================

    public abstract class Alternative : IEquatable<Alternative>
    {
        //--[  Private methods  ]----------------------------------------------

        private   int?            memhash = null;
        protected HashSet<Symbol> smset;

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

        public Alternative(SymbolType sm, IEnumerable<Symbol> symbols)
        {
            if (symbols == null) throw new ArgumentNullException("symbols");

            smset = new HashSet<Symbol>();
            foreach(var symbol in symbols)
            {
                if (symbol == null) throw new ArgumentException("Argument 'symbols' contains null");
                if (!sm.HasFlag(symbol.Type)) smset.Add(symbol);
            }

            if ((sm == SymbolType.None) && (smset.Count == 0))
                throw new ArgumentException("Empty alternative is not allowed");

            SymbolMask = sm;
            Symbols    = smset.ToList();
        }

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

        public SymbolType SymbolMask { get; private set; }

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

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

        public bool MatchesSymbol(Symbol s)
        { return (s != null) && (SymbolMask.HasFlag(s.Type) || smset.Contains(s)); }

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

        #region [  Object      ]

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

        public override int GetHashCode()
        {
            if (!memhash.HasValue)
            {
                memhash = 17 + 7 * (int) SymbolMask;
                for (int ix = 0; ix < Symbols.Count; ++ix)
                    memhash = 31 * memhash + Symbols[ix].GetHashCode();
            }

            return memhash.Value;
        }

        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
           
            if (Symbols.Count != 0)
            {
                sb.Append(Symbols[0]);

                for (int ix = 1; ix < Symbols.Count; ++ix)
                    sb.Append('|').Append(Symbols[ix]);
            }

            if (SymbolMask != SymbolType.None)
            {
                sb.Append(':');
                if (SymbolMask.HasFlag(SymbolType.Nonterminal)) sb.Append('N');
                if (SymbolMask.HasFlag(SymbolType.Terminal)) sb.Append('T');
                if (SymbolMask.HasFlag(SymbolType.Epsilon)) sb.Append('e');
            }

            return sb.ToString();
        }

        #endregion

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

        #region [  IEquatable  ]

        public bool Equals(Alternative other)
        {
            return (SymbolMask    == other.SymbolMask)
                && (Symbols.Count == other.Symbols.Count)
                && (Symbols.Zip(other.Symbols, (x, y) => x.Equals(y)).All(x => x));
        }

        #endregion

    }

//=============================================================================
//  Constant
//=============================================================================

    public class Constant : Alternative, IElement, IEquatable<Constant>
    {
        //--[  Constructors  ]-------------------------------------------------

        public Constant(Symbol symbol)
            : this(new[] { symbol })
        { }

        public Constant(IEnumerable<Symbol> symbols)
            : this(SymbolType.None, symbols)
        { }

        public Constant(SymbolType sm, IEnumerable<Symbol> symbols)
            : base(sm, symbols)
        { Type = ElementType.Constant; }

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

        #region [  Object        ]

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

        public override int GetHashCode()
        { return 23 * base.GetHashCode(); }

        public override string ToString()
        { return base.ToString(); }

        #endregion

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

        #region [  IElement      ]

        public ElementType Type { get; private set; }

        #endregion

        #region [  IEquatable    ]

        public bool Equals(IElement other)
        {
            return ((other != null) && (other.Type == ElementType.Constant))
                ? Equals(other as Constant)
                : false;
        }

        public bool Equals(Constant other)
        {
            return (other         != null)
                && (GetHashCode() == other.GetHashCode())
                && (base.Equals(other as Alternative));
        }

        #endregion

    }

//=============================================================================
//  Variable
//=============================================================================

    public class Variable : Alternative, IElement, IEquatable<Variable>
    {
        //--[  Constructors  ]-------------------------------------------------

        public Variable()
            : this(Extensions.RandomString("FS.%.*"), SymbolType.Any, new Symbol[0])
        { }

        public Variable(string name, SymbolType ws, IEnumerable<Symbol> symbols)
            : base(ws, symbols)
        {
            if (!IsValidName(name)) throw new ArgumentException(string.Format("Invalid variable name '{0}'", name));
            Type = ElementType.Variable;
            Name = name;
        }

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

        public string Name { get; private set; }

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

        public static bool IsValidName(string name)
        {
            return !string.IsNullOrEmpty(name) 
                && char.IsLetter(name[0]) 
                && name.All(x => char.IsLetterOrDigit(x));
        }

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

        #region [  Object        ]

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

        public override int GetHashCode()
        { return Name.GetHashCode() + 89 * base.GetHashCode(); }

        public override string ToString()
        { return (new StringBuilder()).Append('#').Append(Name).Append(':').Append(base.ToString()).ToString(); }

        #endregion

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

        #region [  IElement      ]

        public ElementType Type { get; protected set; }

        #endregion

        #region [  IEquatable    ]

        public bool Equals(IElement other)
        {
            return ((other != null) && (other.Type == ElementType.Variable))
                ? Equals(other as Variable)
                : false;
        }

        public bool Equals(Variable other)
        {
            return (other         != null)
                && (GetHashCode() == other.GetHashCode())
                && (Name          == other.Name)
                && (base.Equals(other));
        }

        #endregion

    }

//=============================================================================
//  Wildcard
//=============================================================================

    public class Wildcard : Variable
    {
        //--[  Constructors  ]-------------------------------------------------

        public Wildcard()
            : this(null, SymbolType.Any, new Symbol[0])
        { }

        public Wildcard(string name, SymbolType ws, IEnumerable<Symbol> symbols)
            : base(name ?? Extensions.RandomString("WR.%.*"), ws, symbols)
        { Type = ElementType.Wildcard; }

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

        #region  [  Object        ]

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

        public override int GetHashCode()
        { return 7 * (base.GetHashCode() / 5); }

        public override string ToString()
        { return "*" + base.ToString().Substring(1); }

        #endregion

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

        #region [  IEquatable    ]

        public new bool Equals(IElement other)
        {
            return ((other != null) && (other.Type == ElementType.Wildcard))
                ? Equals(other as Wildcard)
                : false;
        }

        public bool Equals(Wildcard other)
        {
            return (other         != null)
                && (GetHashCode() == other.GetHashCode())
                && (base.Equals(other));
        }

        #endregion

    }

//=============================================================================
//  Structure
//=============================================================================

    public class Structure : Tree<IElement>, IElement
    {
        //--[  Private fields  ]-----------------------------------------------

        private static Func<IElement, Tree<IElement>> transform =
            x => x as Structure ?? new Tree<IElement>(x);

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

        public Structure(IElement head)
            : this (head, new IElement[0])
        { }

        public Structure(IElement head, IEnumerable<IElement> subelements)
            : base(head, subelements.Select(x => transform(x)))
        {
            if (head == null) throw new ArgumentNullException("value");

            this.Type = ElementType.Structure;
            this.HasWildcard = Children.Any(x => x.Value.Type == ElementType.Wildcard);

            if ((head as Alternative) == null)
                throw new InvalidElementException(this, "structure root must be an Alternative");
        }

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

        public bool HasWildcard { get; private set; }

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

        #region [  IElement    ]

        public ElementType Type { get; private set; }

        #endregion

        #region [  IEquatable  ]

        public bool Equals(IElement other)
        {
            return (other      != null)
                && (other.Type == ElementType.Structure)
                && base.Equals(other as Tree<IElement>);
        }

        #endregion

    }
}