TargetImpl.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_TARGET_TARGETIMPL_H
#define ZYPP_TARGET_TARGETIMPL_H
 
#include <iosfwd>
#include <set>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/PoolItem.h>
#include <zypp/ZYppCommit.h>
 
#include <zypp/Pathname.h>
#include <zypp/Target.h>
#include <zypp/target/rpm/RpmDb.h>
#include <zypp/target/TargetException.h>
#include <zypp/target/RequestedLocalesFile.h>
#include <zypp/target/SolvIdentFile.h>
#include <zypp/target/HardLocksFile.h>
#include <zypp/ManagedFile.h>
#include <zypp/VendorAttr.h>
 
namespace zypp
{ 
  namespace target
  { 
 
    DEFINE_PTR_TYPE(TargetImpl);
    class CommitPackageCache;
 
    //
    //  CLASS NAME : TargetImpl
    //
    class TargetImpl : public base::ReferenceCounted, private base::NonCopyable
    {
      friend std::ostream & operator<<( std::ostream & str, const TargetImpl & obj );
 
    public:
      typedef std::list<PoolItem> PoolItemList;
 
      typedef std::set<PoolItem> PoolItemSet;
 
    public:
      TargetImpl(const Pathname & root_r = "/", bool doRebuild_r = false );
      virtual ~TargetImpl();
 
      void createAnonymousId() const;
 
      void createLastDistributionFlavorCache() const;
 
    private:
      Pathname defaultSolvfilesPath() const;
 
      Pathname solvfilesPath() const
      { return solvfilesPathIsTemp() ? _tmpSolvfilesPath : defaultSolvfilesPath(); }
 
      bool solvfilesPathIsTemp() const
      { return ! _tmpSolvfilesPath.empty(); }
 
      Pathname _tmpSolvfilesPath;
 
    public:
      void load( bool force = true );
 
      void unload();
 
      void reload();
 
      void clearCache();
 
      bool buildCache();
 
    public:
 
      Pathname root() const
      { return _root; }
 
      Pathname home() const
      { return home( _root ); }
 
      static Pathname home( const Pathname & root_r )
      { return root_r / "/var/lib/zypp"; }
 
      ZYppCommitResult commit( ResPool pool_r, const ZYppCommitPolicy & policy_r );
 
      void installSrcPackage( const SrcPackage_constPtr & srcPackage_r );
 
      ManagedFile provideSrcPackage( const SrcPackage_constPtr & srcPackage_r );
 
      virtual std::ostream & dumpOn( std::ostream & str ) const
      { return str << "Target(" << root() << ")"; }
 
      rpm::RpmDb & rpm();
 
      bool providesFile (const std::string & path_str, const std::string & name_str) const;
 
      std::string whoOwnsFile (const std::string & path_str) const
      { return _rpm.whoOwnsFile (path_str); }
 
      Product::constPtr baseProduct() const;
 
      LocaleSet requestedLocales() const
      { return _requestedLocalesFile.locales(); }
      static LocaleSet requestedLocales( const Pathname & root_r );
 
      void updateAutoInstalled();
 
      std::string targetDistribution() const;
      static std::string targetDistribution( const Pathname & root_r );
 
      std::string targetDistributionRelease() const;
      static std::string targetDistributionRelease( const Pathname & root_r );
 
      std::string targetDistributionFlavor() const;
      static std::string targetDistributionFlavor( const Pathname & root_r );
 
      Target::DistributionLabel distributionLabel() const;
      static Target::DistributionLabel distributionLabel( const Pathname & root_r );
 
      std::string distributionVersion() const;
      static std::string distributionVersion( const Pathname & root_r );
 
      std::string distributionFlavor() const;
      static std::string distributionFlavor( const Pathname & root_r );
 
      std::string anonymousUniqueId() const;
      static std::string anonymousUniqueId( const Pathname & root_r );
 
      const VendorAttr & vendorAttr() const
      { return _vendorAttr; }
      void vendorAttr( VendorAttr vendorAttr_r );
 
  public:
    private:
      void commit( const ZYppCommitPolicy & policy_r,
                   CommitPackageCache & packageCache_r,
                   ZYppCommitResult & result_r );
 
      void commitInSingleTransaction( const ZYppCommitPolicy & policy_r,
        CommitPackageCache & packageCache_r,
        ZYppCommitResult & result_r );
 
 
      void commitFindFileConflicts( const ZYppCommitPolicy & policy_r, ZYppCommitResult & result_r );
    protected:
      Pathname _root;
      rpm::RpmDb _rpm;
      RequestedLocalesFile _requestedLocalesFile;
      SolvIdentFile _autoInstalledFile;
      HardLocksFile _hardLocksFile;
      mutable std::string _distributionVersion;
      VendorAttr _vendorAttr;
    };
 
    inline std::ostream & operator<<( std::ostream & str, const TargetImpl & obj )
    {
      return obj.dumpOn( str );
    }
 
  } // namespace target
} // namespace zypp
#endif // ZYPP_TARGET_TARGETIMPL_H