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
{ 
  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 ); }

    Date timestamp() const;

    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:
    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