CallBack.h

Go to the documentation of this file.

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

  File:       CallBack.h

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

  Purpose: Template classes for callback handling.

/-*/
#ifndef CallBack_h
#define CallBack_h

//
//      CLASS NAME : ReportCallback
struct ReportCallback {
  virtual ~ReportCallback()  {}
  virtual void reportbegin() {}
  virtual void reportend()   {}
};


//
//      CLASS NAME : RedirectCallback<class CB>
template <class CB> class RedirectCallback : public ReportCallback {

  private:

    CB * _redirectTo;

    CB * self() { return dynamic_cast<CB*>(this); }

  protected:

    CB * redirectTo( CB * to_r ) {
      CB * ret = _redirectTo;
      _redirectTo = ( to_r == self() ? 0 : to_r );
      return ret;
    }
    CB * redirectTo( CB & to_r ) {
      return redirectTo( &to_r );
    }

  public:

    virtual CB * operator->() {
      return( _redirectTo ? _redirectTo->operator->() : self() );
    }

  public:

    RedirectCallback()
      : _redirectTo( 0 )
    {}
    virtual ~RedirectCallback() {}
};


//
//      CLASS NAME : Report<class CB>
template <class CB> class Report : protected CB {

  public:

    Report() {}
    virtual ~Report() {}

  public:

    CB::redirectTo;

  public:

    //
    //  CLASS NAME : Report<CB>::Send
    class Send {

      private:

        Report<CB> & _report;

      public:

        Send( Report<CB> & report_r )
          : _report( report_r )
        { operator->()->reportbegin(); }
        ~Send() {
          operator->()->reportend();
        }

        CB * operator->() { return _report.operator->(); }
    };

};


//
//      CLASS NAME :
template <class CB> class ReportRedirect {
  ReportRedirect( const ReportRedirect & rhs );             // FORBIDDEN
  ReportRedirect & operator=( const ReportRedirect & rhs ); // FORBIDDEN
  private:
    Report<CB> & _report;
    CB *         _redirect;
    CB *         _oredirect;
  public:
    ReportRedirect( Report<CB> & report_r, CB & redirect_r )
      : _report( report_r )
      , _redirect( &redirect_r )
    {
      _oredirect = _report.redirectTo( _redirect );
    }
    ReportRedirect( Report<CB> & report_r, CB * redirect_r )
      : _report( report_r )
      , _redirect( redirect_r )
    {
      _oredirect = _report.redirectTo( _redirect );
    }
    virtual ~ReportRedirect() {
      _report.redirectTo( _oredirect );
    };
};


//
//      CLASS NAME :
template <class CB> struct ReportReceive : public CB, public ReportRedirect<CB> {
  ReportReceive( Report<CB> & report_r )
    : ReportRedirect<CB>( report_r, static_cast<CB*>(this) )
  {}
};


#endif // CallBack_h

---