exception.cpp

Go to the documentation of this file.

/*
 * Copyright (C) Sergey P. Derevyago, 2008.
 *
 * Permission to copy, use, modify, sell and distribute this software is granted
 * provided this copyright notice appears in all copies.
 * This software is provided "as is" without express or implied warranty, and
 * with no claim as to its suitability for any purpose.
 *
 */

#include <ders/exception.hpp>
#include <exception>
#include <ders/text_buf.hpp>

namespace ders {  // ::ders

sh_text toTextAll(const shException& she)
{
 mem_pool& mp(she.pool());
 if (!she.get()) return nt(mp);

 text_buf buf(mp);
 for (shException e=she; ; ) {
     buf+e->toText();

     e=e->nested;
     if (!e.get()) break;

     buf+'\n';
 }

 return buf;
}

shException recatchException(mem_pool& mp, const FileLine& location)
{
 try { throw; }
 catch (shException she) {
       return she;
 }
 catch (const std::exception& se) {
       return newStdExternException(mp, location, se.what(), typeid(se).name());
 }
 catch (...) {
       return newUnknExternException(mp, location, "Unknown exception");
 }
}

Exception::Exception(const FileLine& loc, const ch_rng& msg, shException nest)
  : location(loc), message(nt(nest.pool(), msg)), nested(nest)
{
}

sh_text Exception::getClassName() const
{
 return nt(message.pool(), "ders::Exception");
}

sh_text Exception::toText() const
{
 return text_buf(getClassName())+" ["+location.file+":"+location.line+
   "], message: "+message;
}

shException newException(mem_pool& mp, const FileLine& loc, const ch_rng& msg)
{
 return newException(loc, msg, shException(mp, 0));
}

shException newException(const FileLine& loc, const ch_rng& msg, shException
  nest)
{
 mp_newbuf<Exception> buf(nest.pool());
 return shException(buf.pool(), buf.rls(::new(buf.get()) Exception(loc, msg,
   nest)));
}

MsgException::MsgException(const FileLine& loc, const ch_rng& msg, shException
  nest) : Exception(loc, msg, nest)
{
}

ExitMsgException::ExitMsgException(const FileLine& loc, const ch_rng& msg, int
  ecode, shException nest) : MsgException(loc, msg, nest), exitCode(ecode)
{
}

sh_text ExitMsgException::getClassName() const
{
 return nt(message.pool(), "ders::ExitMsgException");
}

sh_text ExitMsgException::toText() const
{
 return text_buf(getClassName())+" ["+location.file+":"+location.line+
   "], exitCode="+exitCode+", message: "+message;
}

shException newExitMsgException(mem_pool& mp, const FileLine& loc, const ch_rng&
  msg, int ecode)
{
 return newExitMsgException(loc, msg, ecode, shException(mp, 0));
}

shException newExitMsgException(const FileLine& loc, const ch_rng& msg, int
  ecode, shException nest)
{
 mp_newbuf<ExitMsgException> buf(nest.pool());
 return shException(buf.pool(), buf.rls(::new(buf.get()) ExitMsgException(loc,
   msg, ecode, nest)));
}

ExternException::ExternException(const FileLine& loc, const ch_rng& msg, const
  ch_rng& tname, shException nest) :
  Exception(loc, msg, nest), typeName(nt(nest.pool(), tname))
{
}

sh_text ExternException::toText() const
{
 return text_buf(getClassName())+" ["+location.file+":"+location.line+
   "], typeName=\""+typeName+"\", message: "+message;
}

StdExternException::StdExternException(const FileLine& loc, const ch_rng& msg,
  const ch_rng& tname, shException nest) :
  ExternException(loc, msg, tname, nest)
{
}

sh_text StdExternException::getClassName() const
{
 return nt(message.pool(), "ders::StdExternException");
}

shException newStdExternException(mem_pool& mp, const FileLine& loc, const
  ch_rng& msg, const ch_rng& tname)
{
 return newStdExternException(loc, msg, tname, shException(mp, 0));
}

shException newStdExternException(const FileLine& loc, const ch_rng& msg, const
  ch_rng& tname, shException nest)
{
 mp_newbuf<StdExternException> buf(nest.pool());
 return shException(buf.pool(), buf.rls(::new(buf.get()) StdExternException(loc,
   msg, tname, nest)));
}

UnknExternException::UnknExternException(const FileLine& loc, const ch_rng& msg,
  shException nest) :
  ExternException(loc, msg, nt(nest.pool(), "unknown"), nest)
{
}

sh_text UnknExternException::getClassName() const
{
 return nt(message.pool(), "ders::UnknExternException");
}

shException newUnknExternException(mem_pool& mp, const FileLine& loc, const
  ch_rng& msg)
{
 return newUnknExternException(loc, msg, shException(mp, 0));
}

shException newUnknExternException(const FileLine& loc, const ch_rng& msg,
  shException nest)
{
 mp_newbuf<UnknExternException> buf(nest.pool());
 return shException(buf.pool(), buf.rls(::new(buf.get()) UnknExternException(
   loc, msg, nest)));
}

}  // namespace ::ders

---