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;

  public:
    bool isTargetDistribution() const;

    std::string registerTarget() const;

    std::string registerRelease() 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