Method load

plugins/experimental/txn_box/plugin/src/Extractor.cc:237–299

}

Errata
FeatureGroup::load(Config &cfg, YAML::Node const &node, std::initializer_list<FeatureGroup::Descriptor> const &ex_keys)
{
  unsigned n_keys = node.size(); // Number of keys in @a node.

  Tracking::Info tracking_info[n_keys];
  Tracking       tracking(node, tracking_info, n_keys);

  // Find the roots of extraction - these are the named keys actually in the node.
  // Need to do this explicitly to transfer the flags, and to check for duplicates in @a ex_keys.
  // It is not an error for a named key to be missing unless it's marked @c REQUIRED.
  for (auto &d : ex_keys) {
    auto tinfo = tracking.find(d._name);
    if (nullptr != tinfo) {
      return Errata(
        S_ERROR, R"("INTERNAL ERROR: "{}" is used more than once in the extractor key list of the feature group for the node {}.)",
        d._name, node.Mark());
    }
    if (node[d._name]) {
      tinfo        = tracking.alloc();
      tinfo->_name = d._name;
    } else if (d._flags[REQUIRED]) {
      return Errata(S_ERROR, R"(The required key "{}" was not found in the node {}.)", d._name, node.Mark());
    }
  }

  // Time to get the expressions and walk the references. Need to finalize the range before calling
  // @c load_key as that can modify @a tracking_count. Also must avoid calling this on keys that
  // are explicit but not required - need to fail on missing keys iff they're referenced, which is
  // checked by @c load_key. The presence of required keys has already been verified.
  for (auto info = tracking_info, limit = info + tracking._count; info < limit; ++info) {
    auto &&[dummy, errata]{this->load_key(cfg, tracking, info->_name)};
    if (!errata.is_ok()) {
      return std::move(errata);
    }
  }

  // Persist the tracking info, now that all the sizes are known.
  _expr_info = cfg.alloc_span<ExprInfo>(tracking._count);
  _expr_info.apply([](ExprInfo &info) { new (&info) ExprInfo; });

  // If there are dependencies, allocate state to hold cached values.
  // If any key was marked dependent, then @a _ref_count > 0.
  if (_ref_count > 0) {
    _ctx_state_span = cfg.reserve_ctx_storage(sizeof(State));
    _ordering       = cfg.alloc_span<index_type>(_ref_count);
    for (index_type idx = 0; idx < _ref_count; ++idx) {
      _ordering[idx] = tracking._info[idx]._order_idx;
    }
  }

  // Persist the keys by copying persistent data from the tracking data to config allocated space.
  for (unsigned short idx = 0; idx < tracking._count; ++idx) {
    Tracking::Info &src = tracking._info[idx];
    ExprInfo       &dst = _expr_info[idx];
    dst._name           = src._name;
    dst._expr           = std::move(src._expr);
    dst._exf_idx        = src._exf_idx;