exception.hpp

Go to the documentation of this file.

/*
 *  SatNOGS-COMMS control library
 *
 *  Copyright (C) 2021-2024, Libre Space Foundation <http://libre.space>
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *  SPDX-License-Identifier: GNU General Public License v3.0 or later
 */
 
#pragma once
 
#include <cstdint>
#include <etl/error_handler.h>
#include <etl/string_stream.h>
#include <satnogs-comms-lib/errno_extended.hpp>
 
namespace satnogs::comms::lib
{

class exception : public std::exception, public etl::exception
{
public:
  enum class severity : uint8_t
  {
    CATASTROPHIC = 0, 
    CRITICAL = 1, 
    MAJOR    = 2, 
    MINOR    = 3, 
    NONE     = 4  
  };

  class error_msg
  {
  public:
    const char *verbose; 
    const char *terse;   
    int32_t error_num;   
  };

  exception(severity sev, const char *file, int lineno,
            const error_msg &err_msg)
      : std::exception(),
        etl::exception(ETL_ERROR_TEXT(err_msg.verbose, err_msg.terse), file,
                       lineno),
        m_severity(sev),
        m_errno(err_msg.error_num)
  {
  }

  void
  to_string(etl::string_stream &stream) const
  {
    stream << etl::exception::what() << " | File: " << file_name() << ":"
           << line_number()
           << " | Severity: " << static_cast<int32_t>(m_severity)
           << " | Error: " << m_errno;
  }

  void
  to_string(etl::istring &s) const
  {
    etl::string_stream stream(s);
    to_string(stream);
  }
 
  const char *
  what() const noexcept override
  {
    return etl::exception::what();
  }
 
  int32_t
  get_errno() const
  {
    return m_errno;
  }

  severity
  get_severity() const
  {
    return m_severity;
  }
 
private:
  const severity m_severity;
  const int32_t  m_errno;
};

class inval_arg_exception : public exception
{
public:
  inval_arg_exception(severity sev, const char *file_name, int line)
      : exception(sev, file_name, line,
                  error_msg{"Invalid argument", "invalarg", EINVAL})
  {
  }

  inval_arg_exception(const char *file_name, int line)
      : exception(severity::MINOR, file_name, line,
                  error_msg{"Invalid argument", "invalarg", EINVAL})
  {
  }
};

class msg_too_long_exception : public exception
{
public:
  msg_too_long_exception(const char *file_name, int line)
      : exception(exception::severity::MINOR, file_name, line,
                  error_msg{"Message too long", "msgbadsize", EMSGSIZE})
  {
  }
};

class resource_unavailable_exception : public exception
{
public:
  resource_unavailable_exception(const char *file_name, int line)
      : exception(
            exception::severity::MINOR, file_name, line,
            error_msg{"The resource you are trying to access is currently "
                      "unavailable",
                      "eagain", EAGAIN})
  {
  }
};

class timeout_exception : public exception
{
public:
  timeout_exception(const char *file_name, int line)
      : exception(exception::severity::MINOR, file_name, line,
                  error_msg{"Timeout occurred", "timeout", ETIMEDOUT})
  {
  }
};

 
} /* namespace satnogs::comms::lib */