SuseTagsImpl.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <string>

#include "zypp/Pathname.h"
#include "zypp/source/SourceImpl.h"
#include "zypp/Product.h"
#include "zypp/CheckSum.h"
#include "zypp/source/susetags/SuseTagsProductImpl.h"
#include "zypp/source/susetags/SuseTagsPackageImpl.h"

namespace zypp
{ 

  namespace source
  { 

    namespace susetags
    { 

      struct SuseTagsPackageImplData
      {
        SuseTagsPackageImplData()
        {
        }
        
        TranslatedText _summary;
        TranslatedText _description;
        TranslatedText _insnotify;
        TranslatedText _delnotify;
        License _license_to_confirm;
        std::list<std::string> _authors;
      };
      
      //
      //        CLASS NAME : SuseTagsImpl
      //
      class SuseTagsImpl : public SourceImpl
      {
      public:
        typedef intrusive_ptr<SuseTagsImpl>       Ptr;
        typedef intrusive_ptr<const SuseTagsImpl> constPtr;

      public:
        SuseTagsImpl();
        ~SuseTagsImpl();

      public:
        virtual void createResolvables(Source_Ref source_r);

        virtual ResStore provideResolvables(Source_Ref source_r, zypp::Resolvable::Kind kind);
        
        virtual std::string type(void) const
        { return typeString(); }

        static std::string typeString(void)
        { return "YaST"; }
        
        virtual unsigned numberOfMedia(void) const;
        virtual std::string vendor (void) const;
        virtual const std::list<Pathname> publicKeys();
        virtual std::string unique_id (void) const;
        
        Pathname sourceDir( const std::string & dir );
        virtual void storeMetadata(const Pathname & cache_dir_r);
        
        virtual media::MediaVerifierRef verifier(media::MediaNr media_nr);

      protected:
        virtual std::ostream & dumpOn( std::ostream & str ) const;
        void initCacheDir(const Pathname & cache_dir_r);
        bool cacheExists();
      private:
        virtual void factoryInit();
        
        void readContentFile();
        
        void provideProducts(Source_Ref source_r, ResStore& store);
        void providePackages(Source_Ref source_r, ResStore& store);
        void provideSelections(Source_Ref source_r, ResStore& store);
        void provideSelection(Source_Ref source_r, ResStore& store);
        void providePatterns(Source_Ref source_r, ResStore& store);
        
        bool verifyChecksumsMode();
        
        void verifyFile( const Pathname &path, const std::string &key);
        
        unsigned _media_count;
        
        // descr dir we are using
        // depends if we are on media or
        // cache
        Pathname _descr_dir;
        Pathname _data_dir;
        
        // descr dir on media.
        // we need it if we refresh
        // already running from cache
        Pathname _orig_descr_dir;
        
        Pathname _content_file;
        Pathname _content_file_sig;
        Pathname _content_file_key;
        
        std::string _vendor;
        std::string _media_id;
        detail::ResImplTraits<SuseTagsProductImpl>::Ptr _prodImpl;
        Product::Ptr _product;       
        public:
        
        // shared data between packages with same NVRA
        std::map<NVRA, SuseTagsPackageImplData> _package_data;
        // list of packages which depend on another package for its data
        std::map<NVRA, bool> _is_shared;
        
        // list of translation files
        std::list<std::string> _pkg_translations;
      };

    } // namespace susetags

    using susetags::SuseTagsImpl;

  } // namespace source
} // namespace zypp
#endif // ZYPP_SOURCE_SUSETAGS_SUSETAGSIMPL_H

---