InstSrcManagerCallbacks.h

Go to the documentation of this file.

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

  File:       InstSrcManagerCallbacks.h

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

  Purpose: Callbacks triggered by InstSrcManager

/-*/
#ifndef InstSrcManagerCallbacks_h
#define InstSrcManagerCallbacks_h

#include <iosfwd>

#include <y2util/Url.h>

#include <y2pm/PMCallbacks.h>
#include <y2pm/InstSrcPtr.h>
#include <y2pm/InstSrcDescrPtr.h>

namespace InstSrcManagerCallbacks {

  // Reporting need to change media
  struct MediaChangeCallback : public RedirectCallback<MediaChangeCallback> {
    virtual bool isSet() = 0;
    virtual std::string changeMedia( constInstSrcDescrPtr descr,
                                     const Url & currentUrl,
                                     int expectedMedianr,
                                     PMError error ) = 0;

    virtual std::string changeMedia( const std::string & error,
                                     const std::string & url,
                                     const std::string & product,
                                     int current,
                                     const std::string & currentLabel,
                                     int expected,
                                     const std::string & expectedLabel,
                                     bool doublesided ) = 0;
  };

  class MediaChangeReport : public Report<MediaChangeCallback> {
    virtual bool isSet() {
      return MediaChangeCallback::isSet();
    }
    virtual std::string changeMedia( constInstSrcDescrPtr descr,
                                     const Url & currentUrl,
                                     int expectedMedianr,
                                     PMError error ) {
      return MediaChangeCallback::changeMedia( descr, currentUrl,
                                               expectedMedianr, error );
    }
    virtual std::string changeMedia( const std::string & error,
                                     const std::string & url,
                                     const std::string & product,
                                     int current,
                                     const std::string & currentLabel,
                                     int expected,
                                     const std::string & expectedLabel,
                                     bool doublesided ) {
      return MediaChangeCallback::changeMedia( error, url, product,
                                               current, currentLabel,
                                               expected, expectedLabel,
                                               doublesided );
    }
  };

  extern MediaChangeReport mediaChangeReport;

  // Reporting SourceRefresh
  struct SourceRefreshCallback : public RedirectCallback<SourceRefreshCallback> {
    enum Result
      {
        SUCCESS = 0,
        RETRY,
        SKIP_REFRESH,
        DISABLE_SOURCE
      };
    std::string asString( Result val_r ) const;
    enum Cause
      {
        REFRESH_SKIP_CD_DVD,
        REFRESH_NOT_SUPPORTED_BY_SOURCE,
        SOURCE_IS_UPTODATE,
        SOURCE_REFRESHED,
        USERREQUEST
      };
    std::string asString( Cause val_r ) const;
    enum Error
      {
        NO_SOURCE_FOUND,
        INCOMPLETE_SOURCE_DATA
      };
    std::string asString( Error val_r ) const;

    virtual void   start( constInstSrcDescrPtr descr_r ) = 0;
    virtual Result error( Error error_r,
                          const std::string & detail = std::string() ) = 0;
    virtual void   stop( Result result_r, Cause cause_r,
                         const std::string & detail = std::string() ) = 0;
  };

  class SourceRefreshReport : public Report<SourceRefreshCallback> {
    virtual void start( constInstSrcDescrPtr descr_r ) {
      SourceRefreshCallback::start( descr_r );
    }
    virtual Result error( Error error_r,
                          const std::string & detail = std::string() ) {
      return SourceRefreshCallback::error( error_r, detail );
    }
    virtual void   stop( Result result_r, Cause cause_r,
                         const std::string & detail = std::string() ) {
      SourceRefreshCallback::stop( result_r, cause_r, detail );
    }
  };

  extern SourceRefreshReport sourceRefreshReport;

#if 0

  // Reporting @
  struct @Callback : public RedirectCallback<@Callback> {
    virtual void start() = 0;
    virtual void progress( const ProgressData & prg ) = 0;
    virtual void stop( PMError error ) = 0;
  };

  class @Report : public Report<@Callback> {
    virtual void start() {
      @Callback::start();
    }
    virtual void progress( const ProgressData & prg ) {
      @Callback::progress( prg );
    }
    virtual void stop( PMError error ) {
      @Callback::stop( error );
    }
  };

  extern @Report @Report;
#endif

} // namespace InstSrcManagerCallbacks

#endif // InstSrcManagerCallbacks_h

---