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