pool.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
----------------------------------------------------------------------/
*
* This file contains private API, this might break at any time between releases.
* You have been warned!
*
*/
#ifndef ZYPPNG_SAT_POOL_H_INCLUDED
#define ZYPPNG_SAT_POOL_H_INCLUDED

#include <zypp-core/base/NonCopyable.h>
#include <zypp-core/Pathname.h>
#include <zypp-core/base/Iterable.h>

#include <zypp/ng/arch.h>
#include <zypp/ng/sat/poolconstants.h>
#include <zypp/ng/sat/components/poolcomponents.h>
#include <zypp/ng/base/serialnumber.h>
#include <zypp/ng/sat/repository.h>
#include <zypp/ng/sat/solvable.h>
#include <zypp/ng/sat/queue.h>
#include <zypp/ng/sat/preparedpool.h>

namespace zyppng::sat {

  class Pool
  {
      friend class Repository;
      friend class Solvable;

    public:
      using RepositoryIterable = zypp::Iterable<detail::RepositoryIterator>;
      using SolvableIterable   = zypp::Iterable<detail::SolvableIterator>;

    public:

      Pool();

      Pool(const Pool &) = delete;
      Pool(Pool &&) = delete;
      Pool &operator=(const Pool &) = delete;
      Pool &operator=(Pool &&) = delete;

      ~Pool();

      detail::CPool * get() const
      { return _pool; }

      const SerialNumber & serial() const
      { return _serial; }

      const SerialNumber & serialIDs() const
      { return _serialIDs; }

      PreparedPool prepare();


      detail::size_type capacity() const;

      void setDirty( PoolInvalidation invalidation, std::initializer_list<std::string_view> reasons );

      void clear();

    public:
      static const std::string & systemRepoAlias();

      Repository reposFind( const std::string & alias_r ) const;

      Repository reposInsert( const std::string & alias_r );

      void reposErase( const std::string & alias_r )
      { reposFind( alias_r ).eraseFromPool(); }

      void reposEraseAll()
      { while ( ! reposEmpty() ) reposErase( (*repos().begin()).alias() ); }

      bool reposEmpty() const;

      detail::size_type reposSize() const;

      RepositoryIterable repos() const;

      Repository findSystemRepo() const;

      Repository systemRepo();

      bool isSystemRepo( detail::CRepo * repo_r ) const
      { return repo_r && _pool->installed == repo_r; }

    private:
      detail::CRepo * _systemRepoPtr() const
      { return _pool->installed; }

    public:
      bool solvablesEmpty() const;

      detail::size_type solvablesSize() const;

      SolvableIterable solvables() const;

    public:
      zypp::Pathname rootDir() const
      {
        const char * rd = ::pool_get_rootdir( _pool );
        return( rd ? rd : "/" );
      }

      void rootDir( const zypp::Pathname & root_r )
      {
        if ( root_r.empty() || root_r == "/" )
          ::pool_set_rootdir( _pool, nullptr );
        else
          ::pool_set_rootdir( _pool, root_r.c_str() );
      }

    private:
      detail::CRepo * _createRepo( const std::string & name_r );

      void _deleteRepo( detail::CRepo * repo_r );

      int _addSolv( detail::CRepo * repo_r, FILE * file_r );

      int _addHelix( detail::CRepo * repo_r, FILE * file_r );

      int _addTesttags( detail::CRepo * repo_r, FILE * file_r );

      detail::SolvableIdType _addSolvables( detail::CRepo * repo_r, unsigned count_r );

      void _postRepoAdd( detail::CRepo * repo_r );

      bool validSolvable( const detail::CSolvable & slv_r ) const
      { return slv_r.repo; }
      bool validSolvable( detail::SolvableIdType id_r ) const
      { return id_r < unsigned(_pool->nsolvables) && validSolvable( _pool->solvables[id_r] ); }
      bool validSolvable( const detail::CSolvable * slv_r ) const
      { return _pool->solvables <= slv_r && slv_r <= _pool->solvables+_pool->nsolvables && validSolvable( *slv_r ); }

      detail::CPool * getPool() const
      { return _pool; }

      detail::CRepo * getRepo( detail::RepoIdType id_r ) const
      { return id_r; }

      detail::CSolvable * getSolvable( detail::SolvableIdType id_r ) const
      {
        if ( validSolvable( id_r ) )
          return &_pool->solvables[id_r];
        return 0;
      }

    public:
      detail::IdType parserpmrichdep( const char * capstr_r )
      { return ::pool_parserpmrichdep( _pool, capstr_r ); }

      detail::SolvableIdType getFirstId()  const
      { return getNextId( 1 ); }

      detail::SolvableIdType getNextId( detail::SolvableIdType id_r ) const
      {
        for( ++id_r; id_r < unsigned(_pool->nsolvables); ++id_r )
        {
          if ( validSolvable( _pool->solvables[id_r] ) )
            return id_r;
        }
        return detail::noSolvableId;
      }

      PoolComponentSet & components() { return _componentsSet; }
      const PoolComponentSet & components() const { return _componentsSet; }

      template <typename T>
      T & component() { return _componentsSet.assertComponent<T>(); }

      template <typename T>
      const T * findComponent() const { return _componentsSet.findComponent<T>(); }

    private:
      detail::CPool * _pool;
      SerialNumber _serial;
      SerialNumber _serialIDs;
      SerialNumberWatcher _watcher;
      PoolComponentSet _componentsSet;
#ifndef NDEBUG

      bool _preparing = false;
#endif
  };
}

#endif