include/dlvhex2/ASPSolverManager.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_ASPSOLVER_MANAGER_H)
#define _DLVHEX_ASPSOLVER_MANAGER_H

#include "dlvhex2/PlatformDefinitions.h"
#include "dlvhex2/ID.h"
#include "dlvhex2/OrdinaryASPProgram.h"
#include "dlvhex2/AnswerSet.h"
#include "dlvhex2/Error.h"
#include "dlvhex2/ConcurrentMessageQueueOwning.h"
#include "dlvhex2/InputProvider.h"

#include <boost/shared_ptr.hpp>
#include <vector>
#include <list>

DLVHEX_NAMESPACE_BEGIN

struct Registry;
typedef boost::shared_ptr<Registry> RegistryPtr;

class DLVHEX_EXPORT ASPSolverManager
{
    public:
        //
        // options and solver types
        //

        struct DLVHEX_EXPORT GenericOptions
        {
            GenericOptions();
            virtual ~GenericOptions();

            bool includeFacts;
        };

        struct DLVHEX_EXPORT Results
        {
            virtual ~Results() {}
            virtual AnswerSet::Ptr getNextAnswerSet() = 0;
        };
        typedef boost::shared_ptr<Results> ResultsPtr;

        class DLVHEX_EXPORT DelegateInterface
        {
            public:
                virtual ~DelegateInterface() {}
                virtual void useASTInput(const OrdinaryASPProgram& program) = 0;
                virtual void useInputProviderInput(InputProvider& inp, RegistryPtr reg) = 0;
                virtual ResultsPtr getResults() = 0;
        };
        typedef boost::shared_ptr<DelegateInterface> DelegatePtr;

        struct DLVHEX_EXPORT SoftwareBase
        {
            typedef GenericOptions Options;
            typedef DelegateInterface Delegate;

            private:
                SoftwareBase();
        };

        //
        // SoftwareConfiguration(Ptr)
        //

        struct DLVHEX_EXPORT SoftwareConfigurationBase
        {
            virtual DelegatePtr createDelegate() const = 0;
        };
        typedef boost::shared_ptr<SoftwareConfigurationBase> SoftwareConfigurationPtr;

        template<typename SoftwareT>
            struct SoftwareConfiguration:
    public SoftwareConfigurationBase
    {
        typedef SoftwareT Software;
        typedef typename Software::Options Options;

        Options options;

        SoftwareConfiguration(): options() {}
        SoftwareConfiguration(const Options& o): options(o) {}

        virtual ~SoftwareConfiguration() {}

        virtual DelegatePtr createDelegate() const
        {
            return DelegatePtr(new typename Software::Delegate(options));
        }
    };

    public:
        ASPSolverManager();

        ResultsPtr solve(
            const SoftwareConfigurationBase& solver,
            const OrdinaryASPProgram& program) throw (FatalError);

        ResultsPtr solve(
            const SoftwareConfigurationBase& solver,
            InputProvider& input,
            RegistryPtr reg) throw (FatalError);
};

class DLVHEX_EXPORT PreparedResults:
public ASPSolverManager::Results
{
    public:
        typedef std::list<AnswerSet::Ptr> Storage;

    public:
        PreparedResults(const Storage& storage);
        PreparedResults();
        virtual ~PreparedResults();

        void add(AnswerSet::Ptr as);

        virtual AnswerSet::Ptr getNextAnswerSet();

    protected:
        Storage answersets;
        bool resetCurrent;
        Storage::const_iterator current;
};
typedef boost::shared_ptr<PreparedResults> PreparedResultsPtr;

struct DLVHEX_EXPORT AnswerSetQueueElement
{
    AnswerSetPtr answerset;
    std::string error;
    AnswerSetQueueElement(AnswerSetPtr answerset, const std::string& error):
    answerset(answerset), error(error) {}
};
typedef boost::shared_ptr<AnswerSetQueueElement> AnswerSetQueueElementPtr;

// concrete queue for answer sets
typedef ConcurrentMessageQueueOwning<AnswerSetQueueElement> AnswerSetQueue;
typedef boost::shared_ptr<AnswerSetQueue> AnswerSetQueuePtr;

class DLVHEX_EXPORT ConcurrentQueueResults:
public ASPSolverManager::Results
{
    public:
        ConcurrentQueueResults();
        virtual ~ConcurrentQueueResults();

        void enqueueAnswerset(AnswerSetPtr answerset);
        void enqueueException(const std::string& error);
        void enqueueEnd();

        // gets next answer set or throws exception on error condition
        // returns AnswerSetPtr() on end of queue
        virtual AnswerSetPtr getNextAnswerSet();

    protected:
        AnswerSetQueuePtr queue;
};
typedef boost::shared_ptr<ConcurrentQueueResults> ConcurrentQueueResultsPtr;

DLVHEX_NAMESPACE_END
#endif                           // _DLVHEX_ASPSOLVER_MANAGER_H


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