Class FlatExpression

eval/eval/evaluator_core.h:438–512

A flattened representation of the input CEL AST.

// A flattened representation of the input CEL AST.
class FlatExpression {
 public:
  // path is flat execution path that is based upon the flattened AST tree
  // type_provider is the configured type system that should be used for
  //   value creation in evaluation
  FlatExpression(ExecutionPath path, size_t comprehension_slots_size,
                 const cel::TypeProvider& type_provider,
                 const cel::RuntimeOptions& options,
                 absl_nullable std::shared_ptr<google::protobuf::Arena> arena = nullptr)
      : path_(std::move(path)),
        subexpressions_({path_}),
        comprehension_slots_size_(comprehension_slots_size),
        type_provider_(type_provider),
        options_(options),
        arena_(std::move(arena)) {}

  FlatExpression(ExecutionPath path,
                 std::vector<ExecutionPathView> subexpressions,
                 size_t comprehension_slots_size,
                 const cel::TypeProvider& type_provider,
                 const cel::RuntimeOptions& options,
                 absl_nullable std::shared_ptr<google::protobuf::Arena> arena = nullptr)
      : path_(std::move(path)),
        subexpressions_(std::move(subexpressions)),
        comprehension_slots_size_(comprehension_slots_size),
        type_provider_(type_provider),
        options_(options),
        arena_(std::move(arena)) {}

  // Move-only
  FlatExpression(FlatExpression&&) = default;
  FlatExpression& operator=(FlatExpression&&) = delete;

  // Create new evaluator state instance with the configured options and type
  // provider.
  FlatExpressionEvaluatorState MakeEvaluatorState(
      const google::protobuf::DescriptorPool* absl_nonnull descriptor_pool,
      google::protobuf::MessageFactory* absl_nonnull message_factory,
      google::protobuf::Arena* absl_nonnull arena) const;

  // Evaluate the expression.
  //
  // A status may be returned if an unexpected error occurs. Recoverable errors
  // will be represented as a cel::ErrorValue result.
  //
  // If the listener is not empty, it will be called after each evaluation step
  // that correlates to an AST node. The value passed to the will be the top of
  // the evaluation stack, corresponding to the result of the subexpression.
  absl::StatusOr<cel::Value> EvaluateWithCallback(
      const cel::ActivationInterface& activation,
      const cel::EmbedderContext* absl_nullable embedder_context,
      EvaluationListener listener, FlatExpressionEvaluatorState& state) const;

  const ExecutionPath& path() const { return path_; }

  absl::Span<const ExecutionPathView> subexpressions() const {
    return subexpressions_;
  }