Target.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_TARGET_H
#define ZYPP_TARGET_H
 
#include <iosfwd>
 
#include <zypp/base/ReferenceCounted.h>
#include <zypp/base/NonCopyable.h>
#include <zypp/base/PtrTypes.h>
#include <zypp/APIConfig.h>
 
#include <zypp/Product.h>
#include <zypp/Pathname.h>
#include <zypp/ResPool.h>
 
namespace zypp
{ 
  class VendorAttr;
  namespace target
  {
    class TargetImpl;
    namespace rpm {
      class RpmDb;
    }
  }
  namespace zypp_detail
  {
    class ZYppImpl;
  }
 
  DEFINE_PTR_TYPE(Target);
 
  //
  //    CLASS NAME : Target
  //
  class Target : public base::ReferenceCounted, public base::NonCopyable
  {
  public:
    typedef target::TargetImpl  Impl;
    typedef intrusive_ptr<Impl> Impl_Ptr;
    typedef std::list<PoolItem> PoolItemList;
 
  public:
 
    void buildCache();
 
    void cleanCache();
 
    void load();
 
    void reload();
 
    void unload();
 
    target::rpm::RpmDb & rpmDb();
 
    bool providesFile (const std::string & name_str, const std::string & path_str) const;
 
    std::string whoOwnsFile (const std::string & path_str) const;
 
    Pathname root() const;
 
    bool chrooted() const
    { return( ! root().emptyOrRoot() ); }
 
    Pathname assertRootPrefix( const Pathname & path_r ) const
    { return Pathname::assertprefix( root(), path_r ); }
 
    Product::constPtr baseProduct() const;
 
    LocaleSet requestedLocales() const;
    static LocaleSet requestedLocales( const Pathname & root_r );
 
    void updateAutoInstalled();
 
  public:
    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 );
 
    struct DistributionLabel { std::string shortName; std::string summary; };
    DistributionLabel distributionLabel() const;
    static 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 );
 
  public:
    const VendorAttr & vendorAttr() const;
    void vendorAttr( VendorAttr vendorAttr_r );
 
  public:
    explicit
    Target( const Pathname & root = "/", bool doRebuild_r = false );
    explicit
    Target( const Impl_Ptr & impl_r );
 
  private:
    friend std::ostream & operator<<( std::ostream & str, const Target & obj );
    std::ostream & dumpOn( std::ostream & str ) const;
 
  private:
    friend class zypp_detail::ZYppImpl;
 
    RW_pointer<Impl,rw_pointer::Intrusive<Impl> > _pimpl;
  };
 
  inline std::ostream & operator<<( std::ostream & str, const Target & obj )
  { return obj.dumpOn( str ); }
 
  std::ostream & operator<<( std::ostream & str, const Target::DistributionLabel & obj );
 
} // namespace zypp
#endif // ZYPP_TARGET_H