Method parse_expr

plugins/experimental/txn_box/plugin/src/Config.cc:427–508

}

Rv<Expr>
Config::parse_expr(YAML::Node expr_node)
{
  std::string_view expr_tag(expr_node.Tag());

  // This is the base entry method, so it needs to handle all cases, although most of them
  // will be delegated. Handle the direct / simple special cases here.

  if (expr_node.IsNull()) { // explicit NULL
    return Expr{NIL_FEATURE};
  }

  // If explicitly marked a literal, then no further processing should be done.
  if (0 == strcasecmp(expr_tag, LITERAL_TAG)) {
    if (!expr_node.IsScalar()) {
      return Errata(S_ERROR, R"("!{}" tag used on value at {} which is not a string as required for a literal.)", LITERAL_TAG,
                    expr_node.Mark());
    }
    return Expr{FeatureView::Literal(this->localize(expr_node.Scalar()))};
  } else if (0 == strcasecmp(expr_tag, DURATION_TAG)) {
    if (!expr_node.IsScalar()) {
      return Errata(S_ERROR, R"("!{}" tag used on value at {} which is not a string as required for a literal.)", LITERAL_TAG,
                    expr_node.Mark());
    }
    auto &&[dt, dt_errata]{Feature{expr_node.Scalar()}.as_duration()};
    return {Expr(dt), std::move(dt_errata)};
  } else if (0 != strcasecmp(expr_tag, "?"_sv) && 0 != strcasecmp(expr_tag, "!"_sv)) {
    return Errata(S_ERROR, R"("{}" tag for extractor expression is not supported.)", expr_tag);
  }

  if (expr_node.IsScalar()) {
    return this->parse_scalar_expr(expr_node);
  }
  if (!expr_node.IsSequence()) {
    return Errata(S_ERROR, "Feature expression is not properly structured.");
  }

  // It's a sequence, handle the various cases.
  if (expr_node.size() == 0) {
    return Expr{NIL_FEATURE};
  }
  if (expr_node.size() == 1) {
    return this->parse_scalar_expr(expr_node[0]);
  }

  if (expr_node[1].IsMap()) { // base expression with modifiers.
    return this->parse_expr_with_mods(expr_node);
  }

  // Else, after all this, it's a tuple, treat each element as an expression.
  ActiveType        l_types;
  bool              literal_p = true; // Is the entire sequence literal?
  std::vector<Expr> xa;
  xa.reserve(expr_node.size());
  for (auto const &child : expr_node) {
    auto &&[expr, errata]{this->parse_expr(child)};
    if (!errata.is_ok()) {
      errata.note("While parsing feature expression list at {}.", expr_node.Mark());