re2 1.22.2 → 1.23.0

package/vendor/abseil-cpp/absl/status/statusor.h

@@ -93,7 +93,7 @@ class BadStatusOrAccess : public std::exception {
   //
   // The pointer of this string is guaranteed to be valid until any non-const
   // function is invoked on the exception object.
-  absl::Nonnull<const char*> what() const noexcept override;
+  const char* absl_nonnull what() const noexcept override;
 
   // BadStatusOrAccess::status()
   //
@@ -189,14 +189,22 @@ class ABSL_MUST_USE_RESULT StatusOr;
 //    return Foo(arg);
 //  }
 template <typename T>
-class StatusOr : private internal_statusor::StatusOrData<T>,
+class StatusOr : private internal_statusor::OperatorBase<T>,
+                 private internal_statusor::StatusOrData<T>,
                  private internal_statusor::CopyCtorBase<T>,
                  private internal_statusor::MoveCtorBase<T>,
                  private internal_statusor::CopyAssignBase<T>,
                  private internal_statusor::MoveAssignBase<T> {
+#ifndef SWIG
+  static_assert(!std::is_rvalue_reference_v<T>,
+                "rvalue references are not yet supported.");
+#endif  // SWIG
+
   template <typename U>
   friend class StatusOr;
 
+  friend internal_statusor::OperatorBase<T>;
+
   typedef internal_statusor::StatusOrData<T> Base;
 
  public:
@@ -397,7 +405,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
             typename std::enable_if<
                 internal_statusor::IsAssignmentValid<T, U, true>::value,
                 int>::type = 0>
-  StatusOr& operator=(U&& v ABSL_ATTRIBUTE_LIFETIME_BOUND) {
+  StatusOr& operator=(U&& v ABSL_INTERNAL_ATTRIBUTE_CAPTURED_BY(this)) {
     this->Assign(std::forward<U>(v));
     return *this;
   }
@@ -464,7 +472,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // Returns a reference to the current `absl::Status` contained within the
   // `absl::StatusOr<T>`. If `absl::StatusOr<T>` contains a `T`, then this
   // function returns `absl::OkStatus()`.
-  const Status& status() const&;
+  ABSL_MUST_USE_RESULT const Status& status() const&;
   Status status() &&;
 
   // StatusOr<T>::value()
@@ -493,10 +501,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   //
   // The `std::move` on statusor instead of on the whole expression enables
   // warnings about possible uses of the statusor object after the move.
-  const T& value() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& value() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& value() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& value() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  using StatusOr::OperatorBase::value;
 
   // StatusOr<T>:: operator*()
   //
@@ -508,10 +513,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // `absl::StatusOr<T>`. Alternatively, see the `value()` member function for a
   // similar API that guarantees crashing or throwing an exception if there is
   // no current value.
-  const T& operator*() const& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T& operator*() & ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  const T&& operator*() const&& ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T&& operator*() && ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  using StatusOr::OperatorBase::operator*;
 
   // StatusOr<T>::operator->()
   //
@@ -520,8 +522,7 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   // REQUIRES: `this->ok() == true`, otherwise the behavior is undefined.
   //
   // Use `this->ok()` to verify that there is a current value.
-  const T* operator->() const ABSL_ATTRIBUTE_LIFETIME_BOUND;
-  T* operator->() ABSL_ATTRIBUTE_LIFETIME_BOUND;
+  using StatusOr::OperatorBase::operator->;
 
   // StatusOr<T>::value_or()
   //
@@ -536,10 +537,34 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
   //
   // Unlike with `value`, calling `std::move()` on the result of `value_or` will
   // still trigger a copy.
-  template <typename U>
-  T value_or(U&& default_value) const&;
-  template <typename U>
-  T value_or(U&& default_value) &&;
+  template <
+      typename U,
+      std::enable_if_t<internal_statusor::IsValueOrValid<T, U&&, false>::value,
+                       int> = 0>
+  T value_or(U&& default_value) const& {
+    return this->ValueOrImpl(std::forward<U>(default_value));
+  }
+  template <
+      typename U,
+      std::enable_if_t<internal_statusor::IsValueOrValid<T, U&&, false>::value,
+                       int> = 0>
+  T value_or(U&& default_value) && {
+    return std::move(*this).ValueOrImpl(std::forward<U>(default_value));
+  }
+  template <
+      typename U,
+      std::enable_if_t<internal_statusor::IsValueOrValid<T, U&&, true>::value,
+                       int> = 0>
+  T value_or(U&& default_value ABSL_ATTRIBUTE_LIFETIME_BOUND) const& {
+    return this->ValueOrImpl(std::forward<U>(default_value));
+  }
+  template <
+      typename U,
+      std::enable_if_t<internal_statusor::IsValueOrValid<T, U&&, true>::value,
+                       int> = 0>
+  T value_or(U&& default_value ABSL_ATTRIBUTE_LIFETIME_BOUND) && {
+    return std::move(*this).ValueOrImpl(std::forward<U>(default_value));
+  }
 
   // StatusOr<T>::IgnoreError()
   //
@@ -607,7 +632,9 @@ class StatusOr : private internal_statusor::StatusOrData<T>,
 // operator==()
 //
 // This operator checks the equality of two `absl::StatusOr<T>` objects.
-template <typename T>
+template <typename T,
+          std::enable_if_t<internal_statusor::IsEqualityComparable<T>::value,
+                           int> = 0>
 bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
   if (lhs.ok() && rhs.ok()) return *lhs == *rhs;
   return lhs.status() == rhs.status();
@@ -616,7 +643,9 @@ bool operator==(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
 // operator!=()
 //
 // This operator checks the inequality of two `absl::StatusOr<T>` objects.
-template <typename T>
+template <typename T,
+          std::enable_if_t<internal_statusor::IsEqualityComparable<T>::value,
+                           int> = 0>
 bool operator!=(const StatusOr<T>& lhs, const StatusOr<T>& rhs) {
   return !(lhs == rhs);
 }
@@ -703,88 +732,6 @@ Status StatusOr<T>::status() && {
   return ok() ? OkStatus() : std::move(this->status_);
 }
 
-template <typename T>
-const T& StatusOr<T>::value() const& {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::value() & {
-  if (!this->ok()) internal_statusor::ThrowBadStatusOrAccess(this->status_);
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::value() const&& {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::value() && {
-  if (!this->ok()) {
-    internal_statusor::ThrowBadStatusOrAccess(std::move(this->status_));
-  }
-  return std::move(this->data_);
-}
-
-template <typename T>
-const T& StatusOr<T>::operator*() const& {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-T& StatusOr<T>::operator*() & {
-  this->EnsureOk();
-  return this->data_;
-}
-
-template <typename T>
-const T&& StatusOr<T>::operator*() const&& {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-T&& StatusOr<T>::operator*() && {
-  this->EnsureOk();
-  return std::move(this->data_);
-}
-
-template <typename T>
-absl::Nonnull<const T*> StatusOr<T>::operator->() const {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-absl::Nonnull<T*> StatusOr<T>::operator->() {
-  this->EnsureOk();
-  return &this->data_;
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) const& {
-  if (ok()) {
-    return this->data_;
-  }
-  return std::forward<U>(default_value);
-}
-
-template <typename T>
-template <typename U>
-T StatusOr<T>::value_or(U&& default_value) && {
-  if (ok()) {
-    return std::move(this->data_);
-  }
-  return std::forward<U>(default_value);
-}
-
 template <typename T>
 void StatusOr<T>::IgnoreError() const {
   // no-op

package/vendor/abseil-cpp/absl/status/statusor_benchmark.cc

@@ -0,0 +1,480 @@
+// Copyright 2025 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string>
+
+#include "absl/status/status.h"
+#include "absl/status/statusor.h"
+#include "benchmark/benchmark.h"
+
+namespace {
+
+void BM_StatusOrInt_CtorStatus(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(absl::CancelledError());
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CtorStatus);
+
+void BM_StatusOrInt_CtorStatusWithMessage(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CtorStatusWithMessage);
+
+void BM_StatusOrInt_CopyCtor_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CopyCtor_Error);
+
+void BM_StatusOrInt_CopyCtor_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(42);
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CopyCtor_Ok);
+
+void BM_StatusOrInt_MoveCtor_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_MoveCtor_Error);
+
+void BM_StatusOrInt_MoveCtor_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(42);
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_MoveCtor_Ok);
+
+void BM_StatusOrInt_CopyAssign_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CopyAssign_Error);
+
+void BM_StatusOrInt_CopyAssign_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(42);
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_CopyAssign_Ok);
+
+void BM_StatusOrInt_MoveAssign_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_MoveAssign_Error);
+
+void BM_StatusOrInt_MoveAssign_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> original(42);
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrInt_MoveAssign_Ok);
+
+void BM_StatusOrInt_OkMethod_Error(benchmark::State& state) {
+  absl::StatusOr<int> status(
+      absl::UnknownError("This string is 28 characters"));
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.ok());
+  }
+}
+BENCHMARK(BM_StatusOrInt_OkMethod_Error);
+
+void BM_StatusOrInt_OkMethod_Ok(benchmark::State& state) {
+  absl::StatusOr<int> status(42);
+  for (auto _ : state) {
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.ok());
+  }
+}
+BENCHMARK(BM_StatusOrInt_OkMethod_Ok);
+
+void BM_StatusOrInt_StatusMethod_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.status().ok());
+  }
+}
+BENCHMARK(BM_StatusOrInt_StatusMethod_Error);
+
+void BM_StatusOrInt_StatusMethod_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(std::move(status).status().ok());
+  }
+}
+BENCHMARK(BM_StatusOrInt_StatusMethod_Ok);
+
+void BM_StatusOrInt_StatusMethodRvalue_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(std::move(status).status().ok());
+  }
+}
+BENCHMARK(BM_StatusOrInt_StatusMethodRvalue_Error);
+
+void BM_StatusOrInt_StatusMethodRvalue_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<int> status(42);
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(std::move(status).status());
+  }
+}
+BENCHMARK(BM_StatusOrInt_StatusMethodRvalue_Ok);
+
+void BM_StatusOrString_CtorStatus(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status(absl::CancelledError());
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CtorStatus);
+
+void BM_StatusOrString_CtorStatusWithMessage(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CtorStatusWithMessage);
+
+void BM_StatusOrString_CopyCtor_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status(original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CopyCtor_Error);
+
+void BM_StatusOrString_CopyCtor_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original("This string is 28 characters");
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status(original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CopyCtor_Ok);
+
+void BM_StatusOrString_MoveCtor_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status(std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_MoveCtor_Error);
+
+void BM_StatusOrString_MoveCtor_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original("This string is 28 characters");
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status(std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_MoveCtor_Ok);
+
+void BM_StatusOrString_CopyAssign_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CopyAssign_Error);
+
+void BM_StatusOrString_CopyAssign_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original("This string is 28 characters");
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = original);
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_CopyAssign_Ok);
+
+void BM_StatusOrString_MoveAssign_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_MoveAssign_Error);
+
+void BM_StatusOrString_MoveAssign_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> original("This string is 28 characters");
+    benchmark::DoNotOptimize(original);
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status = std::move(original));
+    benchmark::DoNotOptimize(status);
+  }
+}
+BENCHMARK(BM_StatusOrString_MoveAssign_Ok);
+
+void BM_StatusOrString_OkMethod_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.ok());
+  }
+}
+BENCHMARK(BM_StatusOrString_OkMethod_Error);
+
+void BM_StatusOrString_OkMethod_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.ok());
+  }
+}
+BENCHMARK(BM_StatusOrString_OkMethod_Ok);
+
+void BM_StatusOrString_StatusMethod_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.status().ok());
+  }
+}
+BENCHMARK(BM_StatusOrString_StatusMethod_Error);
+
+void BM_StatusOrString_StatusMethod_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(status.status().ok());
+  }
+}
+BENCHMARK(BM_StatusOrString_StatusMethod_Ok);
+
+void BM_StatusOrString_StatusMethodRvalue_Error(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status(
+        absl::UnknownError("This string is 28 characters"));
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(std::move(status).status());
+  }
+}
+BENCHMARK(BM_StatusOrString_StatusMethodRvalue_Error);
+
+void BM_StatusOrString_StatusMethodRvalue_Ok(benchmark::State& state) {
+  for (auto _ : state) {
+    absl::StatusOr<std::string> status("This string is 28 characters");
+    benchmark::DoNotOptimize(status);
+    benchmark::DoNotOptimize(std::move(status).status());
+  }
+}
+BENCHMARK(BM_StatusOrString_StatusMethodRvalue_Ok);
+
+// Benchmarks comparing a few alternative ways of structuring an interface
+// for returning an int64 on success or an error.  See (a), (b), (c), (d)
+// below for the variants.
+bool bm_cond = true;
+
+bool SimpleIntInterface(int64_t* v) ABSL_ATTRIBUTE_NOINLINE;
+bool SimpleIntInterfaceWithErrorMessage(int64_t* v, std::string* msg)
+    ABSL_ATTRIBUTE_NOINLINE;
+absl::Status SimpleIntInterfaceWithErrorStatus(int64_t* v)
+    ABSL_ATTRIBUTE_NOINLINE;
+absl::StatusOr<int64_t> SimpleIntStatusOrInterface() ABSL_ATTRIBUTE_NOINLINE;
+
+// (a): Just a boolean return value with an out int64* parameter
+bool SimpleIntInterface(int64_t* v) {
+  benchmark::DoNotOptimize(bm_cond);
+  if (bm_cond) {
+    *v = 42;
+    return true;
+  } else {
+    return false;
+  }
+}
+
+// (b): A boolean return value and a string error message filled in on failure
+// and an out int64* parameter filled on success
+bool SimpleIntInterfaceWithErrorMessage(int64_t* v, std::string* msg) {
+  benchmark::DoNotOptimize(bm_cond);
+  if (bm_cond) {
+    *v = 42;
+    return true;
+  } else {
+    *msg = "This is an error message";
+    return false;
+  }
+}
+
+// (c): A Status return value with an out int64* parameter on success
+absl::Status SimpleIntInterfaceWithErrorStatus(int64_t* v) {
+  benchmark::DoNotOptimize(bm_cond);
+  if (bm_cond) {
+    *v = 42;
+    return absl::OkStatus();
+  } else {
+    return absl::UnknownError("This is an error message");
+  }
+}
+
+// (d): A StatusOr<int64> return value
+absl::StatusOr<int64_t> SimpleIntStatusOrInterface() {
+  benchmark::DoNotOptimize(bm_cond);
+  if (bm_cond) {
+    return 42;
+  } else {
+    return absl::StatusOr<int64_t>(
+        absl::UnknownError("This is an error message"));
+  }
+}
+
+void SetCondition(benchmark::State& state) {
+  bm_cond = (state.range(0) == 0);
+  state.SetLabel(bm_cond ? "Success" : "Failure");
+}
+
+void BM_SimpleIntInterface(benchmark::State& state) {
+  SetCondition(state);
+  int64_t sum = 0;
+  for (auto s : state) {
+    int64_t v;
+    if (SimpleIntInterface(&v)) {
+      sum += v;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+
+void BM_SimpleIntInterfaceMsg(benchmark::State& state) {
+  SetCondition(state);
+  int64_t sum = 0;
+  std::string msg;
+  for (auto s : state) {
+    int64_t v;
+    if (SimpleIntInterfaceWithErrorMessage(&v, &msg)) {
+      sum += v;
+    }
+    benchmark::DoNotOptimize(sum);
+    benchmark::DoNotOptimize(msg);
+  }
+}
+
+void BM_SimpleIntInterfaceStatus(benchmark::State& state) {
+  SetCondition(state);
+  int64_t sum = 0;
+  for (auto s : state) {
+    int64_t v;
+    auto result = SimpleIntInterfaceWithErrorStatus(&v);
+    if (result.ok()) {
+      sum += v;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+
+void BM_SimpleIntStatusOrInterface(benchmark::State& state) {
+  SetCondition(state);
+  int64_t sum = 0;
+  for (auto s : state) {
+    auto v_s = SimpleIntStatusOrInterface();
+    if (v_s.ok()) {
+      sum += *v_s;
+    }
+    benchmark::DoNotOptimize(sum);
+  }
+}
+
+// Ordered like this so all the success path benchmarks (Arg(0)) show up,
+// then all the failure benchmarks (Arg(1))
+BENCHMARK(BM_SimpleIntInterface)->Arg(0);
+BENCHMARK(BM_SimpleIntInterfaceMsg)->Arg(0);
+BENCHMARK(BM_SimpleIntInterfaceStatus)->Arg(0);
+BENCHMARK(BM_SimpleIntStatusOrInterface)->Arg(0);
+BENCHMARK(BM_SimpleIntInterface)->Arg(1);
+BENCHMARK(BM_SimpleIntInterfaceMsg)->Arg(1);
+BENCHMARK(BM_SimpleIntInterfaceStatus)->Arg(1);
+BENCHMARK(BM_SimpleIntStatusOrInterface)->Arg(1);
+
+}  // namespace