Exception.h

Go to the documentation of this file.

// Honeycomb, Copyright (C) 2015 NewGamePlus Inc.  Distributed under the Boost Software License v1.0.
#pragma once

#include "Honey/String/Stream.h"

namespace honey
{

#ifndef FINAL
    #define throw_                      Exception::Raiser() ^ Exception::Source(__FUNC__, __FILE__, __LINE__) << 
#else
    #define throw_                      Exception::Raiser() ^
#endif

#define EXCEPTION(Class)                                                        \
    typedef SharedPtr<Class> Ptr;                                               \
    typedef SharedPtr<const Class> ConstPtr;                                    \
                                                                                \
    virtual Exception::Ptr clone() const    { return new Class(*this); }        \
    virtual String typeName() const         { return typeid(*this).name(); }    \
    virtual void raise() const              { throw *this; }                    \



class Exception : public SharedObj<Exception>, public std::exception
{
public:
    struct MsgStream : ostringstream
    {
        MsgStream(Exception& e)                                             : e(&e) {}
        MsgStream(MsgStream&& rhs)                                          : ostringstream(std::move(rhs)), e(rhs.e) { rhs.e = nullptr; }
        Exception* e;
    };

    struct Source
    {
        Source()                                                            : func(nullptr), file(nullptr), line(0) {}
        Source(const char* func, const char* file, int line)                : func(func), file(file), line(line) {}
        Exception& operator<<(Exception& e)                                 { e._source = *this; return e; }
        Exception&& operator<<(Exception&& e)                               { e._source = *this; return move(e); }

        friend ostream& operator<<(ostream& os, const Source& source)
        {
            return os << c_str(source.func) << ":" << c_str(source.file) << ":" << source.line;
        }
        
        const char* func;
        const char* file;
        int line;
    };

    struct Raiser
    {
        void operator^(const Exception& e)                                  { e.raise(); }
        void operator^(const ostream& os)                                   { auto& ms = static_cast<const MsgStream&>(os); assert(ms.e); ms.e->_message += ms.str(); ms.e->raise(); }
    };

    Exception() = default;
    Exception(const Exception& rhs)                                         { operator=(rhs); }

    Exception& operator=(const Exception& rhs)
    {
        _source = rhs._source;
        _message = rhs._message;
        _what = nullptr;
        return *this;
    }
    
    EXCEPTION(Exception)

    
    const Source& source() const                                            { return _source; }
    const String& message() const                                           { return _message; }
    
    const char* what() const throw()                                        { cacheWhat(); return _what->c_str(); }

    static Ptr current();

    template<class T>
    MsgStream operator<<(T&& val)                                           { return forward<MsgStream>(MsgStream(*this) << std::forward<T>(val)); }
    
    friend ostream& operator<<(ostream& os, const Exception& e)             { return os << e.what(); }
    
protected:
    virtual String createWhat() const
    {
        return source().func ?
            sout() << message() << " (exception: " << typeName() << "; " << source() << ")" :
            sout() << message();
    }

private:
    void cacheWhat() const                                                  { if (!_what) _what = honey::make_unique<std::string>(createWhat()); }

    Source _source;
    String _message;
    mutable UniquePtr<std::string> _what;
};

namespace exception
{
    template<class T>
    struct Std : Exception
    {
        typedef SharedPtr<Std> Ptr;
        typedef SharedPtr<const Std> ConstPtr;
        
        Std(const T& e)                         : _e(e) { *this << _e.what(); }
        
        virtual Exception::Ptr clone() const    { return new Std(_e); }
        virtual String typeName() const         { return typeid(_e).name(); }
        virtual void raise() const              { throw _e; }

    private:
        T _e;
    };

    template<class T>
    typename Std<T>::Ptr createStd(const T& e)  { return new Std<T>(e); }

    struct Unknown : Exception                  { EXCEPTION(Unknown) };
}

inline Exception::Ptr Exception::current()
{
    //std exceptions are not dynamic so there's no way to clone them trivially
    try { throw; }
    catch (Exception& e)                { return e.clone(); }
    catch (std::domain_error& e)        { return honey::exception::createStd(e); }
    catch (std::invalid_argument& e)    { return honey::exception::createStd(e); }
    catch (std::length_error& e)        { return honey::exception::createStd(e); }
    catch (std::out_of_range& e)        { return honey::exception::createStd(e); }
    catch (std::logic_error& e)         { return honey::exception::createStd(e); }
    catch (std::range_error& e)         { return honey::exception::createStd(e); }
    catch (std::overflow_error& e)      { return honey::exception::createStd(e); }
    catch (std::underflow_error& e)     { return honey::exception::createStd(e); }
    catch (std::ios_base::failure& e)   { return honey::exception::createStd(e); }
    catch (std::runtime_error& e)       { return honey::exception::createStd(e); }
    catch (std::bad_alloc& e)           { return honey::exception::createStd(e); }
    catch (std::bad_cast& e)            { return honey::exception::createStd(e); }
    catch (std::bad_typeid& e)          { return honey::exception::createStd(e); }
    catch (std::bad_exception& e)       { return honey::exception::createStd(e); }
    catch (std::exception& e)           { return honey::exception::createStd(e); }
    catch (...)                         { return new honey::exception::Unknown(); }
}

namespace debug
{
    struct AssertionFailure : Exception { EXCEPTION(AssertionFailure) };
}

}