kakoune

Fork of kakoune, an acceptable text editor
git clone git://git.laack.co/kakoune.git
Log | Files | Refs

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