Class Activation

eval/public/activation.h:30–166

Instance of Activation class is used by evaluator. It provides binding between references used in expressions and actual values.

// It provides binding between references used in expressions
// and actual values.
class Activation : public BaseActivation {
 public:
  Activation() = default;

  // Non-copyable/non-assignable
  Activation(const Activation&) = delete;
  Activation& operator=(const Activation&) = delete;

  // Move-constructible/move-assignable
  Activation(Activation&& other) = default;
  Activation& operator=(Activation&& other) = default;

  // BaseActivation
  std::vector<const CelFunction*> FindFunctionOverloads(
      absl::string_view name) const override;

  absl::optional<CelValue> FindValue(absl::string_view name,
                                     google::protobuf::Arena* arena) const override;

  // Insert a function into the activation (ie a lazily bound function). Returns
  // a status if the name and shape of the function matches another one that has
  // already been bound.
  absl::Status InsertFunction(std::unique_ptr<CelFunction> function);

  // Insert value into Activation.
  void InsertValue(absl::string_view name, const CelValue& value);

  // Insert ValueProducer into Activation.
  void InsertValueProducer(absl::string_view name,
                           std::unique_ptr<CelValueProducer> value_producer);

  // Remove functions that have the same name and shape as descriptor. Returns
  // true if matching functions were found and removed.
  bool RemoveFunctionEntries(const CelFunctionDescriptor& descriptor);

  // Removes value or producer, returns true if entry with the name was found
  bool RemoveValueEntry(absl::string_view name);

  // Clears a cached value for a value producer, returns if true if entry was
  // found and cleared.
  bool ClearValueEntry(absl::string_view name);

  // Clears all cached values for value producers. Returns the number of entries
  // cleared.
  int ClearCachedValues();

  // Set missing attribute patterns for evaluation.
  //
  // If a field access is found to match any of the provided patterns, the
  // result is treated as a missing attribute error.
  void set_missing_attribute_patterns(
      std::vector<CelAttributePattern> missing_attribute_patterns) {
    missing_attribute_patterns_ = std::move(missing_attribute_patterns);
  }

  const std::vector<CelAttributePattern>& missing_attribute_patterns()
      const override {
    return missing_attribute_patterns_;