exception.hpp

Go to the documentation of this file.

#pragma once

#include <xtd/xtd.hpp>

#include <exception>
#include <xtd/source_location.hpp>
#include <xtd/string.hpp>
#define throw_if(_test, _expression) _throw_if(here(), _test, _expression, #_test)

namespace xtd{

  class exception : public std::exception{
  public:
    using _super_t = std::exception;

    template <typename _ReturnT, typename _ExpressionT>
    inline static _ReturnT _throw_if(const xtd::source_location& source, _ReturnT ret, _ExpressionT exp, const char* expstr){
      if (exp(ret)){
        throw exception(source, expstr);
      }
      return ret;
    }

    exception(const source_location& Source, const std::string& What)
      :  _super_t()
      , _errnum(errno)
      , _source(Source)
      , _what(What){}
    exception(const exception& src)
      : _super_t()
      , _errnum(src._errnum)
      , _source(src._source)
      , _what(src._what){}
    exception(exception&& src)
      : _super_t()
      , _errnum(src._errnum)
      , _source(std::move(src._source))
      , _what(std::move(src._what)){}

    const char * what() const
    #if (XTD_COMPILER_GCC & XTD_COMPILER)
      noexcept
    #endif
      override{
      return _what.c_str();
    }

    virtual const source_location& location() const
    #if (XTD_COMPILER_GCC & XTD_COMPILER)
      noexcept
    #endif
    {
      return _source;
    }

  protected:
    //_errnum needs to be in the base class before heap allocations such as std::string in _what
    int _errnum;
    const source_location& _source;
    std::string _what;
  };

  class crt_exception : public xtd::exception{
  public:
    template <typename _ReturnT, typename _ExpressionT>
    inline static _ReturnT _throw_if(const xtd::source_location& source, _ReturnT ret, _ExpressionT exp, const char* expstr){
      if (exp(ret)){
        throw crt_exception(source, expstr);
      }
      return ret;
    }

    crt_exception(const source_location& Source, const std::string& What) : xtd::exception(Source, What){
      if (!_errnum){
        return;
      }
      _what += " : ";

#if (XTD_COMPILER_MSVC & XTD_COMPILER)
      _what.resize(_what.size() + 100);
      strerror_s(&_what[_what.size() - 100], 100, _errnum);
      _what.resize(strlen(_what.c_str()));
#else
      _what += strerror(_errnum);
#endif
    }
    crt_exception(const crt_exception& ex) : xtd::exception(ex){}
    crt_exception(crt_exception&& ex) : xtd::exception(std::move(ex)){}

    int errnum() const { return _errnum; }
  };

#if ((XTD_OS_MINGW | XTD_OS_WINDOWS) & XTD_OS)
  namespace windows{
    struct exception : xtd::exception{
    public:
      template <typename _ReturnT, typename _ExpressionT>
      inline static _ReturnT _throw_if(const xtd::source_location& source, _ReturnT ret, _ExpressionT exp, const char* expstr){
        if (exp(ret)){
          throw exception(source, expstr);
        }
        return ret;
      }

      exception(const xtd::source_location& source, const std::string&) :xtd::exception(source, ""), _last_error(GetLastError()){
        const char * sTemp = nullptr;
        FormatMessageA(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, _last_error, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), reinterpret_cast<LPSTR>(&sTemp), 0, nullptr);
        _what = sTemp;
        LocalFree((HLOCAL)sTemp);
      }
    private:
      DWORD _last_error;
    };
  }
#endif


}