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