#include <boost/config.hpp>

#include <exception>
#include <string>

namespace http {

class exception : public std::exception
{
public:
  exception(const std::string& msg) : _msg(msg) {}

  /* virtual */ const char* what() const override BOOST_NOEXCEPT
  {
    return _msg.c_str();
  }

private:
  const std::string _msg;
};

// ...

} // namespace http

#define MY_THROW(Ex) \
  throw Ex << base_exception::location_info(debug::location(__FILE__, BOOST_CURRENT_FUNCTION, __LINE__)) \
           << base_exception::trace_info(debug::get_call_stack())

class base_exception
  : virtual public std::exception
  , virtual public boost::exception
{
public:
  typedef boost::error_info<struct tag_backtrace, std::vector<std::string>> trace_info;
  typedef boost::error_info<struct tag_location, debug::location> location_info;
  typedef boost::error_info<struct tag_reason, std::string> reason_info;

  static reason_info reason(const std::string& str)
  {
    return reason_info(str);
  }

  template <typename T>
  const typename T::value_type* get() const
  {
    return boost::get_error_info<T>(*this);
  }

  const std::vector<std::string>& call_stack() const
  {
    if (const std::vector<std::string>* result = get<trace_info>())
    {
      return *result;
    }
    return std::vector<std::string>();
  }

  virtual std::string reason() const
  {
    if (const std::string* result = get<reason_info>())
    {
      return *result;
    }
    return std::string();
  }

  const debug::location& where() const
  {
    if (const debug::location* result = get<location_info>())
    {
      return *result;
    }
    return debug::location();
  }

  virtual const char* what() const throw() override
  {
    return boost::diagnostic_information_what(*this);
  }
};

class some_exception : public base_exception {};

MY_THROW(some_exception())
      << base_exception::reason("Some exception");

#define MY_THROW(Ex) \
  throw Ex << base_exception::location_info(debug::location(__FILE__, BOOST_CURRENT_FUNCTION, __LINE__)) \
           << base_exception::original_type_info(typeid((Ex)).name()) \
           << base_exception::trace_info(debug::get_call_stack())

void sometimes_throws(int arg, std::error_code& ec = throws());

int main() {
  // throw if failed:
  try {
    sometimes_throws(0);
  } catch(std::system_error& e) {
      std::cerr << e.code();
  }

  // do not throw:
  std::error_code ec;
  sometimes_throws(0, ec);
  std::cerr << ec;
}

FH>#include <boost/config.hpp>

FH>#include <exception>
FH>#include <string>

FH>namespace http {

FH>class exception : public std::exception
FH>{
FH>public:
FH>  exception(const std::string& msg) : _msg(msg) {}

FH>  /* virtual */ const char* what() const override BOOST_NOEXCEPT
FH>  {
FH>    return _msg.c_str();
FH>  }

FH>private:
FH>  const std::string _msg;
FH>};

FH>// ...

FH>} // namespace http
FH>

// создание плоской иерархии
template<class Tag> class tagged_exception : public std::exception { ..... };

struct foo_ex_tag {};
struct bar_ex_tag {};

try { ... throw tagged_exception<foo_ex_tag>("oh deer"); ... }
catch(tagged_exception<foo_ex_tag> const& e) { ... e.what() ... }

// миксины
template<class MixIn, class CtorArg = MixIn> class mixed_exception : public std::exception, public MixIn { ..... };

struct foo_mixin { /* дополнительные поля */ };

try { ... throw mixed_exception<foo_mixin>( foo_mixin(1,2,3) ); ... }
catch(mixed_exception<foo_mixin> const& e) { ... e.foo_member ... };

// CRTP

template<class Final> class curious_exception : public std::exception { .... static_cast<Final*>(this) ..... };

struct foo_exception : curious_exception<foo_exception> { ..... };

try { ... throw foo_exception("let eat bee", 1,2,3); ... };
catch(foo_exception const& e) { ... e.foo_member ... };

catch(e){ if(!we_can_handle(e)) throw; } ... }

FH>class exception : public std::exception
FH>{
FH>public:
FH>  exception(const std::string& msg) : _msg(msg) {}

FH>  /* virtual */ const char* what() const override BOOST_NOEXCEPT
FH>  {
FH>    return _msg.c_str();
FH>  }

FH>private:
FH>  const std::string _msg; // <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<
FH>};

#define STR_(t) #t
#define STR(t) Str_(t)
#define MY_THROW(type, msg) \
   throw type(__FILE__ "(" STR(__LINE__) "): " msg)