error.h

Go to the documentation of this file.

// Copyright (c) 2023 anabrid GmbH
// Contact: https://www.anabrid.com/licensing/
// SPDX-License-Identifier: MIT OR GPL-2.0-or-later
 
#pragma once
 
#include "utils/logging.h"
#include <Arduino.h>
#include <cstdarg>
#include <string>
 
#define RETURN_IF_FAILED(status) \
    { auto _status = (status); if (!_status.is_ok()) return _status; }
 
namespace utils {
constexpr unsigned int bufsize = 1000;
 
// extern char buf[bufsize];
 
template <typename... Args> FLASHMEM std::string small_sprintf(const char *format, Args... args) {
  char buf[bufsize];
  snprintf(buf, bufsize, format, args...);
  std::string ret = buf;
  return ret;
}
 
class status {
public:
  int code;        
  std::string msg; 
 
  status(int code, std::string msg) : code(code), msg(msg) {
    if (code != 0) {
      LOG4("utils::status error code=", code, " message=", msg.c_str());
      if (msg.length() == 0) {
        LOG_ALWAYS("Misuse of utils::status! Probably a casting problem.");
      }
    }
  }
 
  status() : status(0, "success") {}
 
  explicit status(int code) : status(code, "No error message provided") {}
 
  explicit status(bool code) : status(code ? 0 : 1) {}
 
  explicit status(std::string msg) : status(-1, msg) {}
 
  // This constructor is neccessary to distinguish it from the status(*format, ...) constructor.
  explicit status(const char *msg) : status(-2, msg) {}
 
  template <typename... Args>
  status(const char *format, Args... args) : status(small_sprintf(format, args...)) {}
 
  template <typename... Args>
  status(int code, const char *format, Args... args) : status(code, small_sprintf(format, args...)) {}
 
  status &attach(const status &other, const char *description = "") {
    if (!other.is_ok() || !is_ok()) {
      code += other.code * 128;
      msg += other.msg + description;
    }
    return *this; // chainable
  }
 
  status &attach_to(status &other, const char *description = "") {
    other.attach(*this, description);
    return *this;
  }
 
  status &attach(int _code, const char *_msg) {
    code += _code * 128;
    msg += _msg;
    return *this;
  }
 
  status &attach(const char *_msg) {
    msg += _msg;
    return *this;
  }
 
  bool is_ok() const { return code == 0; }
 
  operator bool() const { return is_ok(); }
 
  static status success() { return status(0); }
 
  static status failure() { return status(-1); }
};
} // namespace utils