[JavaScript知识库]Hippy项目源码分析（四）

2021SC@SDUSC

首篇文章已说明我的分工：Core全部内容

目录

??include\core\modules\console_module.h

include\core\modules\contextify_module.h

include\core\modules\module_base.h

include\core\modules\module_register.h

? include\core\modules\console_module.h

#pragma once

#include "core/modules/module_base.h"
#include "core/napi/callback_info.h"

class Scope;

class ConsoleModule : public ModuleBase {
 public:
  ConsoleModule() {}
  void Log(const hippy::napi::CallbackInfo& info);
};

控制端模组

include\core\modules\contextify_module.h

#pragma once

#include "core/base/string_view_utils.h"
#include "core/modules/module_base.h"
#include "core/napi/callback_info.h"
#include "core/napi/js_native_api_types.h"

class Scope;

class ContextifyModule : public ModuleBase {
 public:
  using unicode_string_view = tdf::base::unicode_string_view;
  using CtxValue = hippy::napi::CtxValue;

  ContextifyModule() {}
  void RunInThisContext(const hippy::napi::CallbackInfo& info);
  void LoadUntrustedContent(const hippy::napi::CallbackInfo& info);
  void RemoveCBFunc(const unicode_string_view& uri);

 private:
  std::unordered_map<unicode_string_view, std::shared_ptr<CtxValue>>
      cb_func_map_;
};

contextify：

具有FontAwesome支持的轻量级香草JavaScript上下文菜单库。 这个库是为在我的个人项目中使用而编写的，它是针对上下文菜单功能的AIO解决方案

include\core\modules\module_base.h

#pragma once

class ModuleBase {
 public:
  ModuleBase() = default;
  virtual ~ModuleBase() = default;
};

应用模块化难免会使用插件的方式，使用纯C++方式实现插件的封装，及插件加载器泛型动态加载。按照这种套路，可以封装及批量加载不同类型的自定义插件。

include\core\modules\module_register.h

#pragma once

#include <stdio.h>

#include <memory>
#include <string>

#include "base/unicode_string_view.h"
#include "core/base/macros.h"
#include "core/modules/module_base.h"
#include "core/napi/callback_info.h"
#include "core/napi/js_native_api_types.h"
#include "core/scope.h"

#define REGISTER_MODULE(Module, Function)                                   \
  auto __##Module##Function##__ = [] {                                      \
    ModuleRegister::instance()->RegisterInternalModule(&Module::Function,   \
                                                       #Module, #Function); \
    return 0;                                                               \
  }();

#define REGISTER_GLOBAL_MODULE(Module, Function)                          \
  auto __##Module##Function##__ = [] {                                    \
    ModuleRegister::instance()->RegisterGlobalModule(&Module::Function,   \
                                                     #Module, #Function); \
    return 0;                                                             \
  }();

class ModuleRegister {
 public:
  using unicode_string_view = tdf::base::unicode_string_view;

  static ModuleRegister* instance();

  template <typename Module, typename Function>
  void RegisterInternalModule(Function Module::*member_fn,
                              const unicode_string_view& module_name,
                              const unicode_string_view& function_name) {
    internal_modules_[module_name][function_name] =
        GenerateCallback(member_fn, module_name);
  }

  template <typename Module, typename Function>
  void RegisterGlobalModule(Function Module::*member_fn,
                            const unicode_string_view& module_name,
                            const unicode_string_view& function_name) {
    global_modules_[module_name][function_name] =
        GenerateCallback(member_fn, module_name);
  }

  const hippy::napi::ModuleClassMap& GetInternalList() const {
    return internal_modules_;
  }
  const hippy::napi::ModuleClassMap& GetGlobalList() const {
    return global_modules_;
  }

 private:
  ModuleRegister() = default;

  template <typename Module, typename Function>
  hippy::napi::JsCallback GenerateCallback(Function Module::*member_fn,
      const unicode_string_view& module_name) {
    return [member_fn, module_name](const hippy::napi::CallbackInfo& info) {
      std::shared_ptr<Scope> scope = info.GetScope();
      if (!scope) {
        return;
      }

      auto module_ptr = scope->GetModuleClass(module_name);
      if (!module_ptr) {
        auto module = std::make_unique<Module>();
        module_ptr = module.get();
        scope->AddModuleClass(module_name, std::move(module));
      }

      // Call module function.
      auto target = static_cast<Module*>(module_ptr);
      if (target) {
        std::mem_fn(member_fn)(*target, info);
      }
    };
  }

  hippy::napi::ModuleClassMap internal_modules_;
  hippy::napi::ModuleClassMap global_modules_;

  DISALLOW_COPY_AND_ASSIGN(ModuleRegister);
};

Generator函数(协程coroutine)
Generator 函数有多种理解角度。语法上，Generator 函数是一个状态机，封装了多个内部状态。
执行 Generator 函数会返回一个遍历器对象，也就是说，Generator 函数除了状态机，还是一个遍历器对象生成函数。执行函数后返回的是一个遍历器对象，可以依次遍历 Generator 函数内部的每一个状态。