spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma once



class TNotify;
template<class T_ErrorAbleClass_>
class TNotifyAble;


/*
 *  + TNotify
 *  -------------------------------------------------------------------------------------------------------------
 *  TNotify besteht aus einem INT, der einen Errorcode enthält.
 *  Diese Klasse enthält einen operatore für BOOL und kann so bei if (etc) benutzt werden
 *  behandelt werden
 *  -------------------------------------------------------------------------------------------------------------
 *
 *
 *
 *  + TNotifyAble< Erbende Klasse >
 *  -------------------------------------------------------------------------------------------------------------
 *  Macht eine Klasse Notifyable.
 *  Kann eine Notify Klassenweit(static) speichern.
 *  Enthält Funktionen zum setzen und Abrufen von fehlern.
 *  -------------------------------------------------------------------------------------------------------------
 *
 *
 *
 *  + TNotifyAble< Erbende Klasse >
 *    + TStdNotifyCatcher
 *  -------------------------------------------------------------------------------------------------------------
 *  Klasse zum speichern von Fehlern für normale Funktionen.
 *  Hat keine eigenen Variablen oder Funktionen... erbt nur von TNotifyAble
 *  -------------------------------------------------------------------------------------------------------------
 *
 *
 *
 */








///////////////////////////////////////////////// TNotify /////////////////////////////////////////////////



class TNotify
{
private:
    int     _m_NotifyCode_;
public:

    /*
        Konstruktor ( Keine Parameter )
    */
    TNotify()
        : _m_NotifyCode_( 0 )
    {}


    /*
        Konstruktor ( NotifyCode )
    */
    TNotify(int _notifyCode)
        : _m_NotifyCode_( _notifyCode)
    {}


    /*
        Gebt eine Referenz auf den Notifycode zurück
    */
    inline
        int
            GetNotifyCode()
                const
    {
        return (_m_NotifyCode_);
    }


    /*
        Setzt einen Notifycode
    */
    inline
        int
            SetNotifyCode(int _notifyCode)
    {
        return (_m_NotifyCode_ = _notifyCode);
    }


    /*
        Gibt zurück ob ein Fehler vorliegt
        true    = Fehler
        false   = Kein Fehler
    */
    inline
        bool
            IsNotify()
                const
    {
        return  ((_m_NotifyCode_ == 0)? (false):(true));
    }


    /*
        Gibt zurück ob ein Fehler vorliegt
        true    = Kein Fehler
        false   = Fehler
    */
    inline
        bool
            IsValid()
                const
    {
        return  ((_m_NotifyCode_ == 0)? (true):(false));
    }


    /*
        überladener cast-operator
            -> IsValid()
    */
    inline
        operator
            bool()
                const
    {
        return (IsValid());
    }
};


///////////////////////////////////////////////// TNotifyAble /////////////////////////////////////////////////


template<class T_ErrorAbleClass_>
class TNotifyAble
{
private:
    static TNotify          _m_LastNotify_;
public:
    /*
        Setzt einen Klasseweiten Notifycode
    */
    static
        TNotify
            SetNotify( TNotify _notify)
    {
        if( _notify.IsNotify() )
            return (_m_LastNotify_ = _notify);
        return (_notify);
    }

    /*
        Gint das letzte Notify zurück
    */
    static
        inline
            TNotify
                GetLastNotify()
    {
        return (_m_LastNotify_);
    }


    /*
        Gibt zurück ob eine Notify vorliegt
        true    = Fehler
        false   = Kein Fehler
    */
    inline
        bool
            IsNotify()
                const
    {
        return (_m_LastNotify_.IsNotify());
    }

};

template<class T_ErrorAbleClass_>
TNotify
    TNotifyAble<T_ErrorAbleClass_>
                ::_m_LastNotify_ = 0;


///////////////////////////////////////////////// TStdNotifyCatcher /////////////////////////////////////////////////


            
            
struct TStdNotifyCatcher
    : public TNotifyAble<TStdNotifyCatcher>
{};