EdgeDerivation.cs

Go to the documentation of this file.

using System;

namespace Mercury.Syntax
{
//=============================================================================
//  EdgeDerivation
//=============================================================================

    internal enum DerivationType
    {
        Initial     = 0,
        Fundamental = 1,
        Scanning    = 2,
        Prediction  = 3,
    }

    internal class EdgeDerivation : IEquatable<EdgeDerivation>, IComparable<EdgeDerivation>
    {
        //--[  Private fieds  ]------------------------------------------------

        int? memHash = null; // memoized hash

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

        private EdgeDerivation()
        {
            Source     = null;
            Additional   = null;
        }

        //--[  Static methods  ]-----------------------------------------------

        public static EdgeDerivation Initial()
        { return new EdgeDerivation() { Derivation = DerivationType.Initial }; }

        public static EdgeDerivation Prediction()
        { return new EdgeDerivation() { Derivation = DerivationType.Prediction }; }

        public static EdgeDerivation Scanning(Edge source)
        {
            return new EdgeDerivation() { Derivation = DerivationType.Scanning, Source = source };
        }

        public static EdgeDerivation Fundamental(Edge source, Edge additional)
        {
            return new EdgeDerivation() 
            { Derivation = DerivationType.Fundamental, Source = source, Additional = additional };
        }

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

        public DerivationType Derivation { get; private set; }

        public Edge Source   { get; private set; }

        public Edge Additional { get; private set; }

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

        #region [  Object       ]

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

        public override int GetHashCode()
        {
            if (!memHash.HasValue)
            {
                memHash  =  3 * (int) Derivation;
                memHash +=  7 * (Source     == null ? 0 : Source.GetHashCode());
                memHash += 23 * (Additional == null ? 0 : Additional.GetHashCode());
            }

            return memHash.Value;
        }

        #endregion

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

        #region [  IEquatable   ]

        public bool Equals(EdgeDerivation other)
        {
            return (other         != null)
                && (Derivation    == other.Derivation)       && (GetHashCode() == other.GetHashCode())
                && (Source        == null ? other.Source     == null : Source.Equals(other.Source))
                && (Additional    == null ? other.Additional == null : Additional.Equals(other.Additional));
        }

        #endregion

        #region [  IComparable  ]

        public int CompareTo(EdgeDerivation other)
        {
            int temp = Derivation.CompareTo(other.Derivation);
            
            if ((temp == 0) && (Source     != null)) temp = Source.CompareTo(other.Source);
            if ((temp == 0) && (Additional != null)) temp = Additional.CompareTo(other.Additional);

            return temp;
        }

        #endregion

    }
}