组件的注册与调用#

在阅读 librime 的代码过程中，发现不同功能之间调用，是通过组件注册形式来发现与调用的。

所谓组件指 ComponentBase 的子类，代码在：src/rime/component.h 中。

而组件的注册相关管理是指 Registry，代码在：src/rime/registry.h 中。

程序运行时，将全部组件注册到 Registry 的 map 结构中，当需要调用时，在从 Register 中取出相关组件。

我们通过一个 Example 代码说明：

1
#include <map>
2
#include <string>
3

4
using std::map;
5
using std::string;
6

7
template <typename T>
8
using an = std::shared_ptr<T>;
9

10
template <typename T>
11
using the = std::unique_ptr<T>;
12

13
class ComponentBase;
14

15
class Registry {
16
public:
17
  using ComponentMap = map<string, an<ComponentBase>>;
18

19
  an<ComponentBase> find(const string& name);
20
  void registerComponent(const string& name, an<ComponentBase> component);
21
  void unregisterComponent(const string& name);
22
  void clear();
23

24
  static Registry& instance();
25

26
private:
27
  Registry() = default;
28

29
  ComponentMap map_;
30
};

Registry 代码没有什么特别的，就是组件的注册/发现相关函数。唯一需要注意的是，Registry 是单例模式。

1
Registry& Registry::instance() {
2
  static the<Registry> instance_;
3
  if (!instance_) {
4
    instance_ = the<Registry>(new Registry());
5
  }
6
  return *instance_;
7
}
8

9
an<ComponentBase> Registry::find(const string& name) {
10
  auto it = map_.find(name);
11
  if (it != map_.end()) {
12
    return it->second;
13
  }
14
  return nullptr;
15
};
16

17
void Registry::registerComponent(const string& name, an<ComponentBase> component) {
18
  if (auto oldComponent = find(name)) {
19
    oldComponent.reset();
20
  }
21
  map_[name] = component;
22
}
23

24
void Registry::unregisterComponent(const string& name) {
25
  auto it = map_.find(name);
26
  if (it == map_.end()) {
27
    return;
28
  }
29
  it->second.reset();
30
  map_.erase(it);
31
}

组件的代码需要细细咀嚼，仔细阅读可以发现 C++ 与其他编程语言与众不同的地方。

1
#include "registry.hpp"
2

3
class ComponentBase {
4
public:
5
  ComponentBase() = default;
6
  virtual ~ComponentBase() = default;
7
};
8

9
template <typename T, typename Arg>
10
struct Class {
11
  using Initializer = Arg;
12

13
  class Component : virtual public ComponentBase {
14
  public:
15
    virtual an<T> create(Initializer arg) = 0;
16
  };
17

18
  static an<Component> require(const string& name) {
19
    return dynamic_pointer_cast<Component>(Registry::instance().find(name));
20
  }
21
};
22

23
template <typename T>
24
struct Component : public T::Component {
25
public:
26
  an<T> create(typename T::Initializer args) {
27
    return std::make_shared<T>(std::forward<typename T::Initializer>(args));
28
  }
29
};

要实现一个 Component 子类，需要继承 Class 模板类。（个人觉的应该把 Class 改个名称，改为 ComponentRegister）。

1
class Config : public Class<Config, string> {
2
public:
3
  Config() = delete;
4
  Config(string file_path) : config_file_(file_path) {}
5
  ~Config() { std::cout << "call ~Config()" << std::endl; };
6

7
  void print() { std::cout << "config file: " << config_file_ << std::endl; };
8

9
private:
10
  string config_file_;
11
};
12

13
// 方式2
14
class ConfigComponent : public Config::Component {
15
public:
16
  ConfigComponent() { std::cout << "call ConfigComponent()" << std::endl; };
17
  ~ConfigComponent() { std::cout << "call ~ConfigComponent()" << std::endl; };
18

19
  an<Config> create(string file_path) override {
20
    std::cout << "call ConfigComponent create()" << std::endl;
21
    return an<Config>(new Config(file_path));
22
  };
23
};
24

25
int main(int argc, const char* argv[]) {
26
  // 方式1:
27
  // Registry::instance().registerComponent("config", an<Component<Config>>(new Component<Config>));
28

29
  // 方式2:
30
  Registry::instance().registerComponent("config", an<ConfigComponent>(new ConfigComponent()));
31
  an<Config> config = Config::require("config")->create("hamster.yaml");
32
  config->print();
33
  return 0;
34
}

组件注册需要调用 Registry::instance().registerComponent 方法。对于有个性化初始化及清理逻辑的，可使用上面的方式 2 实现。

否则可以方式 1 ，更简单的注册组件。