exceptions/exceptions.h

Go to the documentation of this file.

// Copyright (C) 2009-2024 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef EXCEPTIONS_H
#define EXCEPTIONS_H 1
 
#include <stdexcept>
#include <string>
#include <sstream>
 
namespace isc {
 
class Exception : public std::exception {
public:
 
 
    Exception(const char* file, size_t line, const char* what);
 
    Exception(const char* file, size_t line, const std::string& what);
 
    virtual ~Exception() throw() {}
private:
    void operator=(const Exception& src);
 
public:
 
 
    virtual const char* what() const throw();
 
    virtual const char* what(bool verbose) const throw();
 
 
 
    const std::string& getMessage() const { return (what_); }
 
    const char* getFile() const { return (file_); }
 
    size_t getLine() const { return (line_); }
 
private:
 
    const char* const file_;
 
    size_t line_;
 
    const std::string what_;
 
    std::string verbose_what_;
};
 
class OutOfRange : public Exception {
public:
    OutOfRange(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class InvalidParameter : public Exception {
public:
    InvalidParameter(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class BadValue : public Exception {
public:
    BadValue(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class InvalidOperation : public Exception {
public:
    InvalidOperation(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class Unexpected : public Exception {
public:
    Unexpected(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class NotImplemented : public Exception {
public:
    NotImplemented(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class NotFound : public Exception {
public:
    NotFound(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
class MultiThreadingInvalidOperation : public Exception {
public:
    MultiThreadingInvalidOperation(const char* file, size_t line, const char* what) :
        isc::Exception(file, line, what) {}
};
 
#define isc_throw(type, stream) \
    do { \
        std::ostringstream oss__; \
        oss__ << stream; \
        throw type(__FILE__, __LINE__, oss__.str().c_str()); \
    } while (1)
 
#define isc_throw_1(type, stream, param1) \
    do { \
        std::ostringstream oss__; \
        oss__ << stream; \
        throw type(__FILE__, __LINE__, oss__.str().c_str(), param1); \
    } while (1)
 
#define isc_throw_2(type, stream, param1, param2) \
    do { \
        std::ostringstream oss__; \
        oss__ << stream; \
        throw type(__FILE__, __LINE__, oss__.str().c_str(), param1, param2); \
    } while (1)
 
#define isc_throw_3(type, stream, param1, param2, param3) \
    do { \
        std::ostringstream oss__; \
        oss__ << stream; \
        throw type(__FILE__, __LINE__, oss__.str().c_str(), param1, param2,\
                   param3); \
    } while (1)
 
#define isc_throw_4(type, stream, param1, param2, param3, param4) \
    do { \
        std::ostringstream oss__; \
        oss__ << stream; \
        throw type(__FILE__, __LINE__, oss__.str().c_str(), param1, param2,\
                   param3, param4); \
    } while (1)
 
}
#endif // EXCEPTIONS_H