source: branches/Robocode/HeuristicLab.Problems.Robocode/Symbols/Logical Expressions/Negation.cs @ 9593

using HeuristicLab.Common;
using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;

namespace HeuristicLab.Problems.Robocode
{
    [StorableClass]
    public class Negation : CodeNode
    {
        public override int MinimumArity { get { return 1; } }
        public override int MaximumArity { get { return 1; } }

        [Storable]
        public override string Prefix { get; set; }

        [Storable]
        public override string Suffix { get; set; }

        [StorableConstructor]
        private Negation(bool deserializing) : base(deserializing) { }
        private Negation(Negation original, Cloner cloner)
            : base(original, cloner)
        {
            this.Prefix = "!(";
            this.Suffix = ")";
        }

        public Negation()
            : base("Negation", "A Negation.")
        {
            this.Prefix = "!(";
            this.Suffix = ")";
        }

        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new Negation(this, cloner);
        }

        public override string Interpret(ISymbolicExpressionTreeNode node, System.Collections.Generic.IEnumerable<ISymbolicExpressionTreeNode> children)
        {
            var enumerator = children.GetEnumerator();
            if (!enumerator.MoveNext()) throw new System.Exception("Negation was not given a child.");
            
            var symbol = enumerator.Current.Symbol;
            if (!(symbol is LogicalValue || symbol is LogicalComparison ||
                symbol is NumericalComparison || symbol is Negation))
                throw new System.Exception("Negation was given a child of type " + symbol.GetType().ToString() +
                    ". The expected child must be of type " + typeof(LogicalValue).ToString() + " or " +
                    typeof(LogicalComparison).ToString() + " or " + typeof(NumericalComparison).ToString() + " or " +
                    typeof(Negation).ToString() + ".");

            string result = ((CodeNode)symbol).Interpret(enumerator.Current, enumerator.Current.Subtrees);
            if (enumerator.MoveNext()) throw new System.Exception("LogicalExpression was given more than one child.");

            return this.Prefix + result + this.Suffix;
        }
    }
}