Function ParseFunctionConfigs

env/env_yaml.cc:635–680

}

absl::Status ParseFunctionConfigs(Config& config, absl::string_view yaml,
                                  const YAML::Node& root) {
  const YAML::Node functions = root["functions"];
  if (!functions.IsDefined()) {
    return absl::OkStatus();
  }
  if (!functions.IsSequence()) {
    return YamlError(yaml, functions, "Node 'functions' is not a sequence");
  }

  for (const YAML::Node& function : functions) {
    Config::FunctionConfig function_config;
    if (!function || !function.IsMap()) {
      return YamlError(yaml, function, "Function is not a map");
    }
    const YAML::Node name = function["name"];
    if (!name || !name.IsScalar()) {
      return YamlError(yaml, name, "Function name is not a string");
    }
    function_config.name = GetString(yaml, name);
    const YAML::Node description = function["description"];
    if (description.IsDefined()) {
      if (!description.IsScalar()) {
        return YamlError(yaml, description,
                         "Function description is not a string");
      }
      function_config.description = GetString(yaml, description);
    }
    const YAML::Node overloads = function["overloads"];
    if (overloads.IsDefined()) {
      if (!overloads.IsSequence()) {
        return YamlError(yaml, overloads,
                         "Function 'overloads' item is not a sequence");
      }

      for (const YAML::Node& overload : overloads) {
        CEL_ASSIGN_OR_RETURN(Config::FunctionOverloadConfig overload_config,
                             ParseFunctionOverloadConfig(yaml, overload));
        function_config.overload_configs.push_back(std::move(overload_config));
      }
    }

    CEL_RETURN_IF_ERROR(config.AddFunctionConfig(function_config));
  }
  return absl::OkStatus();
}

void EmitContainerConfig(const Config& env_config, YAML::Emitter& out) {
  const auto& container_config = env_config.GetContainerConfig();