MediaSource.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_MEDIA_MEDIASOURCE_H
#define ZYPP_MEDIA_MEDIASOURCE_H

#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;    
    };



    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;    
    };


    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;
    };


  } // namespace media
} // namespace zypp


#endif // ZYPP_MEDIA_MEDIASOURCE_H

---