exceptions.hpp

//
// Declaration exception classes and related macros
//
// (c) Copyright 2011 DESY, Eugen Wintersberger <eugen.wintersberger@desy.de>
//
// This file is part of libpnicore.
//
// libpnicore 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 2 of the License, or
// (at your option) any later version.
//
// libpnicore 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 libpnicore.  If not, see <http://www.gnu.org/licenses/>.
//
// ===========================================================================
//
// Created on: Apr 19, 2011
//     Author: Eugen Wintersberger
//
//

#pragma once

#include<iostream>
#include<string>
#include<exception>
#include<typeinfo>
#include<list>
#include<boost/current_function.hpp>

#include "../types/types.hpp"

namespace pni{
namespace core{

//================Macros related to exceptions==================================

#define EXCEPTION_RECORD\
    exception_record(__FILE__,__LINE__,BOOST_CURRENT_FUNCTION)


#define EXCEPTION_FORWARD(ETYPE)\
    catch(ETYPE &error)\
    {\
        error.append(EXCEPTION_RECORD);\
        throw error;\
    }

    //========================Exception classes==================================

    class exception_record
    {
        private:
            string _file;     
            size_t _line;     
            string _function; 
        public:
            //===================constructors and destructor===================
            exception_record() = delete;

            exception_record(const string &file,size_t line,const string &func):
                _file(file),
                _line(line),
                _function(func)
            {}

            //==================public member functions========================
            const string &file() const { return _file; }
            size_t line() const { return _line; }
            const string &function() const { return _function; } 
    };

    //------------------------------------------------------------------------
    std::ostream &operator<<(std::ostream &o,const exception_record &rec); 

    //-------------------------------------------------------------------------
    class exception:public std::exception
    {
        private:
            string _name;
            string _description; 
            std::list<exception_record> _records;
        protected:
            std::ostream &print(std::ostream &o) const;
        public:
            //===================public types==================================
            typedef std::list<exception_record>::const_iterator const_iterator;
            //===================constructors and destructor===================
            exception();

            //-----------------------------------------------------------------
            exception(const string &n);

            //-----------------------------------------------------------------
            exception(const string &n, const exception_record &rec);

            //-----------------------------------------------------------------
            exception(const string &n, const exception_record &rec, 
                      const string &d);

            //-----------------------------------------------------------------
            virtual ~exception() throw() { }

            //===================public member functions=======================
            void name(const std::string &name) { _name = name; }

            //-----------------------------------------------------------------
            const string &name() const { return _name; }

            //-----------------------------------------------------------------

            void append(const exception_record &n) { _records.push_back(n); }

            //-----------------------------------------------------------------
            void description(const std::string &desc) { _description = desc; }

            //-----------------------------------------------------------------
            const string &description() const { return _description; }

            //-----------------------------------------------------------------
            const_iterator begin() const { return _records.begin(); }

            //-----------------------------------------------------------------
            const_iterator end() const { return _records.end(); }

            //-----------------------------------------------------------------
            friend std::ostream &operator<<(std::ostream &, const exception &);
            
    };


    //--------------------------------------------------------------------------
    class memory_allocation_error: public exception 
    {
        public:
            memory_allocation_error() : exception("memory_allocation_error") 
            { }

            //-----------------------------------------------------------------
            explicit memory_allocation_error(const exception_record &i, 
                                             const string &d):
                exception("memory_allocation_eror", i, d) 
            { }

            //-----------------------------------------------------------------
            ~memory_allocation_error() throw() { } 

            //-----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const memory_allocation_error &e);
    };

    //-------------------------------------------------------------------------
    class memory_not_allocated_error: public exception
    {
        public:
            memory_not_allocated_error(): 
                exception("memory_not_allocated_error") 
            {}

            //-----------------------------------------------------------------
            explicit memory_not_allocated_error(const exception_record &i,
                                                const string &d):
                exception("memory_not_allocated_error",i,d) 
            {}

            //----------------------------------------------------------------
            ~memory_not_allocated_error() throw() {}

            //----------------------------------------------------------------
            friend std::ostream &operator<<(std::ostream &o,const
                    memory_not_allocated_error &e);
    };


    //-------------------------------------------------------------------------
    class shape_mismatch_error: public exception 
    {
        public:
            shape_mismatch_error() : 
                exception("shape_mismatch_error") 
            { }

            //----------------------------------------------------------------
            explicit shape_mismatch_error(const exception_record &i, 
                                           const string &d) :
                exception("shape_mismatch_error",i,d) 
            { }

            //----------------------------------------------------------------
            ~shape_mismatch_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const shape_mismatch_error &e);
    };

    //--------------------------------------------------------------------------
    class size_mismatch_error: public exception 
    {
        public:
            size_mismatch_error() : exception("size_mismatch_error") 
            { }

            //-----------------------------------------------------------------
            explicit size_mismatch_error(const exception_record &i, 
                                         const string &d) :
                exception("size_mismatch_error", i,d) 
            { }

            //-----------------------------------------------------------------
            ~size_mismatch_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const size_mismatch_error &e);
    };

    //--------------------------------------------------------------------------
    class index_error: public exception 
    {
        public:
            index_error() : exception("index_error") 
            { }

            //-----------------------------------------------------------------
            explicit index_error(const exception_record &i, const string &d) :
                exception("index_error", i, d) 
            { }
           
            //-----------------------------------------------------------------
            ~index_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const index_error &e);
    };

    //--------------------------------------------------------------------------
    class key_error: public exception
    {
        public:
            key_error():exception("key_error"){}

            //-----------------------------------------------------------------
            explicit key_error(const exception_record &i,const string &d):
                exception("key_error",i,d)
            {}

            //-----------------------------------------------------------------
            ~key_error() throw() {}

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const key_error &e);
    };

    //--------------------------------------------------------------------------
    class file_error: public exception 
    {
        public:
            file_error() : exception("file_error") { }

            //-----------------------------------------------------------------
            explicit file_error(const exception_record &i, const string &d) :
                exception("file_error", i, d) 
            { }

            //-----------------------------------------------------------------
            ~file_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const file_error &e);

    };

    //--------------------------------------------------------------------------
    class type_error: public exception 
    {
        public:
            type_error() : exception("type_error") { }
           
            //-----------------------------------------------------------------
            explicit type_error(const exception_record &i, const string &d):
                exception("type_error", i, d) 
            { }

            //-----------------------------------------------------------------
            ~type_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const type_error &e);
    };

    //--------------------------------------------------------------------------
    class value_error: public exception 
    {
        public:
            value_error() : exception("value_error") { }
           
            //-----------------------------------------------------------------
            explicit value_error(const exception_record &i, const string &d):
                exception("value_error", i, d) 
            { }

            //-----------------------------------------------------------------
            ~value_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const value_error &e);
    };

    //--------------------------------------------------------------------------
    class range_error: public exception 
    {
        public:
            range_error(): exception("range_error"){ }

            //-----------------------------------------------------------------
            explicit range_error(const exception_record &i,const string &d):
                exception("range_error",i,d)
            { }

            //-----------------------------------------------------------------
            ~range_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const range_error &e);
    };

    //--------------------------------------------------------------------------
    class not_implemented_error:public exception
    {
        public:
            not_implemented_error(): 
                exception("not_implemented_error")
            { }
            
            //-----------------------------------------------------------------
            explicit not_implemented_error(const exception_record &i,
                                           const string &d):
                exception("not_implemented_error",i,d)
            { }

            //-----------------------------------------------------------------
            ~not_implemented_error() throw() { }

            //----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const not_implemented_error &e);
    };


    //--------------------------------------------------------------------------
    class iterator_error:public exception
    {
        public:
            iterator_error():exception("iterator_error"){ }

            //-----------------------------------------------------------------
            explicit iterator_error(const exception_record &i,const string &d):
                exception("iterator_error",i,d)
            { }

            //-----------------------------------------------------------------
            ~iterator_error() throw() { }

            //-----------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const iterator_error &e);
    };
    

    //-------------------------------------------------------------------------
    class cli_argument_error:public exception
    {
        public:
            //------------------------------------------------------------------
            cli_argument_error():exception("cli_argument_error"){}

            //------------------------------------------------------------------
            cli_argument_error(const exception_record &r,const string &d):
                exception("cli_argument_error",r,d)
            {}
            
            //------------------------------------------------------------------
            ~cli_argument_error() throw() {}

            //------------------------------------------------------------------
            friend std::ostream &
                operator<<(std::ostream &o,const cli_argument_error &e);
    };

    //--------------------------------------------------------------------------
    class cli_option_error:public exception
    {
        public:
            //------------------------------------------------------------------
            cli_option_error():exception("cli_option_error"){}

            //------------------------------------------------------------------
            cli_option_error(const exception_record &r,const string &d):
                exception("cli_option_error",r,d)
            {}

            //------------------------------------------------------------------
            ~cli_option_error() throw() {}

            //------------------------------------------------------------------
            friend std::ostream &
            operator<<(std::ostream &o,const cli_option_error &e);
    };

    //--------------------------------------------------------------------------
    class cli_error:public exception
    {
        public:
            //------------------------------------------------------------------
            cli_error():exception("cli_error"){}
            
            //------------------------------------------------------------------
            cli_error(const exception_record &r,const string &d):
                exception("cli_eror",r,d)
            {}

            //------------------------------------------------------------------
            ~cli_error() throw() {}

            //------------------------------------------------------------------
            friend std::ostream &operator<<(std::ostream &o,const cli_error &e);
    };

    //--------------------------------------------------------------------------
    class cli_help_request:public exception
    {
        public:
            //------------------------------------------------------------------
            cli_help_request():exception("cli_help_request"){}
            
            //------------------------------------------------------------------
            cli_help_request(const exception_record &r,const string &d):
                exception("cli_help_request",r,d)
            {}

            //------------------------------------------------------------------
            ~cli_help_request() throw() {}

            //----------------------------------------------------------------
            friend std::ostream &
            operator<<(std::ostream &o,const cli_help_request &e);
    };
}
}