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