include/dlvhex2/ExtSourceProperties.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 EXTSOURCEPROPERTIES_HPP_
#define EXTSOURCEPROPERTIES_HPP_

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

#include <vector>
#include <string>

DLVHEX_NAMESPACE_BEGIN

WARNING("TODO what is the difference/intended usage of ExtSourceProperty vs ExtSourceProperties? (the names are not very intuitive)")


struct ExtSourceProperties
{
    // exactly one of the following pointers will be NULL
    ExternalAtom* ea;
    PluginAtom* pa;

    // all indices are 0-based
    std::set<int> monotonicInputPredicates;
    std::set<int> antimonotonicInputPredicates;
    std::set<int> predicateParameterNameIndependence;
    std::set<int> finiteOutputDomain;
    std::set<std::pair<int, int> > relativeFiniteOutputDomain;
    bool functional;
    int functionalStart;
    bool supportSets;
    bool onlySafeSupportSets;
    bool completePositiveSupportSets;
    bool completeNegativeSupportSets;
    bool variableOutputArity;
    bool caresAboutAssigned;
    bool caresAboutChanged;
    bool atomlevellinear;        // predicate input can be split into single atoms
    bool tuplelevellinear;       // predicate input can be split such that only atoms with the same arguments must be grouped
    bool usesEnvironment;        // external atom uses the environment (cf. acthex)
    bool finiteFiber;            // a fixed output value can be produced only by finitly many different inputs
                                 // <i,j> means that output value at position j is strictly smaller than at input position i (strlen)
    std::set<std::pair<int, int> > wellorderingStrlen;
                                 // <i,j> means that output value at position j is strictly smaller than at input position i (wrt. natural numbers)
    std::set<std::pair<int, int> > wellorderingNatural;
    bool providesPartialAnswer;

    ExtSourceProperties() : ea(0), pa(0), functionalStart(0) {
        functional = false;
        atomlevellinear = false;
        tuplelevellinear = false;
        usesEnvironment = false;
        finiteFiber = false;
        onlySafeSupportSets = false;
        supportSets = false;
        completePositiveSupportSets = false;
        completeNegativeSupportSets = false;
        variableOutputArity = false;
        caresAboutAssigned = false;
        caresAboutChanged = false;
        providesPartialAnswer = false;
    }

    ExtSourceProperties& operator|=(const ExtSourceProperties& prop2);

    // setter
    inline void addMonotonicInputPredicate(int index) { monotonicInputPredicates.insert(index); }
    inline void addAntimonotonicInputPredicate(int index) { antimonotonicInputPredicates.insert(index); }
    inline void addPredicateParameterNameIndependence(int index) { predicateParameterNameIndependence.insert(index); }
    inline void addFiniteOutputDomain(int index) { finiteOutputDomain.insert(index); }
    inline void addRelativeFiniteOutputDomain(int index1, int index2) { relativeFiniteOutputDomain.insert(std::pair<int, int>(index1, index2)); }
    inline void setFunctional(bool value) { functional = value; }
    inline void setFunctionalStart(int value) { functionalStart = value; }
    inline void setOnlySafeSupportSets(bool value) { onlySafeSupportSets = value; }
    inline void setSupportSets(bool value) { supportSets = value; }
    inline void setCompletePositiveSupportSets(bool value) { completePositiveSupportSets = value; }
    inline void setCompleteNegativeSupportSets(bool value) { completeNegativeSupportSets = value; }
    inline void setVariableOutputArity(bool value) { variableOutputArity = value; }
    inline void setCaresAboutAssigned(bool value) { caresAboutAssigned = value; }
    inline void setCaresAboutChanged(bool value) { caresAboutChanged = value; }
    inline void setAtomlevellinear(bool value) { atomlevellinear = value; }
    inline void setTuplelevellinear(bool value) { tuplelevellinear = value; }
    inline void setUsesEnvironment(bool value) { usesEnvironment = value; }
    inline void setFiniteFiber(bool value) { finiteFiber = value; }
    inline void addWellorderingStrlen(int index1, int index2) { wellorderingStrlen.insert(std::pair<int, int>(index1, index2)); }
    inline void addWellorderingNatural(int index1, int index2) { wellorderingNatural.insert(std::pair<int, int>(index1, index2)); }
    inline void setProvidesPartialAnswer(bool value) { providesPartialAnswer = value; }

    bool isMonotonic() const;

    bool isAntimonotonic() const;

    bool isNonmonotonic() const;

    bool isMonotonic(int parameterIndex) const
        { return monotonicInputPredicates.count(parameterIndex) > 0; }

    bool isAntimonotonic(int parameterIndex) const
        { return antimonotonicInputPredicates.count(parameterIndex) > 0; }

    bool isNonmonotonic(int parameterIndex) const
        { return !isMonotonic(parameterIndex) && !isAntimonotonic(parameterIndex); }

    bool isFunctional() const
        { return functional; }

    bool isLinearOnAtomLevel() const
        { return atomlevellinear; }

    bool isLinearOnTupleLevel() const
        { return tuplelevellinear; }

    bool isIndependentOfPredicateParameterName(int parameterIndex) const
        { return predicateParameterNameIndependence.count(parameterIndex) > 0; }

    bool doesItUseEnvironment() const
        { return usesEnvironment; }

    bool hasFiniteDomain(int outputElement) const
        { return finiteOutputDomain.count(outputElement) > 0; }

    bool hasRelativeFiniteDomain(int outputElement, int inputElement) const
        { return relativeFiniteOutputDomain.count(std::pair<int, int>(outputElement, inputElement)) > 0; }

    bool hasFiniteFiber() const
        { return finiteFiber; }

    bool hasWellorderingStrlen(int from, int to) const
        { return wellorderingStrlen.count(std::pair<int, int>(from, to)) > 0; }

    bool hasWellorderingNatural(int from, int to) const
        { return wellorderingNatural.count(std::pair<int, int>(from, to)) > 0; }

    bool providesOnlySafeSupportSets() const
        { return onlySafeSupportSets; }

    bool providesSupportSets() const
        { return supportSets; }

    bool providesCompletePositiveSupportSets() const
        { return completePositiveSupportSets; }

    bool providesCompleteNegativeSupportSets() const
        { return completeNegativeSupportSets; }

    bool hasVariableOutputArity() const
        { return variableOutputArity; }

    bool doesCareAboutAssigned() const
        { return caresAboutAssigned; }

    bool doesCareAboutChanged() const
        { return caresAboutChanged; }

    bool doesProvidePartialAnswer() const
        { return providesPartialAnswer; }

    void interpretProperties(RegistryPtr reg, const ExternalAtom& atom, const std::vector<std::vector<std::string> >& props);
};

DLVHEX_NAMESPACE_END
#endif

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