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 ZYPP_API Repository : protected sat::detail::PoolMember
    {
    public:
        using SolvableIterator = filter_iterator<detail::ByRepository, sat::detail::SolvableIterator>;
        using size_type = sat::detail::size_type;
        using IdType = sat::detail::RepoIdType;
 
        using Keywords = sat::ArrayAttr<std::string, std::string>;
 
        using ContentRevision = std::string;
        using ContentIdentifier = std::string;
 
    public:
        Repository()
        : _id( sat::detail::noRepoId ) {}
 
        Repository(const Repository &) = default;
        Repository(Repository &&) noexcept = default;
        Repository &operator=(const Repository &) = default;
        Repository &operator=(Repository &&) noexcept = default;

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

        void addTesttags(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 ) ZYPP_API;

    std::ostream & dumpAsXmlOn( std::ostream & str, const Repository & obj ) ZYPP_API;

    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 ZYPP_API 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