clasp_options.h

Go to the documentation of this file.

// 
// Copyright (c) 2006-2013, Benjamin Kaufmann
// 
// This file is part of Clasp. See http://www.cs.uni-potsdam.de/clasp/ 
// 
// Clasp is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// Clasp 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 General Public License for more details.
// 
// You should have received a copy of the GNU General Public License
// along with Clasp; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
//
#ifndef CLASP_CLI_CLASP_OPTIONS_H_INCLUDED
#define CLASP_CLI_CLASP_OPTIONS_H_INCLUDED

#ifdef _MSC_VER
#pragma warning (disable : 4200) // nonstandard extension used : zero-sized array
#pragma once
#endif

#include <clasp/clasp_facade.h>
#include <string>
#include <iosfwd>
namespace ProgramOptions {
class OptionContext;
class OptionGroup;
class ParsedOptions;
}
namespace Clasp { namespace Cli {

enum ConfigKey {
#define CONFIG(k,g,c) config_##k,
#define CLASP_CLI_DEFAULT_CONFIGS config_default = 0,
#define CLASP_CLI_AUX_CONFIGS     config_default_max_value,
#include <clasp/cli/clasp_cli_configs.inl>
    config_aux_max_value,
    config_many,
    config_usr,
    config_usr_max_value = 127,
    config_asp_default   = config_tweety,
    config_sat_default   = config_trendy,
    config_tester_default= config_frumpy,
};

enum OptionKey {
#define OPTION(n,k,...) opt_##k,
#define GROUP_BEGIN(X) X
#define CLASP_SOLVER_BASIC_OPTIONS   option_category_solver,
#define CLASP_SOLVER_LOOKBACK_OPTIONS
#define CLASP_SEARCH_BASIC_OPTIONS   option_category_search,
#define CLASP_SEARCH_RESTART_OPTIONS 
#define CLASP_SEARCH_REDUCE_OPTIONS
#define CLASP_CONTEXT_OPTIONS        option_category_context,
#define CLASP_ASP_OPTIONS            option_category_generator,
#define CLASP_ENUM_OPTIONS
#define CLASP_SOLVE_OPTIONS
#include <clasp/cli/clasp_cli_options.inl>
    option_category_end
};
class ClaspCliConfig;
class ConfigIter {
public:
    const char* name() const;
    const char* args() const;
    bool        valid()const;
    bool        next();
private:
    friend class ClaspCliConfig;
    ConfigIter(const char* x);
    const char* base_;
};
class ClaspCliConfig : public ClaspConfig {
public:
    static ConfigKey   allocConfig();

    static void        appendConfig(ConfigKey k, const char* name, const char* cmd);
    static ConfigKey   loadConfig(const char* fileName);
    static ConfigIter  getConfig(ConfigKey key);
    static bool        releaseConfig(ConfigKey key);
    static const char* getDefaults(ProblemType f);
    
    ClaspCliConfig();
    ~ClaspCliConfig();

    void init(uint32 solverId, ConfigKey config = config_asp_default);
    void initTester(uint32 solverId, ConfigKey config = config_default);
    bool set(OptionKey o, const char* value);
    bool set(uint32 solverId, OptionKey o, const char* value);
    bool setTester(uint32 solverId, OptionKey o, const char* value);
    bool finalize();
    

    void addOptions(ProgramOptions::OptionContext& root);
    void addDisabled(ProgramOptions::ParsedOptions& parsed);
    bool finalize(const ProgramOptions::ParsedOptions& parsed, ProblemType type, bool applyDefaults);


    template <class IT>
    bool setConfig(IT first, IT last, ProblemType t) {
        RawConfig config("setConfig");
        while (first != last) { config.addArg(*first++); }
        return setConfig(config, t);
    }
private:
    enum ConfigOption { opt_configuration = -1, opt_tester = -2 };
    static const uint8 mode_solver = 1u;
    static const uint8 mode_tester = 2u;
    static const uint8 mode_relaxed= 4u;
    static const uint8 opt_applied = 0x80u;
    struct ParseContext;
    typedef ProgramOptions::OptionContext OptionContext;
    typedef SingleOwnerPtr<ParseContext>  CtxPtr;
    typedef SingleOwnerPtr<OptionContext> RootPtr;
    typedef PodVector<std::string>::type  ConfigVec;
    typedef ProgramOptions::ParsedOptions ParsedOpts;
    struct ScopedSet {
        ScopedSet(ClaspCliConfig& s, uint8 mode, uint32 sId = 0);
        ~ScopedSet();
        ClaspCliConfig* operator->()const { return self; }
        ClaspCliConfig* self;
    };
    struct RawConfig {
        std::string raw;
        explicit RawConfig(const char* name);
        void addArg(const char* arg);
        void addArg(const std::string& arg);
        ConfigIter iterator() const { return ConfigIter(raw.data()); }
    };
    class ProgOption;
    void init(OptionContext* ctx, bool owned);
    int  get(OptionKey o, CtxOpts*& ctx, SolverParams*& solver, SolveParams*& solve);
    bool set(ConfigOption o, const char* value);
    bool set(const ConfigIter& it, bool allowConfig, const ParsedOpts& exclude, ParsedOpts* out);
    bool setDefaults(UserConfig* active, uint32 sId, const ParsedOpts& exclude, ProblemType t);
    bool setConfig(const RawConfig& c, ProblemType t);
    void error(int opt) const;
    bool             isGenerator() const { return (cliMode & mode_tester) == 0; }
    const UserConfig*active()const       { return isGenerator() ? this : testerConfig(); }
    UserConfig*      active()            { return isGenerator() ? this : testerConfig(); }
    ProgOption*      createOption(int o);
    bool             finalizeTester(bool defs);
    bool             finalizeSolvers(UserConfig* active, const ParsedOpts& exclude, ProblemType t, bool defs);
    const ParsedOpts&finalizeParsed(UserConfig* active, const ParsedOpts& parsed, ParsedOpts& exclude) const;

    static ConfigVec configs_g;
    CtxPtr opts_;
};
void validate(const char* ctx, const SolverParams& solver, const SolveParams& search);

}}
#endif