Repository.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_REPOSITORY_H
#define ZYPP_SAT_REPOSITORY_H
 
#include <iosfwd>
#include <zypp/base/Iterator.h>
#include <zypp/Pathname.h>
#include <zypp/sat/detail/PoolMember.h>
#include <zypp/sat/LookupAttr.h>     // LookupAttrTools.h included at EOF
#include <zypp/sat/Solvable.h>
#include <zypp/RepoInfo.h>
#include <zypp/Date.h>
#include <zypp/CpeId.h>
 
namespace zypp
{ 
 
    namespace detail
    {
      struct ByRepository;
    }
 
    //
    //  CLASS NAME : Repository
    //
    class Repository : protected sat::detail::PoolMember
    {
    public:
        typedef filter_iterator<detail::ByRepository, sat::detail::SolvableIterator> SolvableIterator;
        typedef sat::detail::size_type size_type;
        typedef sat::detail::RepoIdType IdType;
 
        typedef sat::ArrayAttr<std::string,std::string> Keywords;
 
        typedef std::string ContentRevision;
        typedef std::string ContentIdentifier;
 
    public:
        Repository()
        : _id( sat::detail::noRepoId ) {}
 
        explicit Repository( IdType id_r )
        : _id( id_r ) {}
 
    public:
        static const Repository noRepository;
 
        explicit operator bool() const
        { return get() != nullptr; }
 
        static const std::string & systemRepoAlias();
 
        bool isSystemRepo() const;
 
    public:
        std::string alias() const;
 
        std::string name() const;
 
        std::string label() const;
 
        std::string asUserString() const
        { return label(); }
 
    public:
        ContentRevision contentRevision() const;
 
        ContentIdentifier contentIdentifier() const;
 
        bool hasContentIdentifier( const ContentIdentifier & id_r ) const;
 
        Date generatedTimestamp() const;
 
        Date suggestedExpirationTimestamp() const;
 
        Keywords keywords() const;
 
        bool hasKeyword( const std::string & val_r ) const;
 
        bool maybeOutdated() const;
 
        bool isUpdateRepo() const;
 
        bool providesUpdatesFor( const CpeId & cpeid_r ) const;
 
        bool solvablesEmpty() const;
 
        size_type solvablesSize() const;
 
        SolvableIterator solvablesBegin() const;
 
        SolvableIterator solvablesEnd() const;
 
        Iterable<SolvableIterator> solvables() const;
 
    public:
 
      class ProductInfoIterator;
 
      ProductInfoIterator compatibleWithProductBegin() const;
 
      ProductInfoIterator compatibleWithProductEnd() const;
 
      Iterable<ProductInfoIterator> compatibleWithProduct() const;
 
 
      ProductInfoIterator updatesProductBegin() const;
 
      ProductInfoIterator updatesProductEnd() const;
 
      Iterable<ProductInfoIterator> updatesProduct() const;
 
    public:
        RepoInfo info() const;
 
        void setInfo( const RepoInfo & info_r );
 
        void clearInfo();
 
    public:
        void eraseFromPool();
 
        struct EraseFromPool;
 
   public:
        Repository nextInPool() const;
 
   public:
        void addSolv( const Pathname & file_r );
 
        void addHelix( const Pathname & file_r );
 
        sat::Solvable::IdType addSolvables( unsigned count_r );
        sat::Solvable::IdType addSolvable()
            { return addSolvables( 1 ); }
 
    public:
        sat::detail::CRepo * get() const;
        IdType id() const { return _id; }
        int satInternalPriority() const;
        int satInternalSubPriority() const;
 
    private:
        IdType _id;
    };
 
    std::ostream & operator<<( std::ostream & str, const Repository & obj );
 
    std::ostream & dumpAsXmlOn( std::ostream & str, const Repository & obj );
 
    inline bool operator==( const Repository & lhs, const Repository & rhs )
    { return lhs.get() == rhs.get(); }
 
    inline bool operator!=( const Repository & lhs, const Repository & rhs )
    { return lhs.get() != rhs.get(); }
 
    inline bool operator<( const Repository & lhs, const Repository & rhs )
    { return lhs.get() < rhs.get(); }
 
 
    class Repository::ProductInfoIterator : public boost::iterator_adaptor<
        Repository::ProductInfoIterator    // Derived
        , sat::LookupAttr::iterator        // Base
        , int                              // Value
        , boost::forward_traversal_tag     // CategoryOrTraversal
        , int                              // Reference
    >
    {
      public:
        ProductInfoIterator()
        {}
 
        std::string label() const;
 
        CpeId cpeId() const;
 
      private:
        friend class Repository;
        explicit ProductInfoIterator( sat::SolvAttr attr_r, Repository repo_r );
 
      private:
        friend class boost::iterator_core_access;
        int dereference() const { return 0; }
    };
 
    inline Iterable<Repository::ProductInfoIterator> Repository::compatibleWithProduct() const
    { return makeIterable( compatibleWithProductBegin(), compatibleWithProductEnd() ); }
 
    inline Iterable<Repository::ProductInfoIterator> Repository::updatesProduct() const
    { return makeIterable( updatesProductBegin(), updatesProductEnd() ); }
 
    //
    //  CLASS NAME : Repository::EraseFromPool
    //
    struct Repository::EraseFromPool
    {
        void operator()( Repository repository_r ) const
            { repository_r.eraseFromPool(); }
    };
 
    namespace detail
    { 
      //
      //        CLASS NAME : RepositoryIterator
      //
      class RepositoryIterator : public boost::iterator_adaptor<
            RepositoryIterator                            // Derived
                           , sat::detail::CRepo **        // Base
                           , Repository                   // Value
                           , boost::forward_traversal_tag // CategoryOrTraversal
                           , Repository                   // Reference
                             >
      {
        public:
          RepositoryIterator()
          : RepositoryIterator::iterator_adaptor_( 0 )
          {}
 
          explicit RepositoryIterator( sat::detail::CRepo ** p )
          : RepositoryIterator::iterator_adaptor_( p )
          {}
 
        private:
          friend class boost::iterator_core_access;
 
          Repository dereference() const
          { return Repository( *base() ); }
 
          void increment();
      };
      //
      //        CLASS NAME : ByRepository
      //
      struct ByRepository
      {
        public:
          ByRepository( const Repository & repository_r ) : _repository( repository_r ) {}
          ByRepository( sat::detail::RepoIdType id_r ) : _repository( id_r ) {}
          ByRepository() {}
 
          bool operator()( const sat::Solvable & slv_r ) const
          { return slv_r.repository() == _repository; }
 
        private:
          Repository _repository;
      };
    } // namespace detail
 
    inline Iterable<Repository::SolvableIterator> Repository::solvables() const
    { return makeIterable( solvablesBegin(), solvablesEnd() ); }
 
} // namespace zypp
 
// Late include as sat::ArrayAttr requires Repository.h
#include <zypp/sat/LookupAttrTools.h>
 
#endif // ZYPP_SAT_REPOSITORY_H