exceptions/exceptions.h

Go to the documentation of this file.

// Copyright (C) 2009-2026 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 FatalException : public Exception {
public:
    FatalException(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