option_manager.hh (9053B)
1 #ifndef option_manager_hh_INCLUDED 2 #define option_manager_hh_INCLUDED 3 4 #include "completion.hh" 5 #include "exception.hh" 6 #include "hash_map.hh" 7 #include "option.hh" 8 #include "option_types.hh" 9 #include "ranges.hh" 10 #include "vector.hh" 11 #include "format.hh" 12 #include "string_utils.hh" 13 #include "unique_ptr.hh" 14 15 #include <utility> 16 17 namespace Kakoune 18 { 19 20 class OptionManager; 21 class Context; 22 23 enum class OptionFlags 24 { 25 None = 0, 26 Hidden = 1, 27 }; 28 29 constexpr bool with_bit_ops(Meta::Type<OptionFlags>) { return true; } 30 31 class OptionDesc 32 { 33 public: 34 OptionDesc(String name, String docstring, OptionFlags flags); 35 36 const String& name() const { return m_name; } 37 const String& docstring() const { return m_docstring; } 38 39 OptionFlags flags() const { return m_flags; } 40 41 private: 42 String m_name; 43 String m_docstring; 44 OptionFlags m_flags; 45 }; 46 47 class Option : public UseMemoryDomain<MemoryDomain::Options> 48 { 49 public: 50 virtual ~Option() = default; 51 52 template<typename T> const T& get() const; 53 template<typename T> T& get_mutable(); 54 template<typename T> void set(const T& val, bool notify=true); 55 template<typename T> bool is_of_type() const; 56 57 virtual String get_as_string(Quoting quoting) const = 0; 58 virtual Vector<String> get_as_strings() const = 0; 59 virtual String get_desc_string() const = 0; 60 virtual void set_from_strings(ConstArrayView<String> strs) = 0; 61 virtual void add_from_strings(ConstArrayView<String> strs) = 0; 62 virtual void remove_from_strings(ConstArrayView<String> strs) = 0; 63 virtual void update(const Context& context) = 0; 64 65 virtual bool has_same_value(const Option& other) const = 0; 66 67 virtual Option* clone(OptionManager& manager) const = 0; 68 OptionManager& manager() const { return m_manager; } 69 70 const String& name() const { return m_desc.name(); } 71 const String& docstring() const { return m_desc.docstring(); } 72 OptionFlags flags() const { return m_desc.flags(); } 73 74 protected: 75 Option(const OptionDesc& desc, OptionManager& manager); 76 77 OptionManager& m_manager; 78 const OptionDesc& m_desc; 79 }; 80 81 class OptionManager final : private OptionWatcher 82 { 83 public: 84 OptionManager(OptionManager& parent); 85 ~OptionManager(); 86 87 void reparent(OptionManager& parent); 88 89 Option& operator[] (StringView name); 90 const Option& operator[] (StringView name) const; 91 Option& get_local_option(StringView name); 92 93 void unset_option(StringView name); 94 95 auto flatten_options() const 96 { 97 auto merge = [](auto&& first, const OptionMap& second) { 98 return concatenated(std::forward<decltype(first)>(first) 99 | filter([&second](auto& i) { return not second.contains(i.key); }), 100 second); 101 }; 102 static const OptionMap empty; 103 auto& parent = m_parent ? m_parent->m_options : empty; 104 auto& grand_parent = (m_parent and m_parent->m_parent) ? m_parent->m_parent->m_options : empty; 105 return merge(merge(grand_parent, parent), m_options) | transform(&OptionMap::Item::value); 106 } 107 108 void register_watcher(OptionWatcher& watcher) const; 109 void unregister_watcher(OptionWatcher& watcher) const; 110 111 void on_option_changed(const Option& option) override; 112 private: 113 OptionManager() 114 : m_parent(nullptr) {} 115 // the only one allowed to construct a root option manager 116 friend class Scope; 117 friend class OptionsRegistry; 118 using OptionMap = HashMap<StringView, UniquePtr<Option>, MemoryDomain::Options>; 119 120 OptionMap m_options; 121 OptionManager* m_parent; 122 123 mutable Vector<OptionWatcher*, MemoryDomain::Options> m_watchers; 124 }; 125 126 template<typename T> 127 class TypedOption : public Option 128 { 129 public: 130 TypedOption(OptionManager& manager, const OptionDesc& desc, const T& value) 131 : Option(desc, manager), m_value(value) {} 132 133 void set(T value, bool notify = true) 134 { 135 validate(value); 136 if (m_value != value) 137 { 138 m_value = std::move(value); 139 if (notify) 140 manager().on_option_changed(*this); 141 } 142 } 143 const T& get() const { return m_value; } 144 T& get_mutable() { return m_value; } 145 146 Vector<String> get_as_strings() const override 147 { 148 return option_to_strings(m_value); 149 } 150 151 String get_as_string(Quoting quoting) const override 152 { 153 return option_to_string(m_value, quoting); 154 } 155 156 String get_desc_string() const override 157 { 158 if constexpr (std::is_same_v<int, T> or std::is_same_v<bool, T> or std::is_same_v<String, T>) 159 return option_to_string(m_value, Quoting::Raw); 160 else 161 return "..."; 162 } 163 164 void set_from_strings(ConstArrayView<String> strs) override 165 { 166 set(option_from_strings(Meta::Type<T>{}, strs)); 167 } 168 169 void add_from_strings(ConstArrayView<String> strs) override 170 { 171 if (option_add_from_strings(m_value, strs)) 172 m_manager.on_option_changed(*this); 173 } 174 175 void remove_from_strings(ConstArrayView<String> strs) override 176 { 177 if (option_remove_from_strings(m_value, strs)) 178 m_manager.on_option_changed(*this); 179 } 180 181 void update(const Context& context) override 182 { 183 option_update(m_value, context); 184 } 185 186 bool has_same_value(const Option& other) const override 187 { 188 return other.is_of_type<T>() and other.get<T>() == m_value; 189 } 190 private: 191 virtual void validate(const T& value) const {} 192 T m_value; 193 }; 194 195 template<typename T, void (*validator)(const T&)> 196 class TypedCheckedOption : public TypedOption<T> 197 { 198 using TypedOption<T>::TypedOption; 199 200 Option* clone(OptionManager& manager) const override 201 { 202 return new TypedCheckedOption{manager, this->m_desc, this->get()}; 203 } 204 205 void validate(const T& value) const override { if (validator != nullptr) validator(value); } 206 }; 207 208 template<typename T> const T& Option::get() const 209 { 210 auto* typed_opt = dynamic_cast<const TypedOption<T>*>(this); 211 if (not typed_opt) 212 throw runtime_error(format("option '{}' is not of type '{}'", name(), 213 option_type_name(Meta::Type<T>{}))); 214 return typed_opt->get(); 215 } 216 217 template<typename T> T& Option::get_mutable() 218 { 219 return const_cast<T&>(get<T>()); 220 } 221 222 template<typename T> void Option::set(const T& val, bool notify) 223 { 224 auto* typed_opt = dynamic_cast<TypedOption<T>*>(this); 225 if (not typed_opt) 226 throw runtime_error(format("option '{}' is not of type '{}'", name(), 227 option_type_name(Meta::Type<T>{}))); 228 return typed_opt->set(val, notify); 229 } 230 231 template<typename T> bool Option::is_of_type() const 232 { 233 return dynamic_cast<const TypedOption<T>*>(this) != nullptr; 234 } 235 236 class OptionsRegistry 237 { 238 public: 239 OptionsRegistry(OptionManager& global_manager) : m_global_manager(global_manager) {} 240 241 template<typename T, void (*validator)(const T&) = nullptr> 242 Option& declare_option(StringView name, StringView docstring, 243 const T& value, 244 OptionFlags flags = OptionFlags::None) 245 { 246 auto is_option_identifier = [](char c) { 247 return is_basic_alpha(c) or is_basic_digit(c) or c == '_'; 248 }; 249 250 if (not all_of(name, is_option_identifier)) 251 throw runtime_error{format("name '{}' contains char out of [a-zA-Z0-9_]", name)}; 252 253 auto& opts = m_global_manager.m_options; 254 auto it = opts.find(name); 255 if (it != opts.end()) 256 { 257 if (it->value->is_of_type<T>() and it->value->flags() == flags) 258 return *it->value; 259 throw runtime_error{format("option '{}' already declared with different type or flags", name)}; 260 } 261 String doc = docstring.empty() ? format("[{}]", option_type_name(Meta::Type<T>{})) 262 : format("[{}] - {}", option_type_name(Meta::Type<T>{}), docstring); 263 m_descs.emplace_back(new OptionDesc{name.str(), std::move(doc), flags}); 264 return *opts.insert({m_descs.back()->name(), 265 make_unique_ptr<TypedCheckedOption<T, validator>>(m_global_manager, *m_descs.back(), value)}); 266 } 267 268 const OptionDesc* option_desc(StringView name) const 269 { 270 auto it = find_if(m_descs, 271 [&name](const UniquePtr<const OptionDesc>& opt) 272 { return opt->name() == name; }); 273 return it != m_descs.end() ? it->get() : nullptr; 274 } 275 276 bool option_exists(StringView name) const { return option_desc(name) != nullptr; } 277 278 CandidateList complete_option_name(StringView prefix, ByteCount cursor_pos) const; 279 280 void clear_option_trash() { m_option_trash.clear(); } 281 void move_to_trash(UniquePtr<Option>&& option) { m_option_trash.push_back(std::move(option)); } 282 private: 283 OptionManager& m_global_manager; 284 Vector<UniquePtr<const OptionDesc>, MemoryDomain::Options> m_descs; 285 Vector<UniquePtr<Option>> m_option_trash; 286 }; 287 288 } 289 290 #endif // option_manager_hh_INCLUDED