include/dlvhex2/Atoms.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 ATOMS_HPP_INCLUDED__14102010
#define ATOMS_HPP_INCLUDED__14102010

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/fwd.h"
#include "dlvhex2/Logger.h"
#include "dlvhex2/ID.h"
#include "dlvhex2/PredicateMask.h"
#include "dlvhex2/ExtSourceProperties.h"

#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>

#include <vector>
#include <list>

DLVHEX_NAMESPACE_BEGIN

struct DLVHEX_EXPORT Atom
{
    IDKind kind;

    Tuple tuple;

    // used for indices
    ID front() const { return tuple.front(); }

    protected:
        Atom(IDKind kind):
        kind(kind), tuple()
            { assert(ID(kind,0).isAtom()); }
        Atom(IDKind kind, const Tuple& tuple):
        kind(kind), tuple(tuple)
            { assert(ID(kind,0).isAtom()); }
};

// regarding strong negation:
// during the parse process we do the following:
// we convert strong negation -<foo> into <foo'> (careful with variables in <foo>!)
// we add constraint :- <foo>, <foo'>.
// we somehow mark the <foo'> as strongly negated helper s.t. output can correctly print results
//
// for the first implementation, we leave out strong negation alltogether (not parseable)
struct DLVHEX_EXPORT OrdinaryAtom:
public Atom,
private ostream_printable<OrdinaryAtom>
{
    std::string text;

    bool unifiesWith(const OrdinaryAtom& a) const;
    bool unifiesWith(const OrdinaryAtom& a, RegistryPtr reg) const;
    bool existsHomomorphism(RegistryPtr reg, const OrdinaryAtom& a) const;

    OrdinaryAtom(IDKind kind):
    Atom(kind), text()
        { assert(ID(kind,0).isOrdinaryAtom()); }
    OrdinaryAtom(IDKind kind, const std::string& text):
    Atom(kind), text(text)
        { assert(ID(kind,0).isOrdinaryAtom()); assert(!text.empty()); }
    OrdinaryAtom(IDKind kind, const std::string& text, const Tuple& tuple):
    Atom(kind, tuple), text(text) {
        assert(ID(kind,0).isOrdinaryAtom());
        assert(!text.empty());
    }
    std::ostream& print(std::ostream& o) const
        { return o << "OrdinaryAtom(" << std::hex << kind << std::dec << ",'" << text << "'," << printvector(tuple) << ")"; }

};

struct DLVHEX_EXPORT BuiltinAtom:
public Atom,
private ostream_printable<BuiltinAtom>
{
    BuiltinAtom(IDKind kind):
    Atom(kind)
        { assert(ID(kind,0).isBuiltinAtom()); }
    BuiltinAtom(IDKind kind, const Tuple& tuple):
    Atom(kind, tuple)
        { assert(ID(kind,0).isBuiltinAtom()); }
    std::ostream& print(std::ostream& o) const
        { return o << "BuiltinAtom(" << printvector(tuple) << ")"; }
};

struct DLVHEX_EXPORT AggregateAtom:
public Atom,
private ostream_printable<AggregateAtom>
{
    Tuple variables;
    Tuple literals;

    std::vector<Tuple> mvariables;

    std::vector<Tuple> mliterals;

    AggregateAtom(IDKind kind):
    Atom(kind, Tuple(5, ID_FAIL)),
        variables(), literals()
        { assert(ID(kind,0).isAggregateAtom()); }
    AggregateAtom(IDKind kind,
        const Tuple& tuple, const Tuple& variables, const Tuple& literals):
    Atom(kind, tuple), variables(variables), literals(literals) {
        assert(ID(kind,0).isAggregateAtom()); assert(tuple.size() == 5);
        assert(!variables.empty()); assert(!literals.empty());
    }
    AggregateAtom(IDKind kind,
        const Tuple& tuple, const std::vector<Tuple>& mvariables, const std::vector<Tuple>& mliterals):
    Atom(kind, tuple), mvariables(mvariables), mliterals(mliterals) {
        assert(ID(kind,0).isAggregateAtom()); assert(tuple.size() == 5);
        assert(!mvariables.empty()); assert(!mliterals.empty());
        assert(mvariables.size() == mliterals.size());
        for (int i = 0; i < mvariables.size(); ++i) { assert(!mvariables[i].empty() && !mliterals[i].empty() ); }
    }
    std::ostream& print(std::ostream& o) const
    {
        return o << "AggregateAtom(" << printvector(tuple) << " with vars " <<
            printvector(variables) << " and literals " << printvector(literals) << ")";
    }
};

struct DLVHEX_EXPORT ExternalAtom:
public Atom,
private ostream_printable<ExternalAtom>
{
    ID predicate;

    Tuple inputs;

    // Atom::tuple is used for output terms

    mutable PluginAtom* pluginAtom;

    ID auxInputPredicate;
    typedef std::vector<std::list<unsigned> > AuxInputMapping;
    AuxInputMapping auxInputMapping;

    // auxiliary replacement predicate name is stored in pluginAtom!

    WARNING("inputMask seems to be duplicated in parts of ExternalAtomMask")
        mutable boost::shared_ptr<PredicateMask> inputMask;
    mutable boost::shared_ptr<PredicateMask> auxInputMask;

    mutable ExtSourceProperties prop;

    public:
        ExternalAtom(IDKind kind, ID predicate, const Tuple& inputs, const Tuple& outputs):
        Atom(kind, outputs),
            predicate(predicate),
            inputs(inputs),
            pluginAtom(),
            auxInputPredicate(ID_FAIL),
            inputMask(new PredicateMask),
            auxInputMask(new PredicateMask)
            { assert(ID(kind,0).isExternalAtom()); assert(predicate.isConstantTerm()); prop.ea = this; }
        ExternalAtom(IDKind kind):
        Atom(kind),
            predicate(ID_FAIL),
            inputs(),
            pluginAtom(),
            auxInputPredicate(ID_FAIL),
            inputMask(new PredicateMask),
            auxInputMask(new PredicateMask)
            { assert(ID(kind,0).isExternalAtom()); prop.ea = this; }
        ~ExternalAtom();

        ExternalAtom(const ExternalAtom& ea) : Atom(ea) {
            predicate = ea.predicate;
            inputs = ea.inputs;
            pluginAtom = ea.pluginAtom;
            auxInputPredicate = ea.auxInputPredicate;
            auxInputMapping = ea.auxInputMapping;
            inputMask = ea.inputMask;
            auxInputMask = ea.auxInputMask;
            prop = ea.prop;
            prop.ea = this;      // use the containing external atom
        }

        void operator=(const ExternalAtom& ea) {
            Atom::operator=(ea);
            predicate = ea.predicate;
            inputs = ea.inputs;
            pluginAtom = ea.pluginAtom;
            auxInputPredicate = ea.auxInputPredicate;
            auxInputMapping = ea.auxInputMapping;
            inputMask = ea.inputMask;
            auxInputMask = ea.auxInputMask;
            prop = ea.prop;
            prop.ea = this;      // use the containing external atom
        }

        const ExtSourceProperties& getExtSourceProperties() const;

        std::ostream& print(std::ostream& o) const;

        void updatePredicateInputMask() const;
        InterpretationConstPtr getPredicateInputMask() const
            { return inputMask->mask(); }
        InterpretationConstPtr getAuxInputMask() const
            { return auxInputMask->mask(); }
};

struct DLVHEX_EXPORT ModuleAtom:
public Atom,
private ostream_printable<ModuleAtom>
{

    ID predicate;
    Tuple inputs;
    ID outputAtom;
    std::string actualModuleName;
    // Atom::tuple is used for output terms

    public:
        ModuleAtom(IDKind kind, ID predicate, const Tuple& inputs, ID outputAtom, std::string actualModuleName):
        Atom(kind),
            predicate(predicate),
            inputs(inputs),
            outputAtom(outputAtom),
            actualModuleName(actualModuleName)
            { }

        ModuleAtom(IDKind kind):
        Atom(kind),
            predicate(ID_FAIL),
            inputs(),
            outputAtom(ID_FAIL),
            actualModuleName("")
            { }

        std::ostream& print(std::ostream& o) const;

};

// to prefixed atom (predicate name of the atom)
const std::string MODULEPREFIXSEPARATOR="__";
const std::string MODULEINSTSEPARATOR="___";

DLVHEX_NAMESPACE_END
#endif                           // ATOMS_HPP_INCLUDED__14102010

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