Method load

plugins/experimental/txn_box/plugin/src/text_block.cc:186–276

}

Rv<Directive::Handle>
Do_text_block_define::load(Config &cfg, CfgStaticData const *, YAML::Node drtv_node, swoc::TextView const &, swoc::TextView const &,
                           YAML::Node key_value)
{
  auto   self = new self_type();
  Handle handle(self);
  auto  &fg      = self->_fg;
  self->_line_no = drtv_node.Mark().line;

  auto errata = self->_fg.load(cfg, key_value,
                               {
                                 {NAME_TAG, FeatureGroup::REQUIRED},
                                 {PATH_TAG},
                                 {TEXT_TAG},
                                 {DURATION_TAG},
                                 {NOTIFY_TAG}
  });

  if (!errata.is_ok()) {
    errata.note(R"(While parsing value at {} in "{}" directive at {}.)", key_value.Mark(), KEY, drtv_node.Mark());
    return errata;
  }
  auto idx = fg.index_of(NAME_TAG);

  // Must have a NAME, and either TEXT or PATH. DURATION is optional, but must be a duration if present.
  auto &name_expr{fg[idx]._expr};
  if (!name_expr.is_literal() || !name_expr.result_type().can_satisfy(STRING)) {
    return Errata(S_ERROR, "{} value for {} directive at {} must be a literal string.", NAME_TAG, KEY, drtv_node.Mark());
  }
  self->_name = std::get<IndexFor(STRING)>(std::get<Expr::LITERAL>(name_expr._raw));

  if (auto path_idx = fg.index_of(PATH_TAG); path_idx != INVALID_IDX) {
    auto &path_expr = fg[path_idx]._expr;
    if (!path_expr.is_literal() || !path_expr.result_type().can_satisfy(STRING)) {
      return Errata(S_ERROR, "{} value for {} directive at {} must be a literal string.", PATH_TAG, KEY, drtv_node.Mark());
    }
    self->_path = cfg.localize(ts::make_absolute(std::get<IndexFor(STRING)>(std::get<Expr::LITERAL>(path_expr._raw))).view().data(),
                               Config::LOCAL_CSTR);
  }

  if (auto text_idx = fg.index_of(TEXT_TAG); text_idx != INVALID_IDX) {
    auto &text_expr = fg[text_idx]._expr;
    if (!text_expr.is_literal() || !text_expr.result_type().can_satisfy(STRING)) {
      return Errata(S_ERROR, "{} value for {} directive at {} must be a literal string.", TEXT_TAG, KEY, drtv_node.Mark());
    }
    self->_text = std::get<IndexFor(STRING)>(std::get<Expr::LITERAL>(text_expr._raw));
  }

  if (!self->_text.has_value() && self->_path.empty()) {
    return Errata(S_ERROR, "{} directive at {} must have a {} or a {} key.", KEY, drtv_node.Mark(), PATH_TAG, TEXT_TAG);
  }

  if (auto dur_idx = fg.index_of(DURATION_TAG); dur_idx != INVALID_IDX) {
    auto &dur_expr = fg[dur_idx]._expr;
    if (!dur_expr.is_literal()) {
      return Errata(S_ERROR, "{} value for {} directive at {} must be a literal duration.", DURATION_TAG, KEY, drtv_node.Mark());
    }
    auto &&[dur_value, dur_value_errata]{std::get<Expr::LITERAL>(dur_expr._raw).as_duration()};