Example #1
0
        /// <summary>
        /// Accepts a conjunctive-normal-form expression backwards applier visitor.
        /// </summary>
        /// <param name="visitor">CNF expression visitor.</param>
        public IElementCNF Accept(IElementCNFBackwardsApplierVisitor visitor)
        {
            ClauseCNF newExpression = new ClauseCNF();

            foreach (var literal in this)
            {
                var resultExpression = literal.Accept(visitor);
                if (resultExpression == null)
                {
                    // any of element from the clause holds -> the whole clause holds
                    return(null);
                }
                else
                {
                    newExpression.Add((LiteralCNF)resultExpression);
                }
            }
            return(newExpression);
        }
        /// <summary>
        /// Visits the expression.
        /// </summary>
        /// <param name="expression">Expression.</param>
        public override void Visit(OrExpression expression)
        {
            expression.Children.ForEach(child => child.Accept(this));

            ClauseCNF clause = new ClauseCNF();

            for (int i = 0; i < expression.Children.Count; ++i)
            {
                LiteralCNF literal = Stack.Pop() as LiteralCNF;
                if (literal != null)
                {
                    clause.Add(literal);
                }
                else
                {
                    Debug.Assert(false, "Source expression not in CNF!");
                }
            }
            Stack.Push(clause);
        }