YUIException.h

/*
  Copyright (C) 2000-2012 Novell, Inc
  This library is free software; you can redistribute it and/or modify
  it under the terms of the GNU Lesser General Public License as
  published by the Free Software Foundation; either version 2.1 of the
  License, or (at your option) version 3.0 of the License. This library
  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 Lesser General Public
  License for more details. You should have received a copy of the GNU
  Lesser General Public License along with this library; if not, write
  to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  Floor, Boston, MA 02110-1301 USA
*/


/*-/

  File:     YUIException.h

        Stolen from zypp/libzypp/base/Exception.h

  Author:       Michael Andres    <ma@suse.de>
  Maintainer:   Stefan Hundhammer <shundhammer@suse.de>

/-*/

#ifndef YUIException_h
#define YUIException_h


#include <cerrno>
#include <iostream>
#include <stdexcept>

#include "YProperty.h"


class YWidget;


//
// Macros for application use
//

#define YUI_EXCEPTION_CODE_LOCATION YCodeLocation(__FILE__,__FUNCTION__,__LINE__)


#define YUI_THROW( EXCEPTION ) \
    _YUI_THROW( ( EXCEPTION ), YUI_EXCEPTION_CODE_LOCATION )

#define YUI_CAUGHT( EXCEPTION ) \
    _YUI_CAUGHT( ( EXCEPTION ), YUI_EXCEPTION_CODE_LOCATION )


#define YUI_RETHROW( EXCEPTION ) \
    _YUI_RETHROW( ( EXCEPTION ), YUI_EXCEPTION_CODE_LOCATION )


#define YUI_THROW_MSG( EXCEPTION_TYPE, MSG ) \
    YUI_THROW( EXCEPTION_TYPE( MSG ) )


#define YUI_THROW_ERRNO( EXCEPTION_TYPE ) \
    YUI_THROW( EXCEPTION_TYPE( YUIException::strErrno( errno ) ) )

#define YUI_THROW_ERRNO1( EXCEPTION_TYPE, ERRNO ) \
    YUI_THROW( EXCEPTION_TYPE( YUIException::strErrno( ERRNO ) ) )

#define YUI_THROW_ERRNO_MSG( EXCEPTION_TYPE, MSG) \
    YUI_THROW( EXCEPTION_TYPE( YUIException::strErrno( errno, MSG ) ) )

#define YUI_THROW_ERRNO_MSG1( EXCEPTION_TYPE, ERRNO,MSG ) \
    YUI_THROW( EXCEPTION_TYPE( YUIException::strErrno( ERRNO, MSG ) ) )


//
// Higher-level (UI specific) exception macros
//

#define YUI_CHECK_NEW( PTR )                \
    do                          \
    {                           \
    if ( ! (PTR) )                  \
    {                       \
        YUI_THROW( YUIOutOfMemoryException() ); \
    }                       \
    } while( 0 )



#define YUI_CHECK_PTR( PTR )                \
    do                          \
    {                           \
    if ( ! (PTR) )                  \
    {                       \
        YUI_THROW( YUINullPointerException() ); \
    }                       \
    } while( 0 )


#define YUI_CHECK_WIDGET( WIDGET )          \
    do                          \
    {                           \
    if ( ! ( static_cast<bool> (WIDGET) ) ||    \
         ! (WIDGET)->isValid() )            \
    {                       \
        YUI_THROW( YUIInvalidWidgetException() );   \
    }                       \
    } while( 0 )


#define YUI_CHECK_INDEX_MSG( INDEX, VALID_MIN, VALID_MAX, MSG ) \
    do                              \
    {                               \
    if ( (INDEX) < (VALID_MIN) ||               \
         (INDEX) > (VALID_MAX) )                \
    {                           \
        YUI_THROW( YUIIndexOutOfRangeException( (INDEX), (VALID_MIN), (VALID_MAX), (MSG) ) ); \
    }                           \
    } while( 0 )


#define YUI_CHECK_INDEX( INDEX, VALID_MIN, VALID_MAX ) \
    YUI_CHECK_INDEX_MSG( (INDEX), (VALID_MIN), (VALID_MAX), "")




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

    YCodeLocation()
    : _line( 0 )
    {}

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

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

    int line() const { return _line; }

    std::string asString() const;

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

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

}; // YCodeLocation


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


class YUIException : public std::exception
{
public:
    YUIException();

    YUIException( const std::string & msg_r );

    virtual ~YUIException() throw();

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

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

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

    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 YUIException  &  exception,
             const YCodeLocation &  location,
                     const char * const     prefix );
    virtual const char * what() const throw()
    { return _msg.c_str(); }

protected:

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


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


    mutable YCodeLocation   _where;
    std::string         _msg;

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

}; // class YUIException


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


class YUINullPointerException: public YUIException
{
public:
    YUINullPointerException()
    : YUIException( "Null pointer" )
    {}

    virtual ~YUINullPointerException() throw()
    {}
};


class YUIOutOfMemoryException: public YUIException
{
public:
    YUIOutOfMemoryException()
    : YUIException( "Out of memory" )
    {}

    virtual ~YUIOutOfMemoryException() throw()
    {}

};

class YUIInvalidWidgetException: public YUIException
{
public:
    YUIInvalidWidgetException()
    : YUIException( "Invalid widget" )
    {}

    virtual ~YUIInvalidWidgetException() throw()
    {}
};


class YUIWidgetNotFoundException: public YUIException
{
public:
    YUIWidgetNotFoundException( const std::string & idString )
    : YUIException( std::string( "No widget with ID " ) + idString )
    {}

    virtual ~YUIWidgetNotFoundException() throw()
    {}
};


class YUINoDialogException: public YUIException
{
public:
    YUINoDialogException()
    : YUIException( "No dialog existing" )
    {}

    virtual ~YUINoDialogException() throw()
    {}
};


class YUIDialogStackingOrderException: public YUIException
{
public:
    YUIDialogStackingOrderException()
    : YUIException( "Dialog stacking order violated" )
    {}

    virtual ~YUIDialogStackingOrderException() throw()
    {}
};


class YUISyntaxErrorException: public YUIException
{
public:
    YUISyntaxErrorException( const std::string & msg )
    : YUIException( msg )
    {}

    virtual ~YUISyntaxErrorException() throw()
    {}
};


class YUIPropertyException: public YUIException
{
protected:
    YUIPropertyException( const YProperty &     prop,
              YWidget *         widget = 0 )
    : YUIException()
    , _property( prop )
    , _widget( widget )
    {}

    virtual ~YUIPropertyException() throw()
    {}

public:
    YProperty property() const { return _property; }

    YWidget * widget() const { return _widget; }

    void setWidget( YWidget * w ) { _widget = w; }

protected:

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

private:
    YProperty   _property;
    YWidget *   _widget;
};


class YUIUnknownPropertyException: public YUIPropertyException
{
public:
    YUIUnknownPropertyException( const std::string &    propertyName,
                 YWidget *      widget = 0 )
    : YUIPropertyException( YProperty( propertyName, YUnknownPropertyType ), widget )
    {}

    virtual ~YUIUnknownPropertyException() throw()
    {}

protected:

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


class YUIPropertyTypeMismatchException: public YUIPropertyException
{
public:

    YUIPropertyTypeMismatchException( const YProperty & property,
                      YPropertyType type,
                      YWidget *     widget = 0 )
    : YUIPropertyException( property, widget )
    , _type( type )
    {}

    virtual ~YUIPropertyTypeMismatchException() throw()
    {}

    YPropertyType type() const { return _type; }

protected:

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

private:
    YPropertyType _type;
};


class YUISetReadOnlyPropertyException: public YUIPropertyException
{
public:

    YUISetReadOnlyPropertyException( const YProperty &  property,
                     YWidget *      widget = 0 )
    : YUIPropertyException( property, widget )
    {}

    virtual ~YUISetReadOnlyPropertyException() throw()
    {}

protected:

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


class YUIBadPropertyArgException: public YUIPropertyException
{
public:

    YUIBadPropertyArgException( const YProperty &   property,
                YWidget *       widget,
                const std::string & message = "" )
    : YUIPropertyException( property, widget )
    { setMsg( message ); }

    virtual ~YUIBadPropertyArgException() throw()
    {}

protected:

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


template<class YWidget> class YUITooManyChildrenException: public YUIException
{
public:

    YUITooManyChildrenException( YWidget * container )
    : YUIException( "Too many children" )
    , _container( container )
    {}

    virtual ~YUITooManyChildrenException() throw()
    {}

    YWidget * container() const { return _container; }

protected:

    virtual std::ostream & dumpOn( std::ostream & str ) const
    {
    std::string widgetClass =
        container() ? container()->widgetClass() :
        "widget";

    return str << "Too many children for "
           << widgetClass
           << std::endl;
    }

private:

    YWidget * _container;
};


template<class YWidget> class YUIInvalidChildException: public YUIException
{
public:

    YUIInvalidChildException( YWidget * container,
                  YWidget * child = 0 )
    : YUIException( "Invalid child" )
    , _container( container )
    , _child( child )
    {}

    virtual ~YUIInvalidChildException() throw()
    {}

    YWidget * container() const { return _container; }

    YWidget * child() const { return _child; }

protected:

    virtual std::ostream & dumpOn( std::ostream & str ) const
    {
    std::string containerWidgetClass =
        container() ? container()->widgetClass() :
        "widget";

    std::string childWidgetClass =
        child() ? child()->widgetClass() :
        "<Null>";

    return str << childWidgetClass
           << " is not a child of "
           << containerWidgetClass
           << std::endl;
    }

private:

    YWidget * _container;
    YWidget * _child;
};



class YUIUnsupportedWidgetException: public YUIException
{
public:

    YUIUnsupportedWidgetException( const std::string & widgetType )
    : YUIException( std::string( "Unsupported optional widget type: " ) + widgetType )
    {}

    virtual ~YUIUnsupportedWidgetException() throw()
    {}
};


class YUIInvalidDimensionException: public YUIException
{
public:
    YUIInvalidDimensionException()
    : YUIException( "Invalid dimension (neither YD_HORIZ nor YD_VERT)" )
    {}

    virtual ~YUIInvalidDimensionException() throw()
    {}
};


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

    virtual ~YUIIndexOutOfRangeException() throw()
    {}

    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 YUIPluginException: public YUIException
{
public:
    YUIPluginException( const std::string & pluginName )
    : YUIException( std::string( "Couldn't load plug-in " ) + pluginName )
    {}

    virtual ~YUIPluginException() throw()
    {}
};


class YUICantLoadAnyUIException: public YUIException
{
public:
    YUICantLoadAnyUIException()
    : YUIException( "No $DISPLAY and stdout is not a tty" )
    {}

    virtual ~YUICantLoadAnyUIException() throw()
    {}
};


class YUIButtonRoleMismatchException: public YUIException
{
public:

    YUIButtonRoleMismatchException( const std::string & msg )
    : YUIException( msg )
    {}

    virtual ~YUIButtonRoleMismatchException() throw()
    {}
};


//
// Helper templates
//


template<class _Exception>
void _YUI_THROW( const _Exception & exception_r, const YCodeLocation & where_r )
{
    exception_r.relocate( where_r );
    YUIException::log( exception_r, where_r, "THROW:   " );
    throw( exception_r );
}


template<class _Exception>
void _YUI_CAUGHT( const _Exception & exception_r, const YCodeLocation & where_r )
{
    YUIException::log( exception_r, where_r, "CAUGHT:  " );
}


template<class _Exception>
void _YUI_RETHROW( const _Exception & exception_r, const YCodeLocation & where_r )
{
    YUIException::log( exception_r, where_r, "RETHROW: " );
    exception_r.relocate( where_r );
    throw;
}


#endif // YUIException_h