MediaSource.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_MEDIA_MEDIASOURCE_H
#define ZYPP_MEDIA_MEDIASOURCE_H
 
#include <iosfwd>
 
#include <zypp/Pathname.h>
#include <zypp/base/String.h>
#include <zypp/base/PtrTypes.h>
 
 
namespace zypp {
  namespace media {
 
 
    typedef unsigned int MediaAccessId;
 
 
 
    class MediaSource
    {
    public:
      MediaSource(const std::string &_type,  const std::string &_name,
                  unsigned int       _maj=0, unsigned int       _min=0,
                  const std::string &_bdir=std::string(), bool  _own=true)
        : maj_nr(_maj)
        , min_nr(_min)
        , type(_type)
        , name(_name)
        , bdir(_bdir)
        , iown(_own)
      {}
 
      MediaSource()
        : maj_nr(0)
        , min_nr(0)
      {}
 
      virtual
      ~MediaSource()
      {}
 
      virtual bool equals(const MediaSource &src) const
      {
        if( type == src.type)
        {
          if( maj_nr == 0)
            return name == src.name;
          else
            return maj_nr == src.maj_nr &&
                   min_nr == src.min_nr;
        }
        return false;
      }
 
      virtual std::string asString() const
      {
        std::string tmp1;
        if(maj_nr != 0)
        {
          tmp1 = "[" + str::numstring(maj_nr) + "," +
                       str::numstring(min_nr) + "]";
        }
        return type + "<" + name + tmp1 + ">";
      }
 
      unsigned int maj_nr;  
      unsigned int min_nr;  
      std::string  type;    
      std::string  name;    
      std::string  bdir;    
      bool         iown;    
    };
 
    inline std::ostream & operator<<( std::ostream & str, const MediaSource & obj )
    { return str << obj.asString(); }
 
 
    class AttachPoint
    {
    public:
      AttachPoint(const Pathname &_path=Pathname(),
                  bool            _temp=true)
        : path(_path)
        , temp(_temp)
      {}
 
      bool empty() const { return path.empty(); }
 
      Pathname path;    
      bool     temp;    
    };
 
    std::ostream & operator<<( std::ostream & str, const AttachPoint & obj );
 
    typedef zypp::RW_pointer<MediaSource> MediaSourceRef;
    typedef zypp::RW_pointer<AttachPoint> AttachPointRef;
 
 
 
    struct AttachedMedia
    {
      AttachedMedia()
      {}
 
      AttachedMedia(const MediaSourceRef &_mediaSource,
                    const AttachPointRef &_attachPoint)
        : mediaSource( _mediaSource)
        , attachPoint( _attachPoint)
      {}
 
      MediaSourceRef mediaSource;
      AttachPointRef attachPoint;
    };
 
    std::ostream & operator<<( std::ostream & str, const AttachedMedia & obj );
 
  } // namespace media
} // namespace zypp
 
 
#endif // ZYPP_MEDIA_MEDIASOURCE_H