result.h

/*
 * Copyright 2026 LiveKit
 *
 * 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 LIVEKIT_RESULT_H
#define LIVEKIT_RESULT_H
 
#include <cassert>
#include <optional>
#include <type_traits>
#include <utility>
#include <variant>
 
namespace livekit {
 
template <typename T, typename E> class [[nodiscard]] Result {
public:
  template <typename U = T,
            typename = std::enable_if_t<std::is_constructible<T, U &&>::value>>
  static Result success(U &&value) {
    return Result(
        std::variant<T, E>(std::in_place_index<0>, std::forward<U>(value)));
  }
 
  template <typename F = E,
            typename = std::enable_if_t<std::is_constructible<E, F &&>::value>>
  static Result failure(F &&error) {
    return Result(
        std::variant<T, E>(std::in_place_index<1>, std::forward<F>(error)));
  }
 
  bool ok() const noexcept { return storage_.index() == 0; }
  bool has_error() const noexcept { return !ok(); }
  explicit operator bool() const noexcept { return ok(); }
 
  T &value() & noexcept {
    assert(ok());
    return std::get<0>(storage_);
  }
 
  const T &value() const & noexcept {
    assert(ok());
    return std::get<0>(storage_);
  }
 
  T &&value() && noexcept {
    assert(ok());
    return std::get<0>(std::move(storage_));
  }
 
  const T &&value() const && noexcept {
    assert(ok());
    return std::get<0>(std::move(storage_));
  }
 
  E &error() & noexcept {
    assert(has_error());
    return std::get<1>(storage_);
  }
 
  const E &error() const & noexcept {
    assert(has_error());
    return std::get<1>(storage_);
  }
 
  E &&error() && noexcept {
    assert(has_error());
    return std::get<1>(std::move(storage_));
  }
 
  const E &&error() const && noexcept {
    assert(has_error());
    return std::get<1>(std::move(storage_));
  }
 
private:
  explicit Result(std::variant<T, E> storage) : storage_(std::move(storage)) {}
 
  std::variant<T, E> storage_;
};
 
template <typename E> class [[nodiscard]] Result<void, E> {
public:
  static Result success() { return Result(std::nullopt); }
 
  template <typename F = E,
            typename = std::enable_if_t<std::is_constructible<E, F &&>::value>>
  static Result failure(F &&error) {
    return Result(std::optional<E>(std::forward<F>(error)));
  }
 
  bool ok() const noexcept { return !error_.has_value(); }
  bool has_error() const noexcept { return error_.has_value(); }
  explicit operator bool() const noexcept { return ok(); }
 
  void value() const noexcept { assert(ok()); }
 
  E &error() & noexcept {
    assert(has_error());
    return *error_;
  }
 
  const E &error() const & noexcept {
    assert(has_error());
    return *error_;
  }
 
  E &&error() && noexcept {
    assert(has_error());
    return std::move(*error_);
  }
 
  const E &&error() const && noexcept {
    assert(has_error());
    return std::move(*error_);
  }
 
private:
  explicit Result(std::optional<E> error) : error_(std::move(error)) {}
 
  std::optional<E> error_;
};
 
} // namespace livekit
 
#endif // LIVEKIT_RESULT_H