repository.h

Go to the documentation of this file.

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

#include <iosfwd>
#include <zypp-core/base/Iterator.h>
#include <zypp-core/base/Iterable.h>
#include <zypp-core/Pathname.h>
#include <zypp/ng/sat/poolconstants.h>
#include <zypp/ng/sat/poolmember.h>
//#include <zypp/sat/LookupAttr.h>     // LookupAttrTools.h included at EOF
#include <zypp/ng/sat/solvable.h>
//#include <zypp/RepoInfo.h>
#include <zypp-core/Date.h>
#include <zypp/ng/cpeid.h>
#include <zypp-core/ng/base/iterators.h>

namespace zyppng
{ 
  namespace sat
  {
    namespace detail
    {
      struct ByRepository;
    }

    class Repository;

    namespace detail {
      template<> Pool &       poolFromType( Repository & );
      template<> const Pool & poolFromType( const Repository & );
    }

    //
    //  CLASS NAME : Repository
    //
    class Repository : public PoolMember<Repository>
    {
    public:
        using SolvableIterator = zyppng::FilterIterator<detail::ByRepository, sat::detail::SolvableIterator>;
        using SolvableIterable = zypp::Iterable<SolvableIterator>;
        using size_type = unsigned int;
        using IdType = detail::RepoIdType;

        //using Keywords = sat::ArrayAttr<std::string, std::string>;

        using ContentRevision = std::string;
        using ContentIdentifier = std::string;

    public:
        Repository()
        : _id( 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;

        zypp::Date generatedTimestamp() const;

        zypp::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;

        SolvableIterable 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 zypp::Pathname & file_r );

        void addHelix( const zypp::Pathname & file_r );

        void addTesttags(const zypp::Pathname &file_r);

        sat::Solvable::IdType addSolvables( unsigned count_r );
        sat::Solvable::IdType addSolvable()
            { return addSolvables( 1 ); }

    public:
        detail::CRepo * get() const;
        IdType id() const { return _id; }
        int satInternalPriority() const;
        int satInternalSubPriority() const;

    private:
        SolvableIterator solvablesBegin() const;

        SolvableIterator solvablesEnd() 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 == rhs ); }

    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()
        {}

        // Product label
        std::string label() const;

        // The Common Platform Enumeration name for this product.
        CpeId cpeId() const;

      private:
        friend class Repository;
        // Hide ctor as just a limited set of attributes is valid.
        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 RepositoryIterator
      {
        public:
          using iterator_category = std::forward_iterator_tag;
          using value_type        = Repository;
          using difference_type   = std::ptrdiff_t;
          using pointer           = void;
          using reference         = Repository;

          RepositoryIterator()
          : _base( nullptr )
          {}

          explicit RepositoryIterator( sat::detail::CRepo ** p )
          : _base( p )
          {}

          reference operator*() const
          { return Repository( *_base ); }

          RepositoryIterator & operator++()
          { increment(); return *this; }

          RepositoryIterator operator++(int)
          { RepositoryIterator tmp = *this; increment(); return tmp; }

          bool operator==( const RepositoryIterator & rhs ) const
          { return _base == rhs._base; }

          bool operator!=( const RepositoryIterator & rhs ) const
          { return !(*this == rhs); }

          sat::detail::CRepo ** const & base() const
          { return _base; }

        private:
          void increment();

          sat::detail::CRepo ** _base;
      };

      //
      //        CLASS NAME : ByRepository
      //
      struct ByRepository
      {
        public:
          ByRepository( const Repository & repository_r ) : _repository( repository_r ) {}
          ByRepository( sat::detail::RepoIdType id_r ) : _repository( id_r ) {}
          ByRepository() : _repository( detail::noRepoId ) {}

          bool operator()( const sat::Solvable & slv_r ) const
          { return slv_r.repository() == _repository.id(); }

        private:
          Repository _repository;
      };
    } // namespace detail

    inline zypp::Iterable<Repository::SolvableIterator> Repository::solvables() const
    { return zypp::makeIterable( solvablesBegin(), solvablesEnd() ); }

  } // namespace sat
} // namespace zyppng

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

#endif // ZYPP_SAT_REPOSITORY_H