exception_guard.h

Go to the documentation of this file.

/*
 * Copyright 2026 The A11 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
 *
 *     http://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.
 */
 
#ifndef A11_EXCEPTION_GUARD_H_
#define A11_EXCEPTION_GUARD_H_
 
#include <exception>
#include <functional>
#include <string_view>
#include <utility>
 
#include <absl/functional/any_invocable.h>
#include <absl/status/status.h>
 
namespace a11::exception_guard {
 
namespace internal {
 
// / The status `what` raising `error` becomes. Shared so the wording is one
// thing.
absl::Status Raised(const std::exception& error, std::string_view what);
absl::Status RaisedUnknown(std::string_view what);
 
}  // namespace internal
 
template <typename Callable>
absl::Status Attempt([[maybe_unused]] Callable&& callable,
                     [[maybe_unused]] std::string_view what) {
#if defined(__cpp_exceptions) || defined(__EXCEPTIONS)
  try {
    std::forward<Callable>(callable)();
  } catch (const std::exception& error) {
    return internal::Raised(error, what);
  } catch (...) {
    return internal::RaisedUnknown(what);
  }
  return absl::OkStatus();
#else
  std::forward<Callable>(callable)();
  return absl::OkStatus();
#endif
}
 
template <typename Result, typename... Args>
std::function<Result(Args...)> Wrap(std::function<Result(Args...)> callable,
                                    std::string_view what);
 
template <typename Result, typename... Args>
absl::AnyInvocable<Result(Args...)> WrapOnce(
    absl::AnyInvocable<Result(Args...)> callable, std::string_view what);
 
template <typename Result, typename... Args>
absl::AnyInvocable<Result(Args...) &&> WrapConsuming(
    absl::AnyInvocable<Result(Args...) &&> callable, std::string_view what);
 
}  // namespace a11::exception_guard
 
#endif  // A11_EXCEPTION_GUARD_H_