Exception.h

/*
 * Copyright (c) [2014-2015] Novell, Inc.
 * Copyright (c) [2016-2026] 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"
#include "storage/Utils/Swig.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 as_string() const;

        std::string asString() const ST_DEPRECATED;

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

    private:

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

    };


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


    class Exception : public std::exception
    {
    public:

        Exception(LogLevel log_level = LogLevel::ERROR);

        Exception(const std::string & msg, LogLevel log_level = LogLevel::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 as_string() const;

        std::string asString() const ST_DEPRECATED;

        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 override { 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;

    };


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


    class NullPointerException : public Exception
    {
    public:

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

        virtual ~NullPointerException() noexcept
            {}

    };


    class UnsupportedException : public Exception
    {
    public:

        UnsupportedException(const std::string& msg) : Exception(msg) {}
        virtual ~UnsupportedException() 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", LogLevel::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 invalid_index() const { return _invalidIndex; }

        int invalidIndex() const ST_DEPRECATED { return _invalidIndex; }

        int valid_min() const { return _validMin; }

        int validMin() const ST_DEPRECATED { return _validMin; }

        int valid_max() const { return _validMax; }

        int validMax() const ST_DEPRECATED { return _validMax; }

    protected:

        virtual std::ostream& dumpOn(std::ostream& str) const override
        {
            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 IOException : public Exception
    {
    public:

        IOException(const std::string& msg) : Exception(msg) {}
        virtual ~IOException() 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 override
        {
            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;

    };


    // TODO It should be possible to catch all exception derived from
    // Exception except of Aborted, see code in activate_* and
    // error_callback. Or use some other method to abort function with
    // callbacks.

    class Aborted : public Exception
    {
    public:

        Aborted(const std::string& message) : Exception(message) {}
        virtual ~Aborted() noexcept {}

    };

}

#endif