include/dlvhex2/ComfortPluginInterface.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 COMFORT_PLUGIN_INTERFACE_HPP_INCLUDED_19012011
#define COMFORT_PLUGIN_INTERFACE_HPP_INCLUDED_19012011

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/PluginInterface.h"
#include <boost/foreach.hpp>

#include <cctype>

DLVHEX_NAMESPACE_BEGIN

struct DLVHEX_EXPORT ComfortTerm:
public ostream_printable<ComfortTerm>
{
    enum Type
    {
        STR,
        INT
    };

    Type type;

    std::string strval;

    int intval;

    bool isConstant() const
        { return (type == STR) && (!isupper(strval[0])); }

    bool isVariable() const
        { return (type == STR) && (isupper(strval[0])); }

    bool isInteger() const
        { return type == INT; }
    bool isAnon() const
        { return type == STR && strval == "_"; }

    static ComfortTerm createVariable(const std::string& s)
        { assert(!s.empty() && isupper(s[0])); return ComfortTerm(STR, s, 0); }

    static ComfortTerm createConstant(const std::string& s)
        { assert(!s.empty() && !isupper(s[0])); return ComfortTerm(STR, s, 0); }

    static ComfortTerm createInteger(int i)
        { return ComfortTerm(INT, "", i); }

    inline bool operator==(const ComfortTerm& other) const
    {
        return
            (type == other.type) &&
            (type == STR || intval == other.intval) &&
            (type == INT || strval == other.strval);
    }

    inline bool operator!=(const ComfortTerm& other) const
        { return !operator==(other); }

    inline bool operator<(const ComfortTerm& other) const
    {
        return
            (type < other.type) ||
            (type == STR && other.type == STR && strval < other.strval) ||
            (type == INT && other.type == INT && intval < other.intval);
    }

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

    protected:
        ComfortTerm(Type type, const std::string& strval, int intval):
        type(type), strval(strval), intval(intval) {}

    public:
        ComfortTerm() : type(STR), strval("") {}

        ComfortTerm(int intval) : type(INT), intval(intval) {
        }

        ComfortTerm(std::string strval, bool addQuotes = false) : type(STR) {
            if (addQuotes && (strval.length() == 0 || strval[0] != '\"' || strval[strval.length() - 1] != '\"')) this->strval = std::string("\"") + strval + std::string("\"");
            else this->strval = strval;
        }

        std::string getUnquotedString() const
        {
            if (strval.length() > 1 && strval[0] == '\"' && strval[strval.length() - 1] == '\"')
                return strval.substr(1, strval.length() - 2);
            else
                return strval;
        }

        std::string getString() const
        {
            return strval;
        }

        std::string getVariable() const
        {
            return strval;
        }
};

typedef std::vector<ComfortTerm> ComfortTuple;

struct DLVHEX_EXPORT ComfortAtom:
public ostream_printable<ComfortAtom>
{
    ComfortTuple tuple;

    inline const std::string& toString() const
        { if( strval.empty() ) calculateStrVal(); return strval; }

    bool operator<(const ComfortAtom& other) const
        { return tuple < other.tuple; }

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

    inline const std::string& getPredicate() const
    {
        assert(!tuple.empty() && !tuple.front().isInteger());
        return tuple.front().strval;
    }

    inline const ComfortTuple getArguments() const
    {
        ComfortTuple ct = tuple;
        assert(ct.size() > 0);
        ct.erase(ct.begin());
        return ct;
    }

    inline const ComfortTerm getArgument(int index) const
    {
        assert(index >= 0 && index < (int)tuple.size());
        return tuple[index];
    }

    inline unsigned getArity() const
    {
        return tuple.size() - 1;
    }

    inline unsigned isStrongNegated() const
    {
        assert(!tuple.empty() && !tuple.front().isInteger());
        assert(!tuple[0].strval.length() == 0);
        return tuple[0].strval[0] == '-';
    }

    inline void setArgument(int index, ComfortTerm arg) {
        assert(index >= 0 && index < (int)tuple.size());
        tuple[index] = arg;
    }

    inline void setArguments(ComfortTuple args) {
        assert(tuple.size() > 0);
        ComfortTerm pred = tuple[0];
        tuple.clear();
        tuple.push_back(pred);
        BOOST_FOREACH (ComfortTerm arg, args) {
            tuple.push_back(arg);
        }
    }

    inline ComfortAtom(){}

    inline ComfortAtom(ComfortTerm pred, ComfortTuple args, bool stronglyNegated = false) {
        tuple.push_back(pred);
        BOOST_FOREACH (ComfortTerm arg, args) {
            tuple.push_back(arg);
        }
    }

    // TODO implement setArgument, setArguments, setPredicate, getArguments, getArgument, getArity, isStrongNegated

    // TODO it might be useful to also implement setArgument, setArguments, setPredicate, getArguments, getArgument, getArity

    bool unifiesWith(const ComfortAtom& other) const;

    protected:
        mutable std::string strval;
        void calculateStrVal() const;
};

// you can stream out ComfortAtom objects, e.g., for debugging
struct ComfortLiteral:
public ostream_printable<ComfortLiteral>
{
    public:
        inline const std::string& toString() const
            { if( strval.empty() ) calculateStrVal(); return strval; }

    protected:
        mutable std::string strval;
        void calculateStrVal() const;
};

// this mimicks the old AtomSet
// you can stream out ComfortInterpretation objects, e.g., for debugging

struct ComfortInterpretation;
struct DLVHEX_EXPORT ComfortInterpretation:
public std::set<ComfortAtom>,
public ostream_printable<ComfortInterpretation>
{
    void insert(const ComfortAtom& a);

    void insert(const ComfortInterpretation& i);

    void remove(const std::set<std::string>& predicates);

    void keep(const std::set<std::string>& predicates);

    void matchPredicate(
        const std::string& predicate,
        ComfortInterpretation& destination) const;

    void matchAtom(
        const ComfortAtom& atom,
        ComfortInterpretation& destination) const;

    ComfortInterpretation difference(const ComfortInterpretation& subtractThis) const;

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

    bool operator==(const ComfortInterpretation& c2) const;
};

class DLVHEX_EXPORT ComfortPluginAtom:
public PluginAtom
{
    public:
        struct ComfortQuery
        {
            ComfortInterpretation interpretation;
            ComfortTuple input;
            ComfortTuple pattern;
        };

        typedef std::set<ComfortTuple>
            ComfortAnswer;

        ComfortPluginAtom(const std::string& predicate, bool monotonic=false):
        PluginAtom(predicate, monotonic) {}

        virtual ~ComfortPluginAtom() {}

        virtual void retrieve(const ComfortQuery& q, ComfortAnswer& a) = 0;

    protected:
        virtual void retrieve(const Query& q, Answer& a);
};

DLVHEX_NAMESPACE_END
#endif                           // COMFORT_PLUGIN_INTERFACE_HPP_INCLUDED_19012011


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