tmc51x0_result.hpp

Go to the documentation of this file.

 
#pragma once
#include <cstddef>
#include <cstdint>
#include <tuple>
#include <type_traits>
#include <utility>
 
namespace tmc51x0 {
 
enum class ErrorCode : uint8_t {
  OK = 0,            
  NOT_INITIALIZED,   
  COMM_ERROR,        
  INVALID_VALUE,     
  INVALID_STATE,     
  TIMEOUT,           
  CANCELLED,         
  HARDWARE_ERROR,    
  SHORT_CIRCUIT,     
  OPEN_LOAD,         
  OVERTEMP_WARNING,  
  OVERTEMP_SHUTDOWN, 
  UNSUPPORTED        
};
 
#ifndef TMC51X0_NO_ERROR_STRINGS
inline const char *ErrorMessage(ErrorCode code) {
  switch (code) {
  case ErrorCode::OK:
    return "OK";
  case ErrorCode::NOT_INITIALIZED:
    return "Driver not initialized";
  case ErrorCode::COMM_ERROR:
    return "Communication error";
  case ErrorCode::INVALID_VALUE:
    return "Invalid parameter value";
  case ErrorCode::INVALID_STATE:
    return "Invalid state for operation";
  case ErrorCode::TIMEOUT:
    return "Operation timed out";
  case ErrorCode::CANCELLED:
    return "Operation cancelled";
  case ErrorCode::HARDWARE_ERROR:
    return "Hardware fault detected";
  case ErrorCode::SHORT_CIRCUIT:
    return "Short circuit detected";
  case ErrorCode::OPEN_LOAD:
    return "Open load detected";
  case ErrorCode::OVERTEMP_WARNING:
    return "Overtemperature warning";
  case ErrorCode::OVERTEMP_SHUTDOWN:
    return "Overtemperature shutdown";
  case ErrorCode::UNSUPPORTED:
    return "Feature not supported";
  default:
    return "Unknown error";
  }
}
#endif
 
template <typename T> class Result {
private:
  ErrorCode error_;
  T value_;
 
public:
  explicit Result(T &&value) noexcept
      : error_(ErrorCode::OK), value_(std::move(value)) {}
 
  explicit Result(const T &value) noexcept
      : error_(ErrorCode::OK), value_(value) {}
 
  explicit Result(ErrorCode error) noexcept : error_(error), value_{} {}
 
  [[nodiscard]] explicit operator bool() const noexcept {
    return error_ == ErrorCode::OK;
  }
 
  [[nodiscard]] bool IsOk() const noexcept { return error_ == ErrorCode::OK; }
 
  [[nodiscard]] bool IsErr() const noexcept { return error_ != ErrorCode::OK; }
 
  [[nodiscard]] ErrorCode Error() const noexcept { return error_; }
 
#ifndef TMC51X0_NO_ERROR_STRINGS
  [[nodiscard]] const char *ErrorMessage() const noexcept {
    return tmc51x0::ErrorMessage(error_);
  }
#endif
 
  [[nodiscard]] T &Value() noexcept { return value_; }
 
  [[nodiscard]] const T &Value() const noexcept { return value_; }
 
  [[nodiscard]] T ValueOr(const T &default_value) const noexcept {
    return IsOk() ? value_ : default_value;
  }
 
  template <std::size_t N>
  std::enable_if_t<N == 0, ErrorCode> get() const & noexcept {
    return error_;
  }
 
  template <std::size_t N>
  std::enable_if_t<N == 1, const T &> get() const & noexcept {
    return value_;
  }
 
  template <std::size_t N>
  std::enable_if_t<N == 0, ErrorCode> get() & noexcept {
    return error_;
  }
 
  template <std::size_t N> std::enable_if_t<N == 1, T &> get() & noexcept {
    return value_;
  }
 
  template <std::size_t N>
  std::enable_if_t<N == 0, ErrorCode> get() && noexcept {
    return error_;
  }
 
  template <std::size_t N> std::enable_if_t<N == 1, T &&> get() && noexcept {
    return std::move(value_);
  }
};
 
template <> class Result<void> {
private:
  ErrorCode error_;
 
public:
  Result() noexcept : error_(ErrorCode::OK) {}
 
  explicit Result(ErrorCode error) noexcept : error_(error) {}
 
  [[nodiscard]] explicit operator bool() const noexcept {
    return error_ == ErrorCode::OK;
  }
 
  [[nodiscard]] bool IsOk() const noexcept { return error_ == ErrorCode::OK; }
 
  [[nodiscard]] bool IsErr() const noexcept { return error_ != ErrorCode::OK; }
 
  [[nodiscard]] ErrorCode Error() const noexcept { return error_; }
 
#ifndef TMC51X0_NO_ERROR_STRINGS
  [[nodiscard]] const char *ErrorMessage() const noexcept {
    return tmc51x0::ErrorMessage(error_);
  }
#endif
};
 
// Type alias for Result<void> to allow Result<> syntax
using ResultVoid = Result<void>;
 
template <std::size_t N, typename T>
decltype(auto) get(Result<T> &r) noexcept {
  return r.template get<N>();
}
 
template <std::size_t N, typename T>
decltype(auto) get(const Result<T> &r) noexcept {
  return r.template get<N>();
}
 
template <std::size_t N, typename T>
decltype(auto) get(Result<T> &&r) noexcept {
  return std::move(r).template get<N>();
}
 
// Result<void> is tuple-like with a single element: the ErrorCode.
template <std::size_t N>
std::enable_if_t<N == 0, ErrorCode> get(Result<void> &r) noexcept {
  return r.Error();
}
 
template <std::size_t N>
std::enable_if_t<N == 0, ErrorCode> get(const Result<void> &r) noexcept {
  return r.Error();
}
 
template <std::size_t N>
std::enable_if_t<N == 0, ErrorCode> get(Result<void> &&r) noexcept {
  return r.Error();
}
 
} // namespace tmc51x0
 
// Support for structured bindings
namespace std {
template <typename T>
struct tuple_size<tmc51x0::Result<T>> : integral_constant<size_t, 2> {};
 
template <>
struct tuple_size<tmc51x0::Result<void>> : integral_constant<size_t, 1> {};
 
template <typename T> struct tuple_element<0, tmc51x0::Result<T>> {
  using type = tmc51x0::ErrorCode;
};
 
template <typename T> struct tuple_element<1, tmc51x0::Result<T>> {
  using type = T;
};
 
template <> struct tuple_element<0, tmc51x0::Result<void>> {
  using type = tmc51x0::ErrorCode;
};
} // namespace std