exception.hpp

Go to the documentation of this file.

#ifndef LIBJMMCG_CORE_EXCEPTION_HPP
#define LIBJMMCG_CORE_EXCEPTION_HPP
 
/******************************************************************************
** Copyright © 2002 by J.M.McGuiness, coder@hussar.me.uk
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License as published by the Free Software Foundation; either
** version 2.1 of the License, or (at your option) any later version.
**
** This library 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
** Lesser General Public License for more details.
**
** You should have received a copy of the GNU Lesser General Public
** License along with this library; if not, write to the Free Software
** Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
 
#include "exit_codes.hpp"
#include "info.hpp"
#include "thread_params_traits.hpp"
 
#ifdef WIN32
#  include "thread_api_traits.hpp"
#endif
 
#include <boost/iostreams/stream.hpp>
 
#include <array>
#include <cerrno>
#include <stdexcept>
#include <cstring>
 
#ifdef __GCC__
#  pragma GCC diagnostic push
#  pragma GCC diagnostic ignored "-Wsuggest-final-methods"
#endif
 
namespace jmmcg { namespace LIBJMMCG_VER_NAMESPACE {
 
   namespace ppd {
      template<generic_traits::api_type API, typename Mdl>
      struct api_threading_traits;
   }
 
/// Handy for use in source files.
#define JMMCG_MAKE_EXCPT_SRC1(_JMMCG_EXCPT_MSG) jmmcg::LIBJMMCG_VER_NAMESPACE::exception((_JMMCG_EXCPT_MSG), JMMCG_FUNCTION(void), __REV_INFO__)
/// Handy for use in header files.
#define JMMCG_MAKE_EXCPT_HDR1(_JMMCG_EXCPT_MSG,_JMMCG_REVISION_HDR) jmmcg::LIBJMMCG_VER_NAMESPACE::exception((_JMMCG_EXCPT_MSG), JMMCG_FUNCTION(void), JMMCG_REVISION(_JMMCG_REVISION_HDR))
/// Handy for use in source files.
#define JMMCG_MAKE_CEXCPT_SRC1(_JMMCG_EXCPT_MSG) jmmcg::LIBJMMCG_VER_NAMESPACE::crt_exception((_JMMCG_EXCPT_MSG), JMMCG_FUNCTION(void), __REV_INFO__)
/// Handy for use in header files.
#define JMMCG_MAKE_CEXCPT_HDR1(_JMMCG_EXCPT_MSG,_JMMCG_REVISION_HDR) jmmcg::LIBJMMCG_VER_NAMESPACE::crt_exception((_JMMCG_EXCPT_MSG), JMMCG_FUNCTION(void), JMMCG_REVISION(_JMMCG_REVISION_HDR))
 
   /**
      Inheritance from "std::runtime_error" is done in case of object slicing (which can occur with exceptions) so I set the error string in the exception as best I can. Note that for derived exception classes, the error string held n "std::exception" may not have everything in it compared to the overrriden "what()". But it is better than sweet f.a.
   */
   template<ppd::generic_traits::api_type API, typename Mdl>
   class exception : public std::runtime_error {
   public:
      typedef std::runtime_error base_t;
      typedef ppd::api_threading_traits<API, Mdl> thread_traits;
      typedef typename thread_traits::lock_traits lock_traits;
 
      exception(tstring &&r, info::function &&f, info::revision &&ri) noexcept(false);
      exception(const tostringstream &r, info::function &&f, info::revision &&ri) noexcept(false);
      exception(const exception &ex) noexcept(false);
      void operator=(exception const &)=delete;
      void operator=(exception &&)=delete;
      virtual ~exception() noexcept(true) {
      }
 
      virtual exit_codes::codes __fastcall
      code() const noexcept(true) {
         return exit_codes::exit_jmmcg_exception;
      }
 
      char const * __CLR_OR_THIS_CALL what() const noexcept(true) final override;
 
      virtual const tstring __fastcall to_string() const noexcept(false);
 
      static constexpr std::size_t max_size() noexcept(true) {
         return 27+PATH_MAX+3
            +info::function::max_size()+info::revision::max_size()
            +14+std::numeric_limits<std::size_t>::digits10
            +29+std::numeric_limits<std::size_t>::digits10
            +13+32+1
            +1+sizeof(LIBJMMCG_DETAILED_VERSION_INFO)+1;
      }
 
      /**
         \todo Implement using the advice given in "Standard C++ IOStreams and Locales" by A.Langer & K.Kreft, page 170.
      */
      friend tostream & __fastcall
      operator<<(tostream &o, const exception &e) noexcept(false) {
         return o<<e.to_string();
      }
 
   protected:
      const typename thread_traits::api_params_type::pid_type process_id;
      const typename thread_traits::api_params_type::tid_type thread_id;
      const typename thread_traits::api_params_type::username_type current_username;
 
   private:
      const tstring reason;
      const info::function func;
      const info::revision rev;
      mutable std::string what_;
 
      static NEVER_INLINE const tstring __fastcall
      to_string(const tstring &r, const info::function &f, const info::revision &rev, const typename thread_traits::api_params_type::pid_type pid, const typename thread_traits::api_params_type::tid_type tid, typename thread_traits::api_params_type::username_type const &uname) noexcept(false) {
         std::array<tchar, max_size()> buff;
         boost::iostreams::stream<boost::iostreams::array_sink> o(buff.data(), buff.max_size());
         o<<_T("Exception thrown. Reason: '")<<r<<_T("'.\n")
            <<f<<rev
            <<_T("Process ID: 0x")<<std::hex<<pid
            <<_T(", thread ID: 0x")<<std::hex<<tid
            <<_T(", username: '")<<uname.data()<<_T("'\n")
            LIBJMMCG_DETAILED_VERSION_INFO<<std::ends;
         return tstring{buff.data()};
      }
   };
 
   const tstring __fastcall
   dump_crt_errno(const unsigned long err=errno) noexcept(false);
 
   template<ppd::generic_traits::api_type API, typename Mdl>
   class crt_exception : public exception<API, Mdl> {
   public:
      using base_t=exception<API, Mdl>;
      using thread_traits=typename base_t::thread_traits;
 
      crt_exception(tstring &&r, info::function &&f, info::revision &&ri, const unsigned long en=errno) noexcept(false);
      crt_exception(const tostringstream &r, info::function &&f, info::revision &&ri, const unsigned long en=errno) noexcept(false);
      crt_exception(const crt_exception &ex) noexcept(false);
      void operator=(crt_exception const &)=delete;
      void operator=(crt_exception &&)=delete;
      virtual ~crt_exception() noexcept(true) {
      }
 
      exit_codes::codes __fastcall
      code() const noexcept(true) override {
         return exit_codes::exit_crt_exception;
      }
 
      const tstring __fastcall to_string() const noexcept(false) override;
 
      static constexpr std::size_t max_size() noexcept(true) {
         return base_t::max_size()+14+std::numeric_limits<std::size_t>::digits10+23+1024+4;
      }
 
      /**
         \todo Implement using the advice given in "Standard C++ IOStreams and Locales" by A.Langer & K.Kreft, page 170.
      */
      friend tostream & __fastcall
      operator<<(tostream &o, const crt_exception &e) noexcept(false) {
         return o<<e.to_string();
      }
 
   private:
      const unsigned long crt_errno;
   };
 
} }
 
#ifdef WIN32
#  include "../experimental/NT-based/NTSpecific/exception.hpp"
#endif
 
#include "exception_impl.hpp"
 
#ifdef __GCC__
#  pragma GCC diagnostic pop
#endif
 
#endif