MediaSetAccess.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
 
#ifndef ZYPP_MediaSetAccess_H
#define ZYPP_MediaSetAccess_H
 
#include <iosfwd>
#include <string>
#include <vector>
#include <zypp/base/Function.h>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/Flags.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/media/MediaManager.h>
#include <zypp/Pathname.h>
#include <zypp/CheckSum.h>
#include <zypp/OnMediaLocation.h>
#include <zypp/ManagedFile.h>
 
namespace zypp
{ 
 
    DEFINE_PTR_TYPE(MediaSetAccess);
 
    //
    //  CLASS NAME : MediaSetAccess
    //
    class MediaSetAccess : public base::ReferenceCounted, private base::NonCopyable
    {
      friend std::ostream & operator<<( std::ostream & str, const MediaSetAccess & obj );
 
    public:
      MediaSetAccess( const Url &url, const Pathname & prefered_attach_point = "" );
      MediaSetAccess( const std::string & label_r, const Url &url, const Pathname & prefered_attach_point = "" );
      ~MediaSetAccess();
 
      void setVerifier( unsigned media_nr, media::MediaVerifierRef verifier );
 
      const std::string & label() const
      { return _label; }
 
      void setLabel( const std::string & label_r )
      { _label = label_r; }
 
      enum ProvideFileOption
      {
        PROVIDE_DEFAULT = 0x0,
        PROVIDE_NON_INTERACTIVE = 0x1
      };
      ZYPP_DECLARE_FLAGS(ProvideFileOptions,ProvideFileOption);
 
      void precacheFiles(const std::vector<OnMediaLocation> &files);
 
      Pathname provideFile( const OnMediaLocation & resource, ProvideFileOptions options = PROVIDE_DEFAULT );
 
      ZYPP_DEPRECATED Pathname provideFile( const OnMediaLocation & resource, ProvideFileOptions options, const Pathname &deltafile );
 
      Pathname provideFile(const Pathname & file, unsigned media_nr = 1, ProvideFileOptions options = PROVIDE_DEFAULT );
 
      Pathname provideOptionalFile( const Pathname & file, unsigned media_nr = 1 );
 
      static ManagedFile provideFileFromUrl( const Url & file_url, ProvideFileOptions options = PROVIDE_DEFAULT );
 
      static ManagedFile provideOptionalFileFromUrl( const Url & file_url );
 
      void releaseFile( const OnMediaLocation &resource );
 
 
      void releaseFile(const Pathname & file, unsigned media_nr = 1 );
 
      struct ReleaseFileGuard
      {
        NON_COPYABLE( ReleaseFileGuard );
        NON_MOVABLE( ReleaseFileGuard );
        ReleaseFileGuard( MediaSetAccess & media_r, const OnMediaLocation & loc_r )
        : _media( media_r )
        , _loc( loc_r )
        {}
        ~ReleaseFileGuard()
        { _media.releaseFile( _loc ); }
      private:
        MediaSetAccess & _media;
        const OnMediaLocation & _loc;
      };
 
      Pathname provideDir(const Pathname & dir, bool recursive, unsigned media_nr = 1, ProvideFileOptions options = PROVIDE_DEFAULT );
 
      bool doesFileExist(const Pathname & file, unsigned media_nr = 1 );
 
      void dirInfo( filesystem::DirContent &retlist, const Pathname &dirname,
                    bool dots = true, unsigned media_nr = 1 );
 
      void release();
 
      static Url rewriteUrl (const Url & url_r, const media::MediaNr medianr);
 
    protected:
      Pathname provideFileInternal( const OnMediaLocation &resource, ProvideFileOptions options );
 
      typedef function<void( media::MediaAccessId, const OnMediaLocation & )> ProvideOperation;
 
      void provide( ProvideOperation op, const OnMediaLocation &resource, ProvideFileOptions options );
 
      media::MediaAccessId getMediaAccessId (media::MediaNr medianr);
      virtual std::ostream & dumpOn( std::ostream & str ) const;
 
    private:
      Url _url;
 
      Pathname _prefAttachPoint;
 
      std::string _label;
 
      typedef std::map<media::MediaNr, media::MediaAccessId> MediaMap;
      typedef std::map<media::MediaNr, media::MediaVerifierRef > VerifierMap;
 
      MediaMap _medias;
      VerifierMap _verifiers;
    };
    ZYPP_DECLARE_OPERATORS_FOR_FLAGS(MediaSetAccess::ProvideFileOptions);
 
    inline std::ostream & operator<<( std::ostream & str, const MediaSetAccess & obj )
    { return obj.dumpOn( str ); }
 
 
} // namespace zypp
#endif // ZYPP_SOURCE_MediaSetAccess_H