include/dlvhex2/Rule.h

Go to the documentation of this file.

/* dlvhex -- Answer-Set Programming with external interfaces.
 * Copyright (C) 2005-2007 Roman Schindlauer
 * Copyright (C) 2006-2015 Thomas Krennwallner
 * Copyright (C) 2009-2016 Peter Schüller
 * Copyright (C) 2011-2016 Christoph Redl
 * Copyright (C) 2015-2016 Tobias Kaminski
 * Copyright (C) 2015-2016 Antonius Weinzierl
 *
 * This file is part of dlvhex.
 *
 * dlvhex is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2.1 of
 * the License, or (at your option) any later version.
 *
 * dlvhex is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with dlvhex; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
 * 02110-1301 USA.
 */

#ifndef RULE_HPP_INCLUDED__12102010
#define RULE_HPP_INCLUDED__12102010

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/Logger.h"
#include "dlvhex2/ID.h"

DLVHEX_NAMESPACE_BEGIN

struct Rule:
private ostream_printable<Rule>
{
    IDKind kind;

    Tuple head;

    Tuple body;

    Tuple headGuard;

    Tuple bodyWeightVector;

    ID bound;

    ID weight;

    ID level;

    Tuple weakconstraintVector;

    Rule(IDKind kind):
    kind(kind), head(), headGuard(), body(), bound(ID_FAIL), weight(ID_FAIL), level(ID_FAIL)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body):
    kind(kind), head(head), body(body), headGuard(), bound(ID_FAIL), weight(ID_FAIL), level(ID_FAIL)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body, const Tuple& headGuard):
    kind(kind), head(head), body(body), headGuard(headGuard), bound(ID_FAIL), weight(ID_FAIL), level(ID_FAIL)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body, ID weight, ID level, Tuple weakconstraintVector):
    kind(kind), head(head), body(body), headGuard(), bound(ID_FAIL), weight(weight), level(level), weakconstraintVector(weakconstraintVector)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body, const Tuple& headGuard, ID weight, ID level, Tuple weakconstraintVector):
    kind(kind), head(head), body(body), headGuard(headGuard), bound(ID_FAIL), weight(weight), level(level), weakconstraintVector(weakconstraintVector)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, ID weight, ID level, Tuple weakconstraintVector):
    kind(kind), head(), body(), headGuard(), bound(ID_FAIL), weight(weight), level(level), weakconstraintVector(weakconstraintVector)
        { assert(ID(kind,0).isRule()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body, const Tuple& bodyWeightVector, ID bound):
    kind(kind), head(head), body(body), headGuard(), bodyWeightVector(bodyWeightVector), bound(bound), weight(ID_FAIL), level(ID_FAIL)
        { assert(ID(kind,0).isWeightRule()); assert(body.size() == bodyWeightVector.size()); }

    Rule(IDKind kind, const Tuple& head, const Tuple& body, const Tuple& headGuard, const Tuple& bodyWeightVector, ID bound):
    kind(kind), head(head), body(body), headGuard(headGuard), bodyWeightVector(bodyWeightVector), bound(bound), weight(ID_FAIL), level(ID_FAIL)
        { assert(ID(kind,0).isWeightRule()); assert(body.size() == bodyWeightVector.size()); }

    inline bool isEAGuessingRule() const
        { return head.size() == 2 && head[0].isExternalAuxiliary() && head[1].isExternalAuxiliary(); }

    inline bool isEAAuxInputRule() const
        { return head.size() == 1 && head[0].isExternalInputAuxiliary(); }

    std::ostream& print(std::ostream& o) const
    {
        o << "Rule(" << printvector(head) << " <- " << printvector(body);
        if( weight != ID_FAIL || level != ID_FAIL )
            o << " [" << weight << ":" << level << "]";
        if ( ID(kind,0).isWeightRule() )
            o << "; " << printvector(bodyWeightVector) << " >= " << bound.address;
        return o << ")";
    }
};

DLVHEX_NAMESPACE_END
#endif                           // RULE_HPP_INCLUDED__12102010

// vim:expandtab:ts=4:sw=4:
// mode: C++
// End: