PoolImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_SAT_DETAIL_POOLIMPL_H
#define ZYPP_SAT_DETAIL_POOLIMPL_H
extern "C"
{
#include <solv/pool.h>
#include <solv/repo.h>
#include <solv/solvable.h>
#include <solv/poolarch.h>
#include <solv/repo_solv.h>
#include <solv/pool_parserpmrichdep.h>
}
#include <iosfwd>
#include <set>
#include <vector>
 
#include <zypp-core/base/Hash.h>
#include <zypp-core/base/NonCopyable.h>
#include <zypp/base/SerialNumber.h>
#include <zypp/base/SetTracker.h>
#include <zypp/sat/detail/PoolMember.h>
#include <zypp/sat/SolvableSpec.h>
#include <zypp/sat/Queue.h>
 
#ifndef ZYPPNG
#include <zypp/RepoInfo.h>
#endif
 
#include <zypp/Locale.h>
#include <zypp/Capability.h>
#include <zypp/IdString.h>

namespace zypp
{ 
  namespace sat
  { 
    class SolvableSet;
    namespace detail
    { 

      //
      //        CLASS NAME : PoolImpl
      //
      class PoolImpl : private base::NonCopyable
      {
        public:
          PoolImpl();

          ~PoolImpl();

          CPool * operator->()
          { return _pool; }
 
        public:
          const SerialNumber & serial() const
          { return _serial; }

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

          void prepare() const;

          bool mapSnapshot( const Pathname & path_r, const std::string & cookie_r );
          void setSnapshotCandidate( const Pathname & path_r, const std::string & cookie_r, const std::vector<std::string> & aliases_r )
          { _snapshotPath = path_r; _snapshotCookie = cookie_r; _snapshotAliases = aliases_r; }
          void snapshotWriteIfNeeded() const;
          unsigned & snapshotClaimingRef() const
          { return _snapshotClaiming; }
 
 
        private:
          void setDirty( const char * a1 = 0, const char * a2 = 0, const char * a3 = 0 );

          void localeSetDirty( const char * a1 = 0, const char * a2 = 0, const char * a3 = 0 );

          void depSetDirty( const char * a1 = 0, const char * a2 = 0, const char * a3 = 0 );

          static detail::IdType nsCallback( CPool *, void * data, detail::IdType lhs, detail::IdType rhs );
 
        public:
          static const std::string & systemRepoAlias();
 
          bool isSystemRepo( CRepo * repo_r ) const
          { return repo_r && _pool->installed == repo_r; }
 
          CRepo * systemRepo() const
          { return _pool->installed; }

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

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

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

          void _deleteRepo( CRepo * repo_r );

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

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

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

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

          void _postRepoAdd( CRepo * repo_r );
 
        public:
          bool validSolvable( const CSolvable & slv_r ) const
          { return slv_r.repo; }

          bool validSolvable( SolvableIdType id_r ) const
          { return id_r < unsigned(_pool->nsolvables) && validSolvable( _pool->solvables[id_r] ); }

          bool validSolvable( const CSolvable * slv_r ) const
          { return _pool->solvables <= slv_r && slv_r <= _pool->solvables+_pool->nsolvables && validSolvable( *slv_r ); }
 
        public:
          CPool * getPool() const
          { return _pool; }

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

          CSolvable * getSolvable( SolvableIdType id_r ) const
          {
            if ( validSolvable( id_r ) )
              return &_pool->solvables[id_r];
            return 0;
          }
 
        public:
          sat::detail::IdType parserpmrichdep( const char * capstr_r )
          { return ::pool_parserpmrichdep( _pool, capstr_r ); }
 
        public:
          SolvableIdType getFirstId()  const
          { return getNextId( 1 ); }

          SolvableIdType getNextId( SolvableIdType id_r ) const
          {
            for( ++id_r; id_r < unsigned(_pool->nsolvables); ++id_r )
            {
              if ( validSolvable( _pool->solvables[id_r] ) )
                return id_r;
            }
            return noSolvableId;
          }
 
#ifndef ZYPPNG
        public:
          const RepoInfo & repoInfo( RepoIdType id_r )
          { return _repoinfos[id_r]; }

          void setRepoInfo( RepoIdType id_r, const RepoInfo & info_r );
          void eraseRepoInfo( RepoIdType id_r )
          { _repoinfos.erase( id_r ); }
#endif
 
        public:
          const sat::detail::IdType whatProvidesData( unsigned offset_r )
          { return _pool->whatprovidesdata[offset_r]; }

          unsigned whatProvides( Capability cap_r )
          { prepare(); return ::pool_whatprovides( _pool, cap_r.id() ); }
 
        public:


          void setTextLocale( const Locale & locale_r );
 

          void initRequestedLocales( const LocaleSet & locales_r );

          const LocaleSet & getAddedRequestedLocales() const
          { return _requestedLocalesTracker.added(); }

          const LocaleSet & getRemovedRequestedLocales() const
          { return _requestedLocalesTracker.removed(); }

          const LocaleSet & getRequestedLocales() const
          { return _requestedLocalesTracker.current(); }
 
          bool isRequestedLocale( const Locale & locale_r ) const
          { return _requestedLocalesTracker.contains( locale_r ); }

          void setRequestedLocales( const LocaleSet & locales_r );
          bool addRequestedLocale( const Locale & locale_r );
          bool eraseRequestedLocale( const Locale & locale_r );

          const LocaleSet & getAvailableLocales() const;
 
          bool isAvailableLocale( const Locale & locale_r ) const
          {
            const LocaleSet & avl( getAvailableLocales() );
            LocaleSet::const_iterator it( avl.find( locale_r ) );
            return it != avl.end();
          }
 
          typedef base::SetTracker<IdStringSet> TrackedLocaleIds;

          const TrackedLocaleIds & trackedLocaleIds() const;
 
        public:
          typedef SolvableSet MultiversionList;
 
          const MultiversionList & multiversionList() const;
 
          bool isMultiversion( const Solvable & solv_r ) const;
 
          void multiversionSpecChanged();
 
        public:

          StringQueue autoInstalled() const
          { return _autoinstalled; }

          void setAutoInstalled( const StringQueue & autoInstalled_r )
          { _autoinstalled = autoInstalled_r; }
 
          bool isOnSystemByUser( IdString ident_r ) const
          { return !_autoinstalled.contains( ident_r.id() ); }
 
          bool isOnSystemByAuto( IdString ident_r ) const
          { return _autoinstalled.contains( ident_r.id() ); }

 
        public:

          void setNeedrebootSpec( sat::SolvableSpec needrebootSpec_r )
          {
            _needrebootSpec = std::move(needrebootSpec_r);
            _needrebootSpec.setDirty();
          }

          bool isNeedreboot( const Solvable & solv_r ) const
          { return _needrebootSpec.contains( solv_r ); }

 
        public:
          bool isRetracted( const Solvable & solv_r ) const
          { return _retractedSpec.contains( solv_r ); }
          bool isPtfMaster( const Solvable & solv_r ) const
          { return _ptfMasterSpec.contains( solv_r ); }
          bool isPtfPackage( const Solvable & solv_r ) const
          { return _ptfPackageSpec.contains( solv_r ); }

 
        public:
          const std::set<std::string> & requiredFilesystems() const;
 
        private:
          CPool * _pool;
          SerialNumber _serial;
          mutable std::string _snapshotCookie;
          mutable Pathname _snapshotPath;
          mutable std::vector<std::string> _snapshotAliases;
          mutable std::set<RepoIdType> _snapshotUnclaimed;
          mutable bool _snapshotFileProvides = false;
          mutable unsigned _snapshotClaiming = 0;
          SerialNumber _serialIDs;
          SerialNumberWatcher _watcher;
 
#ifndef ZYPPNG
          std::map<RepoIdType,RepoInfo> _repoinfos;
#endif

          base::SetTracker<LocaleSet> _requestedLocalesTracker;
          mutable scoped_ptr<TrackedLocaleIds> _trackedLocaleIdsPtr;
 
          mutable scoped_ptr<LocaleSet> _availableLocalesPtr;

          void multiversionListInit() const;
          mutable scoped_ptr<MultiversionList> _multiversionListPtr;

          sat::StringQueue _autoinstalled;

          sat::SolvableSpec _needrebootSpec;

          sat::SolvableSpec _retractedSpec;
          sat::SolvableSpec _ptfMasterSpec;
          sat::SolvableSpec _ptfPackageSpec;

          mutable scoped_ptr<std::set<std::string> > _requiredFilesystemsPtr;
      };


    } // namespace detail
  } // namespace sat
} // namespace zypp
#define POOL_SETDIRTY
#endif // ZYPP_SAT_DETAIL_POOLIMPL_H