SourceImpl.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"
#include "zypp/base/ProvideNumericId.h"

#include "zypp/Source.h"
#include "zypp/ResStore.h"
#include "zypp/Pathname.h"
#include "zypp/media/MediaManager.h"
#include "zypp/source/MediaSet.h"

namespace zypp
{ 

  namespace source
  { 

    DEFINE_PTR_TYPE(SourceImpl);

    //
    //  CLASS NAME : SourceImpl
    //
    class SourceImpl : public base::ReferenceCounted
                     , public base::ProvideNumericId<SourceImpl,Source_Ref::NumericId>
                     , private base::NonCopyable
    {
      media::MediaManager media_mgr;

      friend std::ostream & operator<<( std::ostream & str, const SourceImpl & obj );

    public:
      void factoryCtor( const media::MediaId & media_r,
                        const Pathname & path_r = "/",
                        const std::string & alias_r = "",
                        const Pathname cache_dir_r = "",
                        const bool base_source = false);

      class Verifier;

    public:

      const ResStore & resolvables(Source_Ref) const
      { return resolvables(); }
      const ResStore & resolvables() const;
      const ResStore resolvables(zypp::Resolvable::Kind kind) const;

      const Pathname provideFile(const Pathname & file,
                                 const unsigned media_nr = 1,
                                 bool cached = false,
                                 bool checkonly = false);
      const Pathname tryToProvideFile( const Pathname & file, const unsigned media_nr = 1 );

      const Pathname provideDirTree(const Pathname & path,
                                const unsigned media_nr = 1);

      const void releaseFile(const Pathname & file_r,
                             const unsigned media_nr = 1);

      const void releaseDir(const Pathname & path_r,
                            const unsigned media_nr = 1,
                            const bool recursive = false);

      const Pathname providePackage( Package::constPtr package );
      const Pathname providePackageInteractive( Package::constPtr package );
      
      void dirInfo( const unsigned media_nr,
                    std::list<std::string> &retlist,
                    const Pathname         &path_r,
                    bool                    dots = true) const;

      void changeMedia(const media::MediaId & media_r, const Pathname & path_r);

      const bool enabled() const
      { return _enabled; }

      void enable();

      void disable()
      { _enabled = false; }

      const bool autorefresh() const
      { return _autorefresh; }

      void setAutorefresh( const bool enable_r )
      { _autorefresh = enable_r; }

      void refresh();

      virtual void storeMetadata(const Pathname & cache_dir_r);

      std::string alias (void) const
      { return _alias; }

      void setAlias (const std::string & alias)
      { _alias = alias; }

      virtual std::string id (void) const;
      virtual void setId (const std::string id_r);
      virtual unsigned priority (void) const;
      virtual void setPriority (unsigned p);
      virtual unsigned priorityUnsubscribed (void) const;
      virtual void setPriorityUnsubscribed (unsigned p);
      virtual bool subscribed (void) const;
      virtual void setSubscribed (bool s);
      virtual const Pathname & cacheDir (void);
      virtual const std::list<Pathname> publicKeys();

      virtual std::string type(void) const;

      Url url (void) const;
      void setUrl( const Url & url );
      bool remote () const;
      bool baseSource () const
      { return _base_source; }

      const Pathname & path (void) const;

      virtual unsigned numberOfMedia(void) const;

      virtual std::string vendor (void) const;

      virtual std::string unique_id (void) const;

      virtual std::string zmdName (void) const;
      virtual void setZmdName (const std::string name_r);
      virtual std::string zmdDescription (void) const;
      virtual void setZmdDescription (const std::string desc_r);

      virtual void redirect(unsigned media_nr, const Url & new_url);
      void reattach(const Pathname &attach_point);
      void release();

      virtual media::MediaVerifierRef verifier(unsigned media_nr);

    protected:
      Source_Ref selfSourceRef()
      { return Source_Ref( this ); }

      const Pathname provideJustFile(const Pathname & path,
                                 const unsigned media_nr = 1,
                                 bool cached = false,
                                 bool checkonly = false);


    protected:
      ResStore _store;
      Url _url;
      Pathname _path;
      bool _enabled;
      bool _autorefresh;
      std::string _alias;
      Pathname _cache_dir;
      std::string _id;
      unsigned _priority;
      unsigned _priority_unsubscribed;
      bool _subscribed;
      bool _base_source;

      // no playground below this line ;)
    protected:
      SourceImpl();

      virtual void factoryInit();

      virtual ~SourceImpl();

      virtual std::ostream & dumpOn( std::ostream & str ) const;

      intrusive_ptr<MediaSet> _media_set;

    private:
      virtual void createResolvables(Source_Ref source_r);

      virtual ResStore provideResolvables(Source_Ref source_r, zypp::Resolvable::Kind kind);

      bool _res_store_initialized;

    private:
      struct null {};

      SourceImpl( const null & )
      : base::ProvideNumericId<SourceImpl,Source_Ref::NumericId>( NULL )
      , _res_store_initialized(true)
      {}

    public:
      static SourceImpl_Ptr nullimpl()
      {
        static SourceImpl_Ptr _nullimpl( new SourceImpl( null() ) );
        return _nullimpl;
      }

    };

    inline std::ostream & operator<<( std::ostream & str, const SourceImpl & obj )
    { return obj.dumpOn( str ); }


    class SourceImpl::Verifier : public media::MediaVerifierBase
      {
      public:
        Verifier (const std::string & vendor_r, const std::string & id_r, const media::MediaNr media_nr = 1);
        /*
         ** Check if the specified attached media contains
         ** the desired media number (e.g. SLES10 CD1).
         */
        virtual bool
        isDesiredMedia(const media::MediaAccessRef &ref);

      private:
        std::string _media_vendor;
        std::string _media_id;
        media::MediaNr _media_nr;
        SourceImpl_Ptr _source;
      };

  } // namespace source
} // namespace zypp
#endif // ZYPP_SOURCE_SOURCEIMPL_H

---