Function ParseAndEvaluate

codelab/solutions/exercise1.cc:62–105

}  // namespace

absl::StatusOr<std::string> ParseAndEvaluate(absl::string_view cel_expr) {
  // === Start Codelab ===
  // Setup a default environment for building expressions.
  InterpreterOptions options;
  std::unique_ptr<CelExpressionBuilder> builder =
      CreateCelExpressionBuilder(options);

  CEL_RETURN_IF_ERROR(
      RegisterBuiltinFunctions(builder->GetRegistry(), options));

  // Parse the expression. This is fine for codelabs, but this skips the type
  // checking phase. It won't check that functions and variables are available
  // in the environment, and it won't handle certain ambiguous identifier
  // expressions (e.g. container lookup vs namespaced name, packaged function
  // vs. receiver call style function).
  ParsedExpr parsed_expr;
  CEL_ASSIGN_OR_RETURN(parsed_expr, Parse(cel_expr));

  // The evaluator uses a proto Arena for incidental allocations during
  // evaluation.
  google::protobuf::Arena arena;
  // The activation provides variables and functions that are bound into the
  // expression environment. In this example, there's no context expected, so
  // we just provide an empty one to the evaluator.
  Activation activation;

  // Build the expression plan. This assumes that the source expression AST and
  // the expression builder outlive the CelExpression object.
  CEL_ASSIGN_OR_RETURN(std::unique_ptr<CelExpression> expression_plan,
                       builder->CreateExpression(&parsed_expr.expr(),
                                                 &parsed_expr.source_info()));

  // Actually run the expression plan. We don't support any environment
  // variables at the moment so just use an empty activation.
  CEL_ASSIGN_OR_RETURN(CelValue result,
                       expression_plan->Evaluate(activation, &arena));

  // Convert the result to a c++ string. CelValues may reference instances from
  // either the input expression, or objects allocated on the arena, so we need
  // to pass ownership (in this case by copying to a new instance and returning
  // that).
  return ConvertResult(result);
  // === End Codelab ===
}

}  // namespace cel_codelab