GeezerVison is showing github.com — cppchess_engine/ucioption.h at HandcraftedEngine · winapiadmin/cppchess_engine

Expand file tree

ucioption.h

Copy path

More file actions

Latest commit

History

106 lines (80 loc) · 3.07 KB

ucioption.h

Copy path

File metadata and controls

106 lines (80 loc) · 3.07 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

100

101

102

103

104

105

106

Stockfish, a UCI chess playing engine derived from Glaurung 2.1

Stockfish 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 3 of the License, or

(at your option) any later version.

Stockfish 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 this program. If not, see <http://www.gnu.org/licenses/>.

#ifndef UCIOPTION_H_INCLUDED

#define UCIOPTION_H_INCLUDED

#include <cstddef>

#include <functional>

#include <iosfwd>

#include <map>

#include <optional>

#include <string>

namespace engine {

// Define a custom comparator, because the UCI options should be

// case-insensitive

struct CaseInsensitiveLess {

bool operator()(const std::string &, const std::string &) const;

};

class OptionsMap;

// The Option class implements each option as specified by the UCI protocol

class Option {

public:

using OnChange = std::function<std::optional<std::string>(const Option &)>;

Option(const OptionsMap *);

Option(OnChange = nullptr);

Option(bool v, OnChange = nullptr);

Option(const char *v, OnChange = nullptr);

Option(int v, int minv, int maxv, OnChange = nullptr);

Option(const char *v, const char *cur, OnChange = nullptr);

Option &operator=(const std::string &);

operator int() const;

operator std::string() const;

bool operator==(const char *) const;

bool operator!=(const char *) const;

friend std::ostream &operator<<(std::ostream &, const OptionsMap &);

int operator<<(const Option &) = delete;

private:

friend class OptionsMap;

friend class Engine;

friend class Tune;

std::string defaultValue, currentValue, type;

int min, max;

size_t idx;

OnChange on_change;

const OptionsMap *parent = nullptr;

};

class OptionsMap {

public:

using InfoListener = std::function<void(std::optional<std::string>)>;

OptionsMap() = default;

OptionsMap(const OptionsMap &) = delete;

OptionsMap(OptionsMap &&) = delete;

OptionsMap &operator=(const OptionsMap &) = delete;

OptionsMap &operator=(OptionsMap &&) = delete;

void add_info_listener(InfoListener &&);

void setoption(std::istringstream &);

const Option &operator[](const std::string &) const;

void add(const std::string &, const Option &option);

std::size_t count(const std::string &) const;

private:

friend class Engine;

friend class Option;

friend std::ostream &operator<<(std::ostream &, const OptionsMap &);

// The options container is defined as a std::map

using OptionsStore = std::map<std::string, Option, CaseInsensitiveLess>;

OptionsStore options_map;

InfoListener info;

};

} // namespace engine

#endif // #ifndef UCIOPTION_H_INCLUDED