kakoune

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

register_manager.hh (3838B)


      1 #ifndef register_manager_hh_INCLUDED
      2 #define register_manager_hh_INCLUDED
      3 
      4 #include "array_view.hh"
      5 #include "completion.hh"
      6 #include "exception.hh"
      7 #include "utils.hh"
      8 #include "unique_ptr.hh"
      9 #include "hash_map.hh"
     10 #include "string.hh"
     11 #include "vector.hh"
     12 
     13 namespace Kakoune
     14 {
     15 
     16 class Context;
     17 
     18 class Register
     19 {
     20 public:
     21     virtual ~Register() = default;
     22 
     23     virtual void set(Context& context, ConstArrayView<String> values, bool restoring = false) = 0;
     24     virtual ConstArrayView<String> get(const Context& context) = 0;
     25     virtual const String& get_main(const Context& context, size_t main_index) = 0;
     26 
     27     using RestoreInfo = Vector<String, MemoryDomain::Registers>;
     28     RestoreInfo save(const Context& context);
     29     void restore(Context& context, const RestoreInfo& info);
     30 
     31     NestedBool& modified_hook_disabled() { return m_disable_modified_hook; }
     32 
     33 protected:
     34     NestedBool m_disable_modified_hook;
     35 };
     36 
     37 // static value register, which can be modified
     38 class StaticRegister : public Register
     39 {
     40 public:
     41     StaticRegister(String name) : m_name{std::move(name)} {}
     42 
     43     void set(Context& context, ConstArrayView<String> values, bool) override;
     44     ConstArrayView<String> get(const Context&) override;
     45     const String& get_main(const Context& context, size_t main_index) override;
     46 
     47 protected:
     48     String m_name;
     49     Vector<String, MemoryDomain::Registers> m_content;
     50 };
     51 
     52 // Dynamic value register, use it's RegisterRetriever
     53 // to get it's value when needed.
     54 template<typename Getter, typename Setter>
     55 class DynamicRegister : public StaticRegister
     56 {
     57 public:
     58     DynamicRegister(String name, Getter getter, Setter setter)
     59         : StaticRegister(std::move(name)), m_getter(std::move(getter)), m_setter(std::move(setter)) {}
     60 
     61     void set(Context& context, ConstArrayView<String> values, bool) override
     62     {
     63         m_setter(context, values);
     64     }
     65 
     66     ConstArrayView<String> get(const Context& context) override
     67     {
     68         m_content = m_getter(context);
     69         return StaticRegister::get(context);
     70     }
     71 
     72 private:
     73     Getter m_getter;
     74     Setter m_setter;
     75 };
     76 
     77 // Register that is used to store some kind prompt history
     78 class HistoryRegister : public StaticRegister
     79 {
     80 public:
     81     using StaticRegister::StaticRegister;
     82 
     83     void set(Context& context, ConstArrayView<String> values, bool restoring) override;
     84     const String& get_main(const Context&, size_t) override;
     85 };
     86 
     87 template<typename Func>
     88 UniquePtr<Register> make_dyn_reg(String name, Func func)
     89 {
     90     auto setter = [](Context&, ConstArrayView<String>)
     91     {
     92         throw runtime_error("this register is not assignable");
     93     };
     94     return make_unique_ptr<DynamicRegister<Func, decltype(setter)>>(name, std::move(func), setter);
     95 }
     96 
     97 template<typename Getter, typename Setter>
     98 UniquePtr<Register> make_dyn_reg(String name, Getter getter, Setter setter)
     99 {
    100     return make_unique_ptr<DynamicRegister<Getter, Setter>>(name, std::move(getter), std::move(setter));
    101 }
    102 
    103 class NullRegister : public Register
    104 {
    105 public:
    106     void set(Context&, ConstArrayView<String>, bool) override {}
    107 
    108     ConstArrayView<String> get(const Context&) override
    109     {
    110         return ConstArrayView<String>(String::ms_empty);
    111     }
    112 
    113     const String& get_main(const Context&, size_t) override
    114     {
    115         return String::ms_empty;
    116     }
    117 };
    118 
    119 class RegisterManager : public Singleton<RegisterManager>
    120 {
    121 public:
    122     Register& operator[](StringView reg) const;
    123     Register& operator[](Codepoint c) const;
    124     void add_register(Codepoint c, UniquePtr<Register> reg);
    125     CandidateList complete_register_name(StringView prefix, ByteCount cursor_pos) const;
    126 
    127     auto begin() const { return m_registers.begin(); }
    128     auto end() const { return m_registers.end(); }
    129 
    130 protected:
    131     HashMap<Codepoint, UniquePtr<Register>, MemoryDomain::Registers> m_registers;
    132 };
    133 
    134 }
    135 
    136 #endif // register_manager_hh_INCLUDED