errorcode.h

Go to the documentation of this file.

/*
  Copyright (c) Mircea Neacsu (2014-2025) Licensed under MIT License.
  This file is part of MLIB project. See LICENSE file for full license terms.
*/
 

#pragma once

 
#if __has_include("defs.h")
#include "defs.h"
#endif
 
#include <string>
 
#if (defined(_MSVC_LANG) && _MSVC_LANG < 201703L)                                                  \
  || (!defined(_MSVC_LANG) && (__cplusplus < 201703L))
#error "errorcode requires c++17"
#endif
 
namespace mlib {
 
class errfac;
 
class erc
{
public:
  enum level
  {
    none = 0, 
    info,     
    notice,   
    warning,  
    error,    
    critical, 
    alert,    
    emerg     
  };
  erc ();
  explicit erc (int value, level priority = level::error);
  explicit erc (int value, const mlib::errfac& facility, level priority = level::error);
  erc (const erc& other);
  erc (erc&& other);
 
  ~erc () noexcept (false);
  erc& operator= (const erc& rhs);
  erc& operator= (erc&& rhs);
  operator int () const;

  level priority () const;

  bool is_active () const;

  const errfac& facility () const;
 
  bool operator== (const erc& other) const;
  bool operator!= (const erc& other) const;
 
  void raise () const;
 
  void reactivate () const;
  void deactivate () const;
 
  int code () const;

  std::string message () const;
  void message (const std::string& m);
 
  static erc success;
 
private:
  // bit fields
  int value : 24;
  int priority_ : 4;
  mutable int active : 1;
 
  const errfac& facility_;
  std::string msg;
 
  friend class errfac;
};

 
class errfac
{
public:
  // constructors/destructor
  errfac (const std::string& name = "Error");

  void throw_priority (erc::level pri);

  erc::level throw_priority () const;

  void log_priority (erc::level pri);

  erc::level log_priority () const;

  virtual std::string message (const erc& e) const;

  const std::string& name () const;

  static void Default (errfac* f);

  static errfac& Default ();
 
  virtual void raise (const erc& e) const;
  virtual void log (const erc& e) const;
 
private:
  erc::level log_level;
  erc::level throw_level;
  std::string name_;
  static errfac* default_facility;
};
 
#if (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)                                                 \
  || (!defined(_MSVC_LANG) && (__cplusplus >= 202002L))
template <class T>
concept checkable = !std::is_convertible_v<T, int>;

template <checkable T>
class checked : public erc
{
public:
  checked ()
    : erc ()
    , obj ()
  {}

  checked (const T& obj_, const erc& err)
    : erc (err)
    , obj (obj_)
  {}

  checked (const T& obj_, int value = 0, erc::level pri_ = erc::level::error)
    : erc (value, pri_)
    , obj (obj_)
  {}
 
  checked (T&& obj_, erc&& err)
    : erc (std::move (err))
    , obj (std::move (obj_))
  {}
 
  checked (T&& obj_, const erc& err)
    : erc (err)
    , obj (std::move (obj_))
  {}

  checked (const checked<T>& other)
    : erc (other)
    , obj (other.obj)
  {}

  checked (checked<T>&& other)
    : erc (other)
    , obj (other.obj)
  {}
 
  ~checked () noexcept (false) = default;

  checked<T>& operator= (const checked<T>& rhs)
  {
    if (&rhs != this)
    {
      erc::operator= (rhs);
      obj = rhs.obj;
    }
    return *this;
  }

  checked<T>& operator= (checked<T>&& rhs)
  {
    if (&rhs != this)
    {
      *(erc*)this = std::move (rhs);
      obj = std::move (rhs.obj);
    }
    return *this;
  }

  checked<T>& operator= (const erc& rhs)
  {
    erc::operator= (rhs);
    return *this;
  }

  T& operator* ()
  {
    if (code () && priority ())
    {
      reactivate ();
      raise ();
    }
    return obj;
  }
 
  const T& operator* () const
  {
    if (code () && priority ())
    {
      reactivate ();
      raise ();
    }
    return obj;
  }
 
  T* operator->()
  {
    if (code () && priority ())
    {
      reactivate ();
      raise ();
    }
    return &obj;
  }
  const T* operator->() const
  {
    if (code () && priority ())
    {
      reactivate ();
      raise ();
    }
    return &obj;
  }

 
protected:
  T obj;
};
#endif
 
//-----------------------  errfac inlines -------------------------------------

inline errfac deffac;

inline errfac* errfac::default_facility = &deffac;


inline errfac::errfac (const std::string& name)
  : throw_level (erc::level::error)
  , log_level (erc::level::warning)
  , name_ (name)
{}
 
inline void errfac::throw_priority (erc::level pri)
{
  throw_level = (pri < erc::info) ? erc::info : (pri > erc::emerg) ? erc::emerg : pri;
}
 
inline erc::level errfac::throw_priority () const
{
  return throw_level;
}
 
inline void errfac::log_priority (erc::level pri)
{
  log_level = (pri < erc::info) ? erc::info : (pri > erc::emerg) ? erc::emerg : pri;
}
 
inline erc::level errfac::log_priority () const
{
  return log_level;
}
 
inline const std::string& errfac::name () const
{
  return name_;
}

inline std::string errfac::message (const erc& e) const
{
  return std::string ("error ") + std::to_string (e.value);
}
 
inline errfac& errfac::Default ()
{
  return *default_facility;
}

inline void errfac::Default (errfac* facility)
{
  default_facility = facility ? facility : &deffac;
}

inline void errfac::raise (const erc& e) const
{
  if (e.priority_ >= log_level)
    log (e);
  if (e.priority_ >= throw_level)
  {
    // Make sure this erc is not thrown again
    e.active = 0;
    throw e;
  }
}

inline void errfac::log (const erc& e) const
{
  fprintf (stderr, "%s - %s\n", name ().c_str (), e.message ().c_str ());
}
 
//--------------------------- erc inlines -------------------------------------


inline erc::erc ()
  : value{0}
  , priority_{none}
  , active{false}
  , facility_{errfac::Default ()}
{}

inline erc::erc (int v, level l)
  : value{v}
  , priority_{(unsigned short)l}
  , facility_{errfac::Default ()}
  , active{true}
{}

inline erc::erc (int v, const mlib::errfac& f, level l)
  : value{v}
  , priority_{(unsigned short)l}
  , facility_{f}
  , active{true}
{}

inline erc::erc (const erc& other)
  : value{other.value}
  , priority_{other.priority_}
  , active{other.active}
  , facility_{other.facility_}
  , msg{other.msg}
{
  // we are the active error now, the other is deactivated
  other.active = 0;
}

inline erc::erc (erc&& other)
  : value{other.value}
  , priority_{other.priority_}
  , active{other.active}
  , facility_{other.facility_}
  , msg{other.msg}
{
  // we are the active error now, the other is deactivated
  other.active = 0;
}

inline erc::~erc () noexcept (false)
{
  raise ();
}

inline erc& erc::operator= (const erc& rhs)
{
  if (&rhs != this)
  {
    int rhs_active = rhs.active;
    rhs.active = 0; // prevent rhs from throwing if we throw
    if (active && priority_)
      facility_.raise (*this);
    value = rhs.value;
    priority_ = rhs.priority_;
    const_cast<errfac&> (facility_) = rhs.facility_;
    msg = rhs.msg;
    active = rhs_active;
  }
  return *this;
}

inline erc& erc::operator= (erc&& rhs)
{
  if (&rhs != this)
  {
    bool rhs_active = rhs.active;
    rhs.active = 0; // prevent rhs from throwing if we throw
    if (active && value && priority_)
      facility_.raise (*this);
    value = rhs.value;
    priority_ = rhs.priority_;
    const_cast<errfac&>(facility_) = rhs.facility_;
    msg = rhs.msg;
    active = rhs_active;
  }
  return *this;
}
 
inline erc::level erc::priority () const
{
  return (erc::level)priority_;
}
 
inline bool erc::is_active () const
{
  return active;
}
 
inline const errfac& erc::facility () const
{
  return facility_;
}

inline bool erc::operator== (const erc& other) const
{
  active = false;
  const_cast<erc&> (other).active = false;
  if ((!priority_ || !value) && (!other.priority_ || !other.value))
    return true; // success values are the same
  if (&facility_ == &other.facility_ && priority_ == other.priority_ && value == other.value)
    return true;
 
  return false;
}

inline bool erc::operator!= (const erc& other) const
{
  return !operator== (other);
}

inline void erc::raise () const
{
  if (value && active && priority_)
    facility_.raise (*this);
  }

inline int erc::code () const
{
  return value;
}

inline std::string erc::message () const
{
  return msg.empty () ? facility_.message (*this) : msg;
}

inline void erc::message (const std::string& m)
{
  msg = m;
}

inline erc::operator int () const
{
  active = 0;
  return value;
}

inline void erc::reactivate () const
{
  active = 1;
}

inline void erc::deactivate () const
{
  active = 0;
}

inline erc erc::success{0, erc::none};
 
} // namespace mlib