/data/gitorious.org/libyui/libyui-master/src/YUIException.h

/**************************************************************************
Copyright (C) 2000 - 2010 Novell, Inc.
All Rights Reserved.

This program 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.

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, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

**************************************************************************/


/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

  File:         YUIException.h

                Stolen from zypp/libzypp/base/Exception.h

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

/-*/

#ifndef YUIException_h
#define YUIException_h


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

#include "YProperty.h"

using std::string;
using std::ostream;
using std::endl;

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 ( ! (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 string & file_r,
                   const string & func_r,
                   int            line_r )
        : _file( file_r )
        , _func( func_r )
        , _line( line_r )
        {}

    YCodeLocation()
        : _line( 0 )
        {}

    string file() const { return _file; }

    string func() const { return _func; }

    int line() const { return _line; }

    string asString() const;

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

private:
    string      _file;
    string      _func;
    int         _line;

}; // YCodeLocation


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


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

    YUIException( const string & msg_r );

    virtual ~YUIException() throw();

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

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

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

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

    string asString() const;

    static string strErrno( int errno_r );

    static string strErrno( int errno_r, const 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 ostream & dumpOn( ostream & str ) const;


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


    mutable YCodeLocation       _where;
    string                      _msg;

    ostream & dumpError( ostream & str ) const;

}; // class YUIException


ostream & operator<<( 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 string & idString )
        : YUIException( 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 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 ostream & dumpOn( ostream & str ) const = 0;

private:
    YProperty   _property;
    YWidget *   _widget;
};


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

    virtual ~YUIUnknownPropertyException() throw()
        {}

protected:

    virtual ostream & dumpOn( 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 ostream & dumpOn( 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 ostream & dumpOn( ostream & str ) const;
};


class YUIBadPropertyArgException: public YUIPropertyException
{
public:

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

    virtual ~YUIBadPropertyArgException() throw()
        {}

protected:

    virtual ostream & dumpOn( 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 ostream & dumpOn( ostream & str ) const
    {
        string widgetClass =
            container() ? container()->widgetClass() :
            "widget";

        return str << "Too many children for "
                   << widgetClass
                   << 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 ostream & dumpOn( ostream & str ) const
    {
        string containerWidgetClass =
            container() ? container()->widgetClass() :
            "widget";

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

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

private:

    YWidget * _container;
    YWidget * _child;
};



class YUIUnsupportedWidgetException: public YUIException
{
public:

    YUIUnsupportedWidgetException( const string & widgetType )
        : YUIException( 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 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 ostream & dumpOn( ostream & str ) const
    {
        string prefix = msg();

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

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

private:

    int _invalidIndex;
    int _validMin;
    int _validMax;
};


class YUIPluginException: public YUIException
{
public:
    YUIPluginException( const string & pluginName )
        : YUIException( 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 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