Callback.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_CALLBACK_H
#define ZYPP_CALLBACK_H
 
#include <zypp/base/NonCopyable.h>
#include <zypp/UserData.h>
 
namespace zypp
{ 
 
  namespace HACK {
    class Callback
    {
    };
  } // namespace HACK
 
 
  namespace callback
  { 
 
    struct ReportBase
    {
      typedef callback::UserData UserData;
      typedef UserData::ContentType ContentType;
 
      virtual void report( const UserData & userData_r = UserData() )
      {}
 
      virtual ~ReportBase()
      {}
    };
 
    template<class TReport>
      struct DistributeReport;
 
    template<class TReport>
      struct ReceiveReport : public TReport
      {
        typedef TReport                   ReportType;
        typedef ReceiveReport<TReport>    Receiver;
        typedef DistributeReport<TReport> Distributor;
 
        virtual ~ReceiveReport()
        { disconnect(); }
 
        ReceiveReport * whoIsConnected() const
        { return Distributor::instance().getReceiver(); }
 
        bool connected() const
        { return whoIsConnected() == this; }
 
        void connect()
        { Distributor::instance().setReceiver( *this ); }
 
        void disconnect()
        { Distributor::instance().unsetReceiver( *this ); }
 
        virtual void reportbegin()
        {}
        virtual void reportend()
        {}
      };
 
    template<class TReport>
      struct DistributeReport
      {
       public:
        typedef TReport                   ReportType;
        typedef ReceiveReport<TReport>    Receiver;
        typedef DistributeReport<TReport> Distributor;
 
         static DistributeReport & instance()
         {
           static DistributeReport _self;
           return _self;
         }
 
         Receiver * getReceiver() const
         { return _receiver == &_noReceiver ? 0 : _receiver; }
 
         void setReceiver( Receiver & rec_r )
         { _receiver = &rec_r; }
 
         void unsetReceiver( Receiver & rec_r )
         { if ( _receiver == &rec_r ) noReceiver(); }
 
         void noReceiver()
         { _receiver = &_noReceiver; }
 
      public:
         Receiver * operator->()
         { return _receiver; }
 
      private:
        DistributeReport()
        : _receiver( &_noReceiver )
        {}
        Receiver _noReceiver;
        Receiver * _receiver;
      };
 
    template<class TReport>
      struct SendReport : private zypp::base::NonCopyable
      {
        typedef TReport                   ReportType;
        typedef ReceiveReport<TReport>    Receiver;
        typedef DistributeReport<TReport> Distributor;
 
        SendReport()
        { Distributor::instance()->reportbegin(); }
 
        ~SendReport()
        { Distributor::instance()->reportend(); }
 
        static Receiver * whoIsConnected()
        { return Distributor::instance().getReceiver(); }
 
        static bool connected()
        { return whoIsConnected(); }
 
        Distributor & operator->()
        { return Distributor::instance(); }
      };
 
    template<class TReport>
      struct TempConnect
      {
        typedef TReport                   ReportType;
        typedef ReceiveReport<TReport>    Receiver;
        typedef DistributeReport<TReport> Distributor;
 
        TempConnect()
        : _oldRec( Distributor::instance().getReceiver() )
        {
          Distributor::instance().noReceiver();
        }
 
        TempConnect( Receiver & rec_r )
        : _oldRec( Distributor::instance().getReceiver() )
        {
          rec_r.connect();
        }
 
        ~TempConnect()
        {
          if ( _oldRec )
            Distributor::instance().setReceiver( *_oldRec );
          else
            Distributor::instance().noReceiver();
        }
      private:
        Receiver * _oldRec;
      };
 
  } // namespace callback
} // namespace zypp
#endif // ZYPP_CALLBACK_H