exception.h

Go to the documentation of this file.

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef _LOG4CXX_HELPERS_EXCEPTION_H
#define _LOG4CXX_HELPERS_EXCEPTION_H
 
#include <exception>
#include <log4cxx/log4cxx.h>
#include <log4cxx/logstring.h>
#include <string>
 
#ifdef _MSC_VER
    #pragma warning ( push )
    #pragma warning (disable : 4275) // ::std::exception needs to have dll-interface
    #pragma warning (disable : 4251) // ::std::basic_string needs to have dll-interface
#endif
 
namespace LOG4CXX_NS
{
namespace helpers
{
class LOG4CXX_EXPORT Exception : public ::std::exception
{
    public:
        Exception(const char* msg);
        Exception(const LogString& msg);
        const char* what() const noexcept override;
        static LogString makeMessage(const LogString& type, log4cxx_status_t stat);
#if !LOG4CXX_LOGCHAR_IS_UTF8
        static std::string makeMessage(const char* type, log4cxx_status_t stat);
#endif
    private:
        std::string msg;
}; // class Exception

class LOG4CXX_EXPORT RuntimeException : public Exception
{
    public:
        RuntimeException(log4cxx_status_t stat);
        RuntimeException(const LogString& msg);
    private:
        static LogString formatMessage(log4cxx_status_t stat);
}; // class RuntimeException

class LOG4CXX_EXPORT  NullPointerException : public RuntimeException
{
    public:
        NullPointerException(const LogString& msg);
}; // class NullPointerException

class LOG4CXX_EXPORT IllegalArgumentException : public RuntimeException
{
    public:
        IllegalArgumentException(const LogString& msg);
}; // class IllegalArgumentException

class LOG4CXX_EXPORT IOException : public Exception
{
    public:
        IOException();
        IOException(log4cxx_status_t stat);
        IOException(const LogString& msg);
        IOException(const char* msg);
        IOException(const LogString& type, log4cxx_status_t stat);
#if !LOG4CXX_LOGCHAR_IS_UTF8
        IOException(const char* msg, log4cxx_status_t stat);
#endif
    private:
        static LogString formatMessage(log4cxx_status_t stat);
};
 
class LOG4CXX_EXPORT SubProcessFailure : public Exception
{
    public:
        SubProcessFailure(const LogString& processName, int exitCode, int exitWhy);
#if !LOG4CXX_LOGCHAR_IS_UTF8
        SubProcessFailure(const char* processName, int exitCode, int exitWhy);
#endif
        static LogString makeMessage(const LogString& processName, int exitCode, int exitWhy);
};
 
class LOG4CXX_EXPORT MissingResourceException : public Exception
{
    public:
        MissingResourceException(const LogString& key);
    private:
        static LogString formatMessage(const LogString& key);
};
 
class LOG4CXX_EXPORT PoolException : public Exception
{
    public:
        PoolException(log4cxx_status_t stat);
    private:
        static LogString formatMessage(log4cxx_status_t stat);
};

class LOG4CXX_EXPORT InstantiationException : public Exception
{
    public:
        InstantiationException(const LogString& msg);
};

class LOG4CXX_EXPORT ClassNotFoundException : public Exception
{
    public:
        ClassNotFoundException(const LogString& className);
    private:
        static LogString formatMessage(const LogString& className);
};
 
 
class LOG4CXX_EXPORT NoSuchElementException : public Exception
{
    public:
        NoSuchElementException();
};
 
class LOG4CXX_EXPORT IllegalStateException : public Exception
{
    public:
        IllegalStateException();
};

class LOG4CXX_EXPORT SocketException : public IOException
{
    public:
        SocketException(const LogString& msg);
        SocketException(log4cxx_status_t status);
};

class LOG4CXX_EXPORT ConnectException : public SocketException
{
    public:
        ConnectException(const LogString& msg);
        ConnectException(log4cxx_status_t status);
};
 
class LOG4CXX_EXPORT ClosedChannelException : public SocketException
{
    public:
        ClosedChannelException();
};

class LOG4CXX_EXPORT BindException : public SocketException
{
    public:
        BindException(log4cxx_status_t status);
};

class LOG4CXX_EXPORT InterruptedIOException : public IOException
{
    public:
        InterruptedIOException(const LogString& msg);
};
 

class LOG4CXX_EXPORT SocketTimeoutException : public InterruptedIOException
{
    public:
        SocketTimeoutException();
};
 
 
}  // namespace helpers
} // namespace log4cxx
 
#if defined(_MSC_VER)
    #pragma warning (pop)
#endif
 
#endif // _LOG4CXX_HELPERS_EXCEPTION_H