MediaAccess.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_MEDIA_MEDIAACCESS_H
#define ZYPP_MEDIA_MEDIAACCESS_H
 
#include <iosfwd>
#include <map>
#include <list>
#include <string>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/APIConfig.h>
 
#include <zypp/Pathname.h>
#include <zypp/PathInfo.h>
 
#include <zypp/media/MediaException.h>
#include <zypp/media/MediaSource.h>
 
#include <zypp/Url.h>
 
namespace zypp {
  namespace media {
 
    class MediaHandler;
 
    //
    //  CLASS NAME : MediaAccess
    class MediaAccess : public base::ReferenceCounted, private base::NonCopyable
    {
    public:
        typedef intrusive_ptr<MediaAccess> Ptr;
        typedef intrusive_ptr<const MediaAccess> constPtr;
 
    private:
 
        static const Pathname _noPath;
 
        MediaHandler * _handler;
 
        friend class MediaManager;
        friend class MediaManager_Impl;
 
        AttachedMedia        attachedMedia() const;
 
        bool                 isSharedMedia() const;
 
        void                 resetParentId();
        bool                 dependsOnParent() const;
 
        bool                 dependsOnParent(MediaAccessId parentId,
                                             bool exactIdMatch) const;
    public:
 
        MediaAccess();
 
        void open( const Url& url, const Pathname & preferred_attach_point = "" );
 
        bool isOpen() const { return( _handler != 0 ); }
 
        bool        downloads() const;
 
        std::string protocol() const;
 
        Url url() const;
 
        void close();
 
    public:
 
        void attach(bool next = false);
 
        bool isAttached() const;
 
        bool hasMoreDevices() const;
 
        virtual void
        getDetectedDevices(std::vector<std::string> & devices,
                           unsigned int & index) const;
 
 
        Pathname localRoot() const;
 
        Pathname localPath( const Pathname & pathname ) const;
 
        void disconnect();
 
        void release( const std::string & ejectDev = "" );
 
        void provideFile( const Pathname & filename, const ByteCount &expectedFileSize ) const;
 
        void releaseFile( const Pathname & filename ) const;
 
        void provideDir( const Pathname & dirname ) const;
 
        void provideDirTree( const Pathname & dirname ) const;
 
        void releaseDir( const Pathname & dirname ) const;
 
        void releasePath( const Pathname & pathname ) const;
 
        void setDeltafile( const Pathname & filename ) const;
 
    public:
 
        void dirInfo( std::list<std::string> & retlist,
                         const Pathname & dirname, bool dots = true ) const;
 
        void dirInfo( filesystem::DirContent & retlist,
                      const Pathname & dirname, bool dots = true ) const;
 
        bool doesFileExist( const Pathname & filename ) const;
 
        virtual ~MediaAccess();
 
    public:
 
        virtual std::ostream & dumpOn( std::ostream & str ) const;
 
    public:
        void getFile( const Url &from, const Pathname &to );
 
    public:
 
      class FileProvider {
        FileProvider( const FileProvider & );             // no copy
        FileProvider & operator=( const FileProvider & ); // no assign
        private:
          MediaAccess::constPtr _media;
          Pathname              _file;
          Pathname              _local_file;
        public:
          FileProvider( MediaAccess::constPtr media_r, const Pathname & file_r )
            : _media( media_r )
            , _file( file_r )
            , _local_file( "" )
          {
            if ( _file.empty() ) {
              ZYPP_THROW(MediaBadFilenameException(_file.asString()));
            } else if ( _media ) {
              try {
                _media->provideFile( _file, 0 );
                _local_file = _media->localPath( _file );
              }
              catch (const MediaException & excpt_r)
              {
                ZYPP_CAUGHT(excpt_r);
                _media = NULL;
                ZYPP_RETHROW(excpt_r);
              }
            }
          }
 
          ~FileProvider() {
            if ( _media )
            {
              try {
                _media->releaseFile( _file );
              }
              catch (const MediaException &excpt_r)
              {
                ZYPP_CAUGHT(excpt_r);
              }
              catch(...) {} // No exception from dtor!
            }
          }
 
        public:
 
          Pathname localFile() const { return _local_file; }
 
          Pathname operator()() const {
            if ( _media )
              return _media->localPath( _file );
            return Pathname();
          }
      };
    };
 
    std::ostream & operator<<( std::ostream & str, const MediaAccess & obj );
 
 
  } // namespace media
} // namespace zypp
 
#endif // ZYPP_MEDIA_MEDIAACCESS_H