Method Evaluate1Unknown

eval/eval/comprehension_step.cc:212–279

}

absl::StatusOr<bool> ComprehensionDirectStep::Evaluate1Unknown(
    ExecutionFrameBase& frame, IterableKind range_iter_kind,
    const AttributeTrail& range_iter_attr,
    ValueIterator* absl_nonnull range_iter,
    ComprehensionSlots::Slot* absl_nonnull accu_slot,
    ComprehensionSlots::Slot* absl_nonnull iter_slot, Value& result,
    AttributeTrail& trail) const {
  Value condition;
  AttributeTrail condition_attr;
  Value key_or_value;
  Value* key;
  Value* value;

  switch (range_iter_kind) {
    case IterableKind::kList:
      key = &key_or_value;
      value = iter_slot->mutable_value();
      break;
    case IterableKind::kMap:
      key = iter_slot->mutable_value();
      value = nullptr;
      break;
    default:
      ABSL_UNREACHABLE();
  }
  while (true) {
    CEL_ASSIGN_OR_RETURN(bool ok, range_iter->Next2(frame.descriptor_pool(),
                                                    frame.message_factory(),
                                                    frame.arena(), key, value));
    if (!ok) {
      break;
    }
    CEL_RETURN_IF_ERROR(frame.IncrementIterations());
    *iter_slot->mutable_attribute() =
        range_iter_attr.Step(AttributeQualifierFromValue(*key));
    if (frame.attribute_utility().CheckForUnknownExact(
            iter_slot->attribute())) {
      *iter_slot->mutable_value() = frame.attribute_utility().CreateUnknownSet(
          iter_slot->attribute().attribute());
    }

    // Evaluate the loop condition.
    CEL_RETURN_IF_ERROR(condition_->Evaluate(frame, condition, condition_attr));

    switch (condition.kind()) {
      case ValueKind::kBool:
        break;
      case ValueKind::kError:
        ABSL_FALLTHROUGH_INTENDED;
      case ValueKind::kUnknown:
        result = std::move(condition);
        return true;
      default:
        result =
            cel::ErrorValue(CreateNoMatchingOverloadError("<loop_condition>"));
        return true;
    }