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, const Pathname &deltafile = Pathname() );

      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 Pathname & )> ProvideOperation;

      void provide( ProvideOperation op, const OnMediaLocation &resource, ProvideFileOptions options, const Pathname &deltafile );

      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