/home/brandes/workspace/LAMA/src/lama/solver/MetaSolver.hpp

Go to the documentation of this file.

#ifndef LAMA_METASOLVER_HPP_
#define LAMA_METASOLVER_HPP_

// for dll_import
#include <lama/config.hpp>

// base classes
#include <lama/solver/Solver.hpp>

// others
#include <lama/solver/creator/SolverCreator.hpp>
#include <lama/solver/creator/SolverFactory.hpp>

// spirit
#include <boost/spirit/include/qi.hpp>

#include <string>
#include <fstream>

namespace lama
{

namespace phoenix = boost::phoenix;
namespace qi = boost::spirit::qi;
namespace ascii = boost::spirit::ascii;

class LAMA_DLL_IMPORTEXPORT MetaSolver : public Solver
{
public:
    typedef std::string::const_iterator StringIterator;

    MetaSolver( const std::string& id );

    MetaSolver( const std::string& id, LoggerPtr logger );

    MetaSolver( const std::string& id, const std::string& configuration );

    MetaSolver( const std::string& id, const std::string& configuration, LoggerPtr logger );

    MetaSolver( const MetaSolver& other );

    virtual ~MetaSolver();

    virtual void initialize( const Matrix& coefficients );

    virtual void initializePreconditioner( const Matrix& coefficients, LogLevel::LogLevel level  );


    virtual void solveImpl();


    /*
     * @brief If arg is a file it reads the files content. If not it calls the direct interpretation
     *
     * @param[in] arg   Input string which is a file name or a configuration string
     */
    void interpreteArgument( const std::string arg );

    /*
     * @brief Parses the given configuration and constructs the MetaSolver
     *
     * Parses the given configuration in mConfiguration and constructs the MetaSolver with the
     * described settings.
     */
    void parseConfiguration( const std::string& configuration );

    struct MetaSolverRuntime : SolverRuntime
    {
        MetaSolverRuntime();
        virtual ~MetaSolverRuntime();
        
        SolverPtr mRootSolver;
    };

    virtual const MetaSolverRuntime& getConstRuntime() const;

private:
    virtual SolverPtr copy();

    virtual MetaSolverRuntime& getRuntime();

    MetaSolverRuntime mMetaSovlerRuntime;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

};

class SolverConfigGrammar :
    public qi::grammar<std::string::const_iterator, void(), ascii::space_type>
{
public:
    typedef std::string::const_iterator StringIterator;
    SolverConfigGrammar();

    void setRootSolver( SolverPtr solver );

    SolverPtr getRootSolver();

private:
    typedef SolverCreator::RuleType RuleType;

    qi::rule<StringIterator, void(), qi::locals< RuleType >, ascii::space_type>
                    mRSolverConfiguration;

    qi::rule<StringIterator, void(), ascii::space_type> mRCriteriaConfiguration;

    qi::rule<StringIterator, void(), ascii::space_type> mRLoggerConfiguration;

    qi::rule<StringIterator, void(), ascii::space_type> mRConfiguration;

    qi::rule<StringIterator, void(), ascii::space_type> mRConfigurationSequence;

    SolverPtr mRootSolver;

    LAMA_LOG_DECL_STATIC_LOGGER(logger);

};

//template <typename Iterator>
//struct SkipGrammar : qi::grammar<Iterator, void()>
//{
//    SkipGrammar();
//
//    qi::rule<Iterator, void()> comment;
//    qi::rule<Iterator, void()> start;
//};

} //namespace lama

#endif /* METASOLVER_HPP_ */