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

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

namespace HeuristicLab.Problems.Robocode
{
    [StorableClass]
    public class LogicalExpression : 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 LogicalExpression(bool deserializing) : base(deserializing) { }
        private LogicalExpression(LogicalExpression original, Cloner cloner)
            : base(original, cloner)
        {
            this.Prefix = "";
            this.Suffix = "";
        }

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

        public override IDeepCloneable Clone(Cloner cloner)
        {
            return new LogicalExpression(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("LogicalExpression 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("LogicalExpression 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;
        }
    }
}