CCSDSResult.h

Go to the documentation of this file.

#ifndef CCSDS_RESULT_H
#define CCSDS_RESULT_H
 
#include <variant>
#include <vector>
#include <cstdint>
 
//exclude includes when building for MCU
#ifndef CCSDS_MCU
  #include <iostream>
#else
  #include <string>
#endif //CCSDS_MCU
 
namespace CCSDS {
  enum ErrorCode : std::uint8_t {
    NONE = 0,                           
    UNKNOWN_ERROR = 1,                  
    NO_DATA = 2,                        
    INVALID_DATA = 3,                   
    INVALID_HEADER_DATA = 4,            
    INVALID_SECONDARY_HEADER_DATA = 5,  
    INVALID_APPLICATION_DATA = 6,       
    NULL_POINTER = 7,                   
    INVALID_CHECKSUM = 8,               
    VALIDATION_FAILURE = 9,             
    TEMPLATE_SET_FAILURE = 10,          
    FILE_READ_ERROR = 11,               
    FILE_WRITE_ERROR = 12,              
    CONFIG_FILE_ERROR = 13              
  };
 
  class Error {
  public:
    Error(const ErrorCode code, std::string message)
      : m_code(code), m_message(std::move(message)) {
    }
 
    [[nodiscard]] ErrorCode code() const { return m_code; }
 
    [[nodiscard]] const std::string &message() const { return m_message; }
 
  private:
    ErrorCode m_code; 
    std::string m_message; 
  };
 
  template<typename T>
  class Result {
    std::variant<T, Error> data; 
 
  public:
    Result(T value) : data(std::move(value)) {
    }
 
    Result(Error error) : data(error) {
    }
 
    [[nodiscard]] bool has_value() const {
      return std::holds_alternative<T>(data);
    }
 
    T &value() { return std::get<T>(data); }
    const T &value() const { return std::get<T>(data); }
 
    [[nodiscard]] Error error() const {
      return std::get<Error>(data);
    }
 
    explicit operator bool() const { return has_value(); }
  };
 
  // Convenient type aliases for common result types
  using ResultBool = Result<bool>;
  using ResultBuffer = Result<std::vector<std::uint8_t> >;
}
 
/* ERROR MANAGEMENT MACROS */
 
#define RETURN_IF_ERROR(condition, errorCode)            \
do { if (condition) return errorCode; } while (0)
 
#define RET_IF_ERR_MSG(condition, errorCode, message)    \
do {                                                     \
    if (condition) {                                     \
        return CCSDS::Error{errorCode,message};          \
    }                                                    \
} while (0)
 
#define ASSIGN_MV(var, result)                 \
do {                                           \
    auto&& _res = (result);                    \
    if (!_res) return _res.error();            \
    var = std::move(_res.value());             \
} while (0)
 
#define ASSIGN_CP(var, result)                 \
do {                                           \
auto&& _res = (result);                        \
if (!_res) return _res.error();                \
var = _res.value();                            \
} while (0)
 
 
#define ASSIGN_OR_PRINT(var, result)           \
do {                                           \
    auto&& _res = (result);                    \
    if (!_res) {                               \
        printf("[ Error ]: Code [%u]: %s\n", static_cast<unsigned>(_res.error().code()), _res.error().message().c_str());; \
    } else {                                   \
        var = std::move(_res.value());         \
    }                                          \
} while (0)
 
#define ASSERT_SUCCESS(result)                 \
do {                                           \
    auto&& _res = (result);                    \
    if (!_res.has_value()) return;             \
} while (0)
 
#define FORWARD_RESULT(result)                 \
do {                                           \
    auto&& _res = (result);                    \
    if (!_res.has_value()) return _res;        \
} while (0)
 
#endif // CCSDS_RESULT_H