Product.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_PRODUCT_H
#define ZYPP_PRODUCT_H
 
#include <list>
#include <string>
 
#include <zypp/ResObject.h>
 
namespace zypp
{ 
 
  DEFINE_PTR_TYPE(Product);
 
  //
  //    CLASS NAME : Product
  //
  class Product : public ResObject
  {
  public:
    typedef Product                  Self;
    typedef ResTraits<Self>          TraitsType;
    typedef TraitsType::PtrType      Ptr;
    typedef TraitsType::constPtrType constPtr;
 
  public:
    sat::Solvable referencePackage() const;
 
    std::string referenceFilename() const;
 
    CapabilitySet droplist() const;
 
  public:
    /***/
    typedef std::vector<constPtr> ReplacedProducts;
 
    ReplacedProducts replacedProducts() const;
 
    std::string productLine() const;
 
  public:
    std::string shortName() const;
 
    std::string flavor() const;
 
    std::string type() const;
 
    std::list<std::string> flags() const;
 
    Date endOfLife() const;
 
    bool hasEndOfLife() const;
    bool hasEndOfLife( Date & value ) const;
 
    std::vector<Repository::ContentIdentifier> updateContentIdentifier() const;
 
    bool hasUpdateContentIdentifier( const Repository::ContentIdentifier & cident_r ) const;
 
    template <class TIterator>
    bool hasUpdateContentIdentifier( TIterator begin, TIterator end ) const
    {
      for_( it, begin, end )
        if ( hasUpdateContentIdentifier( *it ) )
          return true;
      return false;
    }
 
  public:
    bool isTargetDistribution() const;
 
    std::string registerTarget() const;
 
    std::string registerRelease() const;
 
    std::string registerFlavor() const;
 
  public:
    /***/
    class UrlList;
 
    UrlList urls( const std::string & key_r ) const;
 
    UrlList releaseNotesUrls() const;
 
    UrlList registerUrls() const;
 
    UrlList smoltUrls() const;
 
    UrlList updateUrls() const;
 
    UrlList extraUrls() const;
 
    UrlList optionalUrls() const;
 
  protected:
    friend Ptr make<Self>( const sat::Solvable & solvable_r );
    Product( const sat::Solvable & solvable_r );
    virtual ~Product();
  };
 
  class Product::UrlList
  {
    private:
      typedef std::list<Url> ListType;
 
    public:
      typedef ListType::value_type     value_type;
      typedef ListType::size_type      size_type;
      typedef ListType::const_iterator const_iterator;
 
      bool empty() const
      { return _list.empty(); }
 
      size_type size() const
      { return _list.size(); }
 
      const_iterator begin() const
      { return _list.begin(); }
 
      const_iterator end() const
      { return _list.end(); }
 
      Url first() const
      { return empty() ? value_type() : _list.front(); }
 
    public:
      std::string key() const
      { return _key; }
 
    private:
      friend class Product;
      std::string _key;
      ListType    _list;
  };
 
  std::ostream & operator<<( std::ostream & str, const Product::UrlList & obj );
 
} // namespace zypp
#endif // ZYPP_PRODUCT_H