Exception.hpp

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                     _     _   _   _     __     _                     |
|                    | |   | | | \_/ |   /  \   | |                    |
|                    | |   | | | |_| |  / /\ \  | |                    |
|                    | |__ | | | | | | / ____ \ | |__                  |
|                    |____||_| |_| |_|/ /    \ \|____|                 |
|                                                                      |
|                             core library                             |
|                                                                      |
|                                         (C) SUSE Linux Products GmbH |
\----------------------------------------------------------------------/

  File:       Exception.hpp

  Author:     Michael Calmer
  Maintainer: Michael Calmer

/-*/
#ifndef CA_MGM_EXCEPTION_HPP
#define CA_MGM_EXCEPTION_HPP

#include "ca-mgm/config.h"
#include <ca-mgm/String.hpp>
#include <string.h>

namespace CA_MGM_NAMESPACE
{

  class Exception : public std::exception
  {
    friend std::ostream & operator<<( std::ostream & str, const Exception & obj );

    protected:
      Exception(const char* file, int line, const char* msg,
                int errorCode, const Exception *otherException = 0);

    public:
      Exception(const Exception& e);
      Exception& operator= (const Exception& rhs);
      virtual ~Exception() throw();

      virtual const char* type() const;
      virtual const char* getMessage() const;
      virtual std::string getFullMessage() const;

      const char* getFile() const;
      int getLine() const;

      int getErrorCode() const;

      virtual const char* what() const throw();

    private:
      char* m_file;
      int m_line;
      char* m_msg;
      int m_errorCode;
  };

namespace ExceptionDetail
{
  unsigned const BUFSZ = 1024;

  template <typename exType>
  struct Errno
  {
    static exType simple(char const * file, int line, int errnum)
    {
      return exType(file, line, ::strerror(errnum), errnum);
    }

    template <typename Mtype>
    static exType format(char const * file, int line,
                         Mtype const & msg, int errnum)
    {
      return format(file, line, msg.c_str(), errnum);
    }

    static exType format(char const * file, int line,
                         char const * msg, int errnum)
    {
      return exType(file, line, str::form("%s: %d(%s)", msg, errnum, ::strerror(errnum)).c_str(), errnum);
    }
  }; // struct Errno
}

#define CA_MGM_DECLARE_EXCEPTION2(NAME, BASE) \
class NAME##Exception : public BASE \
{ \
public: \
        NAME##Exception(const char* file, int line, const char* msg, int errorCode = 0, const ca_mgm::Exception* otherException = 0); \
        virtual ~NAME##Exception() throw(); \
        virtual const char* type() const; \
};

#define CA_MGM_DECLARE_EXCEPTION(NAME) CA_MGM_DECLARE_EXCEPTION2(NAME, ca_mgm::Exception)

#define CA_MGM_DEFINE_EXCEPTION2(NAME, BASE) \
NAME##Exception::NAME##Exception(const char* file, int line, const char* msg, int errorCode, const ::ca_mgm::Exception* otherException) \
        : BASE(file, line, msg, errorCode, otherException) {} \
NAME##Exception::~NAME##Exception() throw() { } \
const char* NAME##Exception::type() const { return #NAME "Exception"; }\


#define CA_MGM_DEFINE_EXCEPTION(NAME) CA_MGM_DEFINE_EXCEPTION2(NAME, ca_mgm::Exception)

#define CA_MGM_THROW(exType, msg) throw exType(__FILE__, __LINE__, (msg))

#define CA_MGM_THROW_SUBEX(exType, msg, subex) \
throw exType(__FILE__, __LINE__, (msg), -1, &(subex))

#define CA_MGM_THROW_ERR(exType, msg, err) \
throw exType(__FILE__, __LINE__, (msg), (err))

#define CA_MGM_THROW_ERRNO(exType) CA_MGM_THROW_ERRNO1(exType, errno)

#define CA_MGM_THROW_ERRNO1(exType, errnum) \
throw ::ca_mgm::ExceptionDetail::Errno< exType >::simple(__FILE__, __LINE__, (errnum))

#define CA_MGM_THROW_ERRNO_MSG(exType, msg) \
CA_MGM_THROW_ERRNO_MSG1(exType, (msg), errno)

#define CA_MGM_THROW_ERRNO_MSG1(exType, msg, errnum) \
throw ::ca_mgm::ExceptionDetail::Errno< exType >:: \
      format(__FILE__, __LINE__, (msg), (errnum))


        CA_MGM_DECLARE_EXCEPTION(Memory);

        CA_MGM_DECLARE_EXCEPTION(Runtime);

        CA_MGM_DECLARE_EXCEPTION(Overflow);

        CA_MGM_DECLARE_EXCEPTION(Syntax);


        CA_MGM_DECLARE_EXCEPTION(Value);

        CA_MGM_DECLARE_EXCEPTION(System);

        CA_MGM_DECLARE_EXCEPTION(OutOfBounds);

}      // End of CA_MGM_NAMESPACE

#endif /* CA_MGM_EXCEPTION_HPP */