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-core/Globals.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 ZYPP_API Target : public base::ReferenceCounted, public base::NonCopyable
  {
  public:
    using Impl = target::TargetImpl;
    using Impl_Ptr = intrusive_ptr<Impl>;
    using PoolItemList = std::list<PoolItem>;
 
  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 ) ZYPP_LOCAL;
    explicit
    Target( const Impl_Ptr & impl_r ) ZYPP_LOCAL;
 
  private:
    friend std::ostream & operator<<( std::ostream & str, const Target & obj );
    std::ostream & dumpOn( std::ostream & str ) const override;
 
  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