uncaught_handler.hpp

Go to the documentation of this file.

/*
 * Copyright 2008,2009,2010,2011,2012 Stephan Ossowski, Korbinian Schneeberger,
 * Felix Ott, Joerg Hagmann, Alf Scotland, Sebastian Bender
 * 
 * This file is part of SHORE.
 * 
 * SHORE is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * SHORE is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with SHORE.  If not, see <http://www.gnu.org/licenses/>.
 */



#ifndef SHORE_PROGRAM_UNCAUGHT_HANDLER_HPP__
#define SHORE_PROGRAM_UNCAUGHT_HANDLER_HPP__

#include <cerrno>
#include <cstring>
#include <iostream>
#include <stdexcept>
#include <string>

#include <boost/filesystem.hpp>
#include <boost/version.hpp>

#include "shore/program/av_parser.hpp"
#include "shore/stream/streams.hpp"

namespace shore {

class uncaught_handler
{
 public:

        enum Status
        {
                STATUS_OK,
                STATUS_ERR_USAGE,
                STATUS_ERR_FILESYSTEM,
                STATUS_ERR_IO,
                STATUS_ERR_RUNTIME,
                STATUS_ERR_DOMAIN,
                STATUS_ERR_LOGIC,
                STATUS_ERR_EXCEPTION,
                STATUS_ERR_ANY
        };

 private:

        std::string m_name;
        ostreams *m_os;
        Status m_status;

        bool m_rethrow_exceptions;

 public:

        uncaught_handler(const std::string &name);

        ~uncaught_handler();

        void set_rethrow_exceptions(const bool b);

        void set_stream(std::ostream &os);

        void set_file(const std::string &fn);

        void add_stream(std::ostream &os);

        void add_file(const std::string &fn);

        Status status() const;

        template<typename Func>
        Status operator()(Func func)
        {
                m_status=STATUS_OK;

            #ifndef NOCATCH
                try
            #endif // NOCATCH
                {
                        func();
                }
            #ifndef NOCATCH
                catch(const av_parser::usage_error &e)
                {
                        m_status=STATUS_ERR_USAGE;

                        // re-throw: Usage exceptions are handled separately
                        // by shore::program
                        throw;
                }
                // basic_filesystem_error is the same as filesystem_error since boost 1.35
            #if (BOOST_VERSION / 100) < 1035
                catch(const boost::filesystem::basic_filesystem_error<boost::filesystem::path> &e)
                {
                        m_status=STATUS_ERR_FILESYSTEM;

                        (*m_os)<<m_name<<": filesystem error --- "<<e.what()
                               <<std::endl;

                        (*m_os)<<"error code "<<e.system_error()
                               <<": "<<std::strerror(e.system_error());

                        if(!e.path1().empty())
                        {
                                (*m_os)<<" {\""<<e.path1();
                                if(!e.path2().empty())
                                {
                                        (*m_os)<<"\", \""<<e.path2();
                                }
                                (*m_os)<<"\"}";
                        }

                        (*m_os)<<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
            #endif  // BOOST_VERSION
                catch(const boost::filesystem::filesystem_error& e)
                {
                        m_status=STATUS_ERR_FILESYSTEM;

                        (*m_os)<<m_name<<": filesystem error --- "<<e.what()
                               <<std::endl;

            #if (BOOST_VERSION / 100) < 1035

                        (*m_os)<<"error code "<<e.system_error()
                               <<": "<<std::strerror(e.system_error())<<std::endl;

            #else // BOOST_VERSION

                        // boost >= v1.35
                        (*m_os)<<"error code "<<e.code().value()<<": "
                               <<e.code().message()<<std::endl;

            #endif // BOOST_VERSION

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(const std::ios_base::failure& e)
                {
                        m_status=STATUS_ERR_IO;

                        (*m_os)<<m_name<<": read/write failure --- "<<e.what()
                               <<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(const std::runtime_error& e)
                {
                        m_status=STATUS_ERR_RUNTIME;

                        (*m_os)<<m_name<<": runtime error --- "<<e.what()
                               <<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(const std::domain_error& e)
                {
                        m_status=STATUS_ERR_DOMAIN;

                        (*m_os)<<m_name<<": domain error --- "<<e.what()
                               <<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(const std::logic_error& e)
                {
                        m_status=STATUS_ERR_LOGIC;

                        (*m_os)<<m_name<<": logic error --- "<<e.what()
                               <<std::endl;
                        (*m_os)<<"Please report this bug."<<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(const std::exception& e)
                {
                        m_status=STATUS_ERR_EXCEPTION;

                        (*m_os)<<m_name<<": exception --- "<<e.what()<<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
                catch(...)
                {
                        m_status=STATUS_ERR_ANY;

                        (*m_os)<<m_name<<": error"<<std::endl;

                        if(m_rethrow_exceptions)
                                throw;
                }
            #endif // NOCATCH

                return m_status;
        }
};

} // namespace shore

#endif // SHORE_PROGRAM_UNCAUGHT_HANDLER_HPP__