kakoune/src/option_types.hh

226 lines
6.3 KiB
C++
Raw Normal View History

#ifndef option_types_hh_INCLUDED
#define option_types_hh_INCLUDED
2013-04-09 20:05:40 +02:00
#include "exception.hh"
#include "string.hh"
#include "units.hh"
#include "coord.hh"
2015-01-06 14:40:56 +01:00
#include "array_view.hh"
#include "unordered_map.hh"
#include <tuple>
#include <vector>
namespace Kakoune
{
inline String option_to_string(StringView opt) { return opt.str(); }
inline void option_from_string(StringView str, String& opt) { opt = str.str(); }
2013-03-26 13:47:14 +01:00
2013-05-13 14:23:07 +02:00
inline String option_to_string(int opt) { return to_string(opt); }
inline void option_from_string(StringView str, int& opt) { opt = str_to_int(str); }
inline bool option_add(int& opt, int val) { opt += val; return val != 0; }
2013-03-26 13:47:14 +01:00
inline String option_to_string(bool opt) { return opt ? "true" : "false"; }
inline void option_from_string(StringView str, bool& opt)
2013-03-26 13:47:14 +01:00
{
if (str == "true" or str == "yes")
opt = true;
else if (str == "false" or str == "no")
opt = false;
else
throw runtime_error("boolean values are either true, yes, false or no");
}
constexpr char list_separator = ':';
2015-01-12 14:58:41 +01:00
template<typename T, MemoryDomain domain>
String option_to_string(const Vector<T, domain>& opt)
2013-03-26 13:47:14 +01:00
{
String res;
for (size_t i = 0; i < opt.size(); ++i)
{
res += escape(option_to_string(opt[i]), list_separator, '\\');
2013-03-26 13:47:14 +01:00
if (i != opt.size() - 1)
res += list_separator;
2013-03-26 13:47:14 +01:00
}
return res;
}
2015-01-12 14:58:41 +01:00
template<typename T, MemoryDomain domain>
void option_from_string(StringView str, Vector<T, domain>& opt)
2013-03-26 13:47:14 +01:00
{
opt.clear();
2015-01-09 14:57:21 +01:00
Vector<String> elems = split(str, list_separator, '\\');
2013-03-26 13:47:14 +01:00
for (auto& elem: elems)
{
T opt_elem;
option_from_string(elem, opt_elem);
opt.push_back(opt_elem);
}
}
2015-01-12 14:58:41 +01:00
template<typename T, MemoryDomain domain>
bool option_add(Vector<T, domain>& opt, const Vector<T, domain>& vec)
{
std::copy(vec.begin(), vec.end(), back_inserter(opt));
return not vec.empty();
}
2015-01-14 20:16:32 +01:00
template<typename Key, typename Value, MemoryDomain domain>
String option_to_string(const UnorderedMap<Key, Value, domain>& opt)
2014-11-11 00:24:02 +01:00
{
String res;
for (auto it = begin(opt); it != end(opt); ++it)
{
if (it != begin(opt))
res += list_separator;
String elem = escape(option_to_string(it->first), '=', '\\') + "=" +
escape(option_to_string(it->second), '=', '\\');
res += escape(elem, list_separator, '\\');
}
return res;
}
2015-01-14 20:16:32 +01:00
template<typename Key, typename Value, MemoryDomain domain>
void option_from_string(StringView str, UnorderedMap<Key, Value, domain>& opt)
2014-11-11 00:24:02 +01:00
{
opt.clear();
2015-01-01 13:09:30 +01:00
for (auto& elem : split(str, list_separator, '\\'))
2014-11-11 00:24:02 +01:00
{
2015-01-09 14:57:21 +01:00
Vector<String> pair_str = split(elem, '=', '\\');
2014-11-11 00:24:02 +01:00
if (pair_str.size() != 2)
throw runtime_error("map option expects key=value");
std::pair<Key, Value> pair;
option_from_string(pair_str[0], pair.first);
option_from_string(pair_str[1], pair.second);
opt.insert(std::move(pair));
}
}
constexpr char tuple_separator = '|';
2013-03-26 13:47:14 +01:00
template<size_t I, typename... Types>
struct TupleOptionDetail
{
static String to_string(const std::tuple<Types...>& opt)
{
return TupleOptionDetail<I-1, Types...>::to_string(opt) +
tuple_separator + escape(option_to_string(std::get<I>(opt)), tuple_separator, '\\');
}
static void from_string(ConstArrayView<String> elems, std::tuple<Types...>& opt)
{
option_from_string(elems[I], std::get<I>(opt));
TupleOptionDetail<I-1, Types...>::from_string(elems, opt);
}
};
template<typename... Types>
struct TupleOptionDetail<0, Types...>
{
static String to_string(const std::tuple<Types...>& opt)
{
return option_to_string(std::get<0>(opt));
}
static void from_string(ConstArrayView<String> elems, std::tuple<Types...>& opt)
{
option_from_string(elems[0], std::get<0>(opt));
}
};
template<typename... Types>
String option_to_string(const std::tuple<Types...>& opt)
{
return TupleOptionDetail<sizeof...(Types)-1, Types...>::to_string(opt);
}
template<typename... Types>
void option_from_string(StringView str, std::tuple<Types...>& opt)
{
auto elems = split(str, tuple_separator, '\\');
if (elems.size() != sizeof...(Types))
throw runtime_error(elems.size() < sizeof...(Types) ?
"not enough elements in tuple"
: "to many elements in tuple");
TupleOptionDetail<sizeof...(Types)-1, Types...>::from_string(elems, opt);
}
2013-05-13 14:23:07 +02:00
template<typename RealType, typename ValueType>
inline String option_to_string(const StronglyTypedNumber<RealType, ValueType>& opt)
{
return to_string(opt);
}
2013-05-13 14:23:07 +02:00
template<typename RealType, typename ValueType>
inline void option_from_string(StringView str, StronglyTypedNumber<RealType, ValueType>& opt)
{
opt = StronglyTypedNumber<RealType, ValueType>{str_to_int(str)};
}
2013-05-13 14:23:07 +02:00
template<typename RealType, typename ValueType>
inline bool option_add(StronglyTypedNumber<RealType, ValueType>& opt,
StronglyTypedNumber<RealType, ValueType> val)
{
opt += val;
return val != 0;
}
template<typename T>
bool option_add(T&, const T&)
{
throw runtime_error("no add operation supported for this option type");
}
template<typename EffectiveType, typename LineType, typename ColumnType>
inline void option_from_string(StringView str, LineAndColumn<EffectiveType, LineType, ColumnType>& opt)
{
auto vals = split(str, ',');
if (vals.size() != 2)
throw runtime_error("expected <line>,<column>");
opt.line = str_to_int(vals[0]);
opt.column = str_to_int(vals[1]);
}
template<typename EffectiveType, typename LineType, typename ColumnType>
inline String option_to_string(const LineAndColumn<EffectiveType, LineType, ColumnType>& opt)
{
return format("{},{}", opt.line, opt.column);
}
2013-10-21 19:57:48 +02:00
enum YesNoAsk
{
Yes,
No,
Ask
};
inline String option_to_string(YesNoAsk opt)
{
switch (opt)
{
case Yes: return "yes";
case No: return "no";
case Ask: return "ask";
}
kak_assert(false);
return "ask";
}
inline void option_from_string(StringView str, YesNoAsk& opt)
2013-10-21 19:57:48 +02:00
{
if (str == "yes" or str == "true")
opt = Yes;
else if (str == "no" or str == "false")
opt = No;
else if (str == "ask")
opt = Ask;
else
throw runtime_error(format("invalid value '{}', expected yes, no or ask", str));
2013-10-21 19:57:48 +02:00
}
}
#endif // option_types_hh_INCLUDED