Repository.h

Go to the documentation of this file.

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

#include <iosfwd>
#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"

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;

    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 asUserString() const
        { return name(); }

        Date generatedTimestamp() const;

        Date suggestedExpirationTimestamp() const;

        Keywords keywords() const;

        bool maybeOutdated() const;

        bool isUpdateRepo() const;

        bool providesUpdatesFor( const std::string &cpeid ) const;

        bool solvablesEmpty() const;

        size_type solvablesSize() const;

        SolvableIterator solvablesBegin() const;

        SolvableIterator solvablesEnd() const;

    public:

      class ProductInfoIterator;

      ProductInfoIterator compatibleWithProductBegin() const;

      ProductInfoIterator compatibleWithProductEnd() const;

      ProductInfoIterator updatesProductBegin() const;

      ProductInfoIterator updatesProductEnd() 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:
        ::_Repo * 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;

        std::string 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; }
    };

    //
    //  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
                           , ::_Repo **                   // Base
                           , Repository                   // Value
                           , boost::forward_traversal_tag // CategoryOrTraversal
                           , Repository                   // Reference
                             >
      {
        public:
          RepositoryIterator()
          : RepositoryIterator::iterator_adaptor_( 0 )
          {}

          explicit RepositoryIterator( ::_Repo ** 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
} // namespace zypp

// Late include as sat::ArrayAttr requires Repository.h
#include "zypp/sat/LookupAttrTools.h"

#endif // ZYPP_SAT_REPOSITORY_H