result.h

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <optional>
#include <string>
#include <system_error>
#include <variant>
 
namespace duvc {
 
enum class ErrorCode {
  Success = 0,          
  DeviceNotFound,       
  DeviceBusy,           
  PropertyNotSupported, 
  InvalidValue,         
  PermissionDenied,     
  SystemError,          
  InvalidArgument,      
  NotImplemented        
};
 
const char *to_string(ErrorCode code);
 
class Error {
public:
  Error(ErrorCode code, std::string message = "");
 
  Error(std::error_code code, std::string message = "");
 
  ErrorCode code() const { return code_; }
 
  const std::string &message() const { return message_; }
 
  std::string description() const;
 
private:
  ErrorCode code_;
  std::string message_;
};
 
template <typename T> class Result {
public:
  Result(T value) : data_(std::move(value)) {}
 
  Result(Error error) : data_(std::move(error)) {}
 
  Result(ErrorCode code, std::string message = "")
      : data_(Error(code, std::move(message))) {}
 
  bool is_ok() const { return std::holds_alternative<T>(data_); }
 
  bool is_error() const { return std::holds_alternative<Error>(data_); }
 
  const T &value() const & { return std::get<T>(data_); }
 
  T &&value() && { return std::get<T>(std::move(data_)); }
 
  const Error &error() const { return std::get<Error>(data_); }
 
  T value_or(const T &default_value) const & {
    return is_ok() ? value() : default_value;
  }
 
  T value_or(T &&default_value) && {
    return is_ok() ? std::move(*this).value() : std::move(default_value);
  }
 
  explicit operator bool() const { return is_ok(); }
 
private:
  std::variant<T, Error> data_;
};
 
template <> class Result<void> {
public:
  Result() : error_(std::nullopt) {}
 
  Result(Error error) : error_(std::move(error)) {}
 
  Result(ErrorCode code, std::string message = "")
      : error_(Error(code, std::move(message))) {}
 
  bool is_ok() const { return !error_.has_value(); }
 
  bool is_error() const { return error_.has_value(); }
 
  const Error &error() const { return *error_; }
 
  explicit operator bool() const { return is_ok(); }
 
private:
  std::optional<Error> error_;
};
 
template <typename T> Result<T> Ok(T value) {
  return Result<T>(std::move(value));
}
 
inline Result<void> Ok() { return Result<void>(); }
 
template <typename T> Result<T> Err(Error error) {
  return Result<T>(std::move(error));
}
 
template <typename T> Result<T> Err(ErrorCode code, std::string message = "") {
  return Result<T>(code, std::move(message));
}
 
} // namespace duvc