Exception.h

/*
 * Copyright (c) [2014-2015] Novell, Inc.
 * Copyright (c) 2016 SUSE LLC
 *
 * All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of version 2 of the GNU General Public License as published
 * by the Free Software Foundation.
 *
 * This program 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 this program; if not, contact Novell, Inc.
 *
 * To contact Novell about this file by physical or electronic mail, you may
 * find current contact information at www.novell.com.
 */


#ifndef STORAGE_EXCEPTION_H
#define STORAGE_EXCEPTION_H


/*
 * Large parts stolen from libyui/YUIException.h
 */


#include <stdexcept>
#include <string>
#include <ostream>

#include "storage/Utils/Logger.h"


namespace storage
{

    class CodeLocation
    {
    public:
        CodeLocation( const std::string & file_r,
                      const std::string & func_r,
                      int                 line_r )
            : _file(file_r), _func(func_r), _line(line_r)
            {}

        CodeLocation()
            : _file(), _func(), _line(0)
            {}

        const std::string& file() const { return _file; }

        const std::string& func() const { return _func; }

        int line() const { return _line; }

        std::string asString() const;

        friend std::ostream & operator<<( std::ostream & str, const CodeLocation & obj );

    private:
        std::string     _file;
        std::string     _func;
        int             _line;

    }; // CodeLocation


    std::ostream & operator<<( std::ostream & str, const CodeLocation & obj );


    class Exception : public std::exception
    {
    public:
        Exception(LogLevel log_level = ERROR);

        Exception(const std::string & msg, LogLevel log_level = ERROR);

        virtual ~Exception() noexcept;

        const CodeLocation & where() const
            { return _where; }

        void relocate( const CodeLocation & newLocation ) const
            { _where = newLocation; }

        const std::string & msg() const
            { return _msg; }

        LogLevel log_level() const { return _log_level; }

        void setMsg( const std::string & msg )
            { _msg = msg; }

        std::string asString() const;

        static std::string strErrno( int errno_r );

        static std::string strErrno( int errno_r, const std::string & msg );

        static void log( const Exception  &     exception,
                         const CodeLocation &   location,
                         const char * const     prefix );

        virtual const char * what() const noexcept
            { return _msg.c_str(); }

    protected:

        virtual std::ostream & dumpOn( std::ostream & str ) const;


    private:
        friend std::ostream & operator<<( std::ostream & str,
                                          const Exception & obj );


        mutable CodeLocation    _where;
        std::string             _msg;
        LogLevel _log_level;

        std::ostream & dumpError( std::ostream & str ) const;

    }; // class Exception


    std::ostream & operator<<( std::ostream & str, const Exception & obj );


    class NullPointerException: public Exception
    {
    public:
        NullPointerException()
            : Exception( "Null pointer", ERROR )
            {}

        virtual ~NullPointerException() noexcept
            {}
    };


    class NotImplementedException : public Exception
    {
    public:
        NotImplementedException(const std::string& msg) : Exception(msg) {}
        virtual ~NotImplementedException() noexcept {}
    };


    class LogicException : public Exception
    {
    public:
        LogicException(const std::string& msg) : Exception(msg) {}
        virtual ~LogicException() noexcept {}
    };


    class OutOfMemoryException: public Exception
    {
    public:
        OutOfMemoryException()
            : Exception( "Out of memory", ERROR )
            {}

        virtual ~OutOfMemoryException() noexcept
            {}

    };


    class IndexOutOfRangeException: public Exception
    {
    public:
        IndexOutOfRangeException( int                   invalidIndex,
                                  int                   validMin,
                                  int                   validMax,
                                  const std::string &   msg = "" )
            : Exception( msg )
            , _invalidIndex( invalidIndex )
            , _validMin( validMin )
            , _validMax( validMax )
            {}

        virtual ~IndexOutOfRangeException() noexcept
            {}

        int invalidIndex() const        { return _invalidIndex; }

        int validMin() const    { return _validMin; }

        int validMax() const    { return _validMax; }

    protected:

        virtual std::ostream & dumpOn( std::ostream & str ) const
        {
            std::string prefix = msg();

            if ( prefix.empty() )
                prefix = "Index out of range";

            return str << prefix << ": " << _invalidIndex
                       << " valid: " << _validMin << " .. " << _validMax
                       << std::endl;
        }

    private:

        int _invalidIndex;
        int _validMin;
        int _validMax;
    };


    class OverflowException : public Exception
    {
    public:

        OverflowException() : Exception("overflow") {}
        virtual ~OverflowException() noexcept {}

    };


    class ParseException: public Exception
    {
    public:

        ParseException( const std::string & msg,
                        const std::string & seen,
                        const std::string & expected ):
            Exception( msg ),
            _seen( seen ),
            _expected( expected )
            {}

        virtual ~ParseException() noexcept
            {}

        const std::string & seen() const { return _seen; }

        const std::string & expected() const { return _expected; }

        virtual std::ostream & dumpOn( std::ostream & str ) const
        {
            std::string prefix = "Parse error";

            if ( ! msg().empty() )
                prefix += ": ";

            return str << prefix << msg()
                       << "; expected: \"" << _expected
                       << "\" seen: \"" << _seen << "\""
                       << std::endl;
        }

    private:

        std::string _seen;
        std::string _expected;
    };

}

#endif