include/dlvhex2/ProgramCtx.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.
 */

#if !defined(_DLVHEX_PROGRAMCTX_H)
#define _DLVHEX_PROGRAMCTX_H

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/fwd.h"
#include "dlvhex2/Configuration.h"
#include "dlvhex2/ASPSolverManager.h"
#include "dlvhex2/Interpretation.h"
#include "dlvhex2/PluginContainer.h"
#include "dlvhex2/InputProvider.h"
#include "dlvhex2/FinalEvalGraph.h"
#include "dlvhex2/EvalHeuristicBase.h"
#include "dlvhex2/EvalGraphBuilder.h"
#include "dlvhex2/ExternalAtomEvaluationHeuristicsInterface.h"
#include "dlvhex2/UnfoundedSetCheckHeuristics.h"
#include "dlvhex2/ModelBuilder.h"
#include "dlvhex2/Registry.h"
#include "dlvhex2/Nogood.h"

#include <boost/shared_ptr.hpp>
#include <boost/functional/factory.hpp>

#include <typeinfo>
#include <vector>
#include <string>
#include <iosfwd>

DLVHEX_NAMESPACE_BEGIN

typedef boost::shared_ptr<EvalHeuristicBase<EvalGraphBuilder> >
EvalHeuristicPtr;

typedef boost::shared_ptr<ModelBuilder<FinalEvalGraph> >
ModelBuilderPtr;

typedef boost::function<ModelBuilder<FinalEvalGraph>*(ModelBuilderConfig<FinalEvalGraph>&)>
ModelBuilderFactory;

typedef std::map<std::string, PluginAtomPtr>
PluginAtomMap;

class DLVHEX_EXPORT ProgramCtx
{
    public:
        Configuration config;

        const RegistryPtr& registry() const
            { return _registry; }

        const PluginContainerPtr& pluginContainer() const
            { return _pluginContainer; }

        PluginAtomMap& pluginAtomMap() 
            { return pluginAtoms; }

        void setupRegistry(RegistryPtr registry);

        void changeRegistry(RegistryPtr registry);

        void setupPluginContainer(PluginContainerPtr pluginContainer);

        EvalHeuristicPtr evalHeuristic;
        ModelBuilderFactory modelBuilderFactory;
        ExternalAtomEvaluationHeuristicsFactoryPtr defaultExternalAtomEvaluationHeuristicsFactory;
        UnfoundedSetCheckHeuristicsFactoryPtr unfoundedSetCheckHeuristicsFactory;

        ASPSolverManager::SoftwareConfigurationPtr aspsoftware;

        InputProviderPtr inputProvider;

        HexParserPtr parser;

        std::vector<ID> idb;
        std::vector<std::vector<ID> > idbList;

        Interpretation::Ptr edb;
        std::vector<InterpretationPtr> edbList;

        uint32_t maxint;

        PluginInterfacePtr customModelGeneratorProvider;

        std::vector<int> currentOptimum;
        unsigned currentOptimumRelevantLevels;

        // used by plugins to store specific plugin data in ProgramCtx
        // default constructs PluginT::CtxData if it is not yet stored in ProgramCtx
        template<typename PluginT>
            typename PluginT::CtxData& getPluginData();

        template<typename PluginT>
            typename PluginT::Environment& getPluginEnvironment();
        template<typename PluginT>
            const typename PluginT::Environment& getPluginEnvironment() const;

        // TODO: add visibility policy (as in clasp)
        DependencyGraphPtr depgraph;
        ComponentGraphPtr compgraph;
        std::vector<LiberalSafetyPluginFactoryPtr> liberalSafetyPlugins;
        LiberalSafetyCheckerPtr liberalSafetyChecker;
        FinalEvalGraphPtr evalgraph;
        FinalEvalGraph::EvalUnit ufinal;
        std::list<ModelCallbackPtr> modelCallbacks;
        std::list<FinalCallbackPtr> finalCallbacks;
        ModelBuilderPtr modelBuilder;
        // model graph is only accessible via modelbuilder->getModelGraph()!
        // (model graph is part of the model builder) TODO think about that

        std::map<std::string, std::string> benchmarksToSnapshotAtFirstModel;

        StatePtr state;

        bool terminationRequest;

        void
            changeState(const boost::shared_ptr<State>& s);

    public:
        ProgramCtx();
        ~ProgramCtx();

        ASPSolverManager::SoftwareConfigurationPtr
            getASPSoftware() const;

        void
            setASPSoftware(ASPSolverManager::SoftwareConfigurationPtr c);

        //
        // plugin helpers
        //

        void processPluginOptions(std::list<const char*>& pluginOptions);

        void addPluginAtomsFromPluginContainer();

        void addPluginAtom(PluginAtomPtr atom);

        void associateExtAtomsWithPluginAtoms(const Tuple& idb, bool failOnUnknownAtom=true);

        void setupByPlugins();

        void resetCacheOfPlugins(bool resetOnlyIfUsesEnvironment=true);

        //
        // state processing
        // the following functions are given in intended order of calling
        // optional functions may be omitted
        //

        void showPlugins();
        void convert();
        void parse();
        void moduleSyntaxCheck();
        void mlpSolver();
        void rewriteEDBIDB();
        void safetyCheck();
        void createDependencyGraph();
        void liberalSafetyCheck();
        void optimizeEDBDependencyGraph();
        void createComponentGraph();
        void strongSafetyCheck();
        void createEvalGraph();
        void setupProgramCtx();
        void evaluate();
        void postProcess();

        class SubprogramAnswerSetCallback : public ModelCallback
        {
            public:
                std::vector<InterpretationPtr> answersets;
                virtual bool operator()(AnswerSetPtr model);
                virtual ~SubprogramAnswerSetCallback();
        };
        std::vector<InterpretationPtr> evaluateSubprogram(InterpretationConstPtr edb, std::vector<ID>& idb);
        std::vector<InterpretationPtr> evaluateSubprogram(InputProviderPtr& ip, InterpretationConstPtr addFacts);
        std::vector<InterpretationPtr> evaluateSubprogram(ProgramCtx& pc, bool parse);

    protected:
        RegistryPtr _registry;

        PluginContainerPtr _pluginContainer;

        typedef std::map<std::string, boost::shared_ptr<PluginData> > PluginDataContainer;
        PluginDataContainer pluginData;

        typedef std::map<std::string, boost::shared_ptr<PluginEnvironment> > PluginEnvironmentContainer;
        PluginEnvironmentContainer pluginEnvironment;

        PluginAtomMap pluginAtoms;
};

// used by plugins to store specific plugin data in ProgramCtx
// default constructs PluginT::CtxData if it is not yet stored in ProgramCtx
template<typename PluginT>
typename PluginT::CtxData& ProgramCtx::getPluginData()
{
    const std::string pluginTypeName(typeid(PluginT).name());
    PluginDataContainer::const_iterator it =
        pluginData.find(pluginTypeName);
    if( it == pluginData.end() ) {
        it = pluginData.insert(std::make_pair(
            pluginTypeName,
            boost::shared_ptr<PluginData>(new typename PluginT::CtxData))
            ).first;
    }
    typename PluginT::CtxData* pret =
        dynamic_cast<typename PluginT::CtxData*>(it->second.get());
    assert(!!pret);
    return *pret;
}


// used by plugins to store specific plugin data in ProgramCtx
// default constructs PluginT::Environment if it is not yet stored in ProgramCtx
template<typename PluginT>
typename PluginT::Environment& ProgramCtx::getPluginEnvironment()
{
    const std::string pluginTypeName(typeid(PluginT).name());
    PluginEnvironmentContainer::const_iterator it =
        pluginEnvironment.find(pluginTypeName);
    if( it == pluginEnvironment.end() ) {
        it = pluginEnvironment.insert(std::make_pair(
            pluginTypeName,
            boost::shared_ptr<PluginEnvironment>(new typename PluginT::Environment))
            ).first;
    }
    typename PluginT::Environment* pret =
        dynamic_cast<typename PluginT::Environment*>(it->second.get());
    assert(!!pret);
    return *pret;
}


template<typename PluginT>
const typename PluginT::Environment& ProgramCtx::getPluginEnvironment() const
{
    const std::string pluginTypeName(typeid(PluginT).name());
    PluginEnvironmentContainer::const_iterator it =
        pluginEnvironment.find(pluginTypeName);
    if( it == pluginEnvironment.end() ) {
        throw std::runtime_error("Cannot use getPluginEnvironment const before using not const");
    }
    const typename PluginT::Environment* pret =
        dynamic_cast<const typename PluginT::Environment*>(it->second.get());
    assert(!!pret);
    return *pret;
}


DLVHEX_NAMESPACE_END
#endif                           /* _DLVHEX_PROGRAMCTX_H */



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