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.
 */
 
#pragma once
 
#include <optional>
#include <stdexcept>
#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 hasError() const noexcept { return !ok(); }
  explicit operator bool() const noexcept { return ok(); }
 
  T& value() & {
    if (!ok()) {
      throw std::logic_error("Result::value() called on an error result");
    }
    return std::get<0>(storage_);
  }
 
  const T& value() const& {
    if (!ok()) {
      throw std::logic_error("Result::value() called on an error result");
    }
    return std::get<0>(storage_);
  }
 
  T&& value() && {
    if (!ok()) {
      throw std::logic_error("Result::value() called on an error result");
    }
    return std::get<0>(std::move(storage_));
  }
 
  const T&& value() const&& {
    if (!ok()) {
      throw std::logic_error("Result::value() called on an error result");
    }
    return std::get<0>(std::move(storage_));
  }
 
  E& error() & {
    if (!hasError()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return std::get<1>(storage_);
  }
 
  const E& error() const& {
    if (!hasError()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return std::get<1>(storage_);
  }
 
  E&& error() && {
    if (!hasError()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return std::get<1>(std::move(storage_));
  }
 
  const E&& error() const&& {
    if (!hasError()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    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 hasError() const noexcept { return error_.has_value(); }
  explicit operator bool() const noexcept { return ok(); }
 
  void value() const {
    if (!ok()) {
      throw std::logic_error("Result::value() called on an error result");
    }
  }
 
  E& error() & {
    if (!error_.has_value()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return *error_;
  }
 
  const E& error() const& {
    if (!error_.has_value()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return *error_;
  }
 
  E&& error() && {
    if (!error_.has_value()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return std::move(*error_);
  }
 
  const E&& error() const&& {
    if (!error_.has_value()) {
      throw std::logic_error("Result::error() called on a success result");
    }
    return std::move(*error_);
  }
 
private:
  explicit Result(std::optional<E> error) : error_(std::move(error)) {}
 
  std::optional<E> error_;
};
 
} // namespace livekit