PMSolvable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                                                                      |
|                      __   __    ____ _____ ____                      |
|                      \ \ / /_ _/ ___|_   _|___ \                     |
|                       \ V / _` \___ \ | |   __) |                    |
|                        | | (_| |___) || |  / __/                     |
|                        |_|\__,_|____/ |_| |_____|                    |
|                                                                      |
|                               core system                            |
|                                                        (C) SuSE GmbH |
\----------------------------------------------------------------------/

   File:       PMSolvable.h

   Author:     Michael Andres <ma@suse.de>
   Maintainer: Michael Andres <ma@suse.de>

/-*/
#ifndef PMSolvable_h
#define PMSolvable_h

#include <iosfwd>
#include <list>

#include <y2pm/PMSolvablePtr.h>

#include <y2pm/PkgName.h>
#include <y2pm/PkgEdition.h>
#include <y2pm/PkgArch.h>
#include <y2pm/PkgRelation.h>

//
//      CLASS NAME : PMSolvable
class PMSolvable : public CountedRep {
  REP_BODY(PMSolvable);

  public:

    typedef std::list<PkgRelation>          PkgRelList_type;
    typedef PkgRelList_type::iterator       PkgRelList_iterator;
    typedef PkgRelList_type::const_iterator PkgRelList_const_iterator;

  public:

    //
    //  CLASS NAME : Provides_iterator
    class Provides_iterator {

      private:

        constPMSolvablePtr        pkg;
        PkgRelList_const_iterator iter;

      public:

        Provides_iterator( constPMSolvablePtr p )
          : pkg( p )
        {}

        Provides_iterator( PkgRelList_const_iterator i )
          : iter( i )
        {}

        PkgRelation operator* () const {
              return (pkg!= NULL) ? PkgRelation(pkg->name(), EQ, pkg->edition()) : *iter;
        }

        Provides_iterator& operator++ () {
          if (pkg) {
            iter = pkg->provides_begin();
            pkg = NULL;
          }
          else
            ++iter;
          return *this;
        }

        Provides_iterator  operator++ (int) {
          Provides_iterator temp = *this;
          operator++();
          return temp;
        }

        bool operator== ( const Provides_iterator& i2 ) {
          return pkg == i2.pkg && iter == i2.iter;
        }

        bool operator!= ( const Provides_iterator& i2 ) {
          return !operator==(i2);
        }
    };

    typedef Provides_iterator Provides_const_iterator;

  protected:

    // name, edition, and architecture
    PkgName    _name;
    PkgEdition _edition;
    PkgArch    _arch;

    // relations of the package
    PkgRelList_type _requires, _conflicts, _provides, _obsoletes;

  private:

    void traceFileRel( const PkgRelation & rel_r ) const;
    void traceFileRel( const PkgRelList_type & rellist_r ) const {
      for ( PkgRelList_type::const_iterator it = rellist_r.begin(); it != rellist_r.end(); ++it ) {
        traceFileRel( *it );
      }
    }

  public:

    PMSolvable( const PkgName& name,
                const PkgEdition& edition,
                const PkgArch& arch);

    virtual ~PMSolvable();

  public:

    virtual std::ostream & dumpOn( std::ostream & str ) const;

    const PkgRelation& addProvides(const PkgName name ) {
      _provides.push_front( PkgRelation( name, EQ, PkgEdition(PkgEdition::UNSPEC) ));
      return *(_provides.begin());
    }

    const PkgRelation& addProvides( const char *name ) {
      return addProvides( PkgName(name) );
    }

    const PkgRelList_type& setProvides(const PkgRelList_type& provides)
    {
      _provides = provides;
      return _provides;
    }

    const PkgRelList_type& setRequires(const PkgRelList_type& requires)
    {
      _requires = requires;
      traceFileRel( _requires );
      return _requires;
    }

    const PkgRelList_type& addPreRequires(PkgRelList_type& prerequires);

    const PkgRelList_type& setObsoletes(const PkgRelList_type& obsoletes)
    {
      _obsoletes = obsoletes;
      return _obsoletes;
    }

    const PkgRelList_type& setConflicts(const PkgRelList_type& conflicts)
    {
      _conflicts = conflicts;
      traceFileRel( _conflicts );
      return _conflicts;
    }

    // Unused? If not check for FileRel.
    const PkgRelation& addRequires(const PkgRelation& r) {
      _requires.push_front(r);
      traceFileRel( r );
      return *(_requires.begin());
    }

    Provides_iterator all_provides_begin() const {
      return Provides_iterator(constPMSolvablePtr(this));
    }
    Provides_iterator all_provides_end() const {
      return Provides_iterator( provides_end() );
    }
    PkgRelation self_provides() const {
      return PkgRelation( _name, EQ, _edition );
    }

    bool doesProvide(const PkgRelation& rel) const;

    bool doesObsolete( const constPMSolvablePtr & item_r ) const;

    const PkgName& name() const { return _name; }
    const PkgEdition& edition() const { return _edition; }
    const PkgArch& arch() const { return _arch; }

    const std::string & version() const { return _edition.version(); }
    const std::string & release() const { return _edition.release(); }

    std::string nameEd() const { return (const std::string &)_name + '-' + _edition.asString(); }

    std::string nameEdArch() const { return nameEd() + '.' + (const std::string &)_arch; }

    const PkgRelList_type& requires() const { return _requires; }
    PkgRelList_type prerequires() const;
    const PkgRelList_type& conflicts() const { return _conflicts; }
    const PkgRelList_type& provides() const { return _provides; }
    const PkgRelList_type& obsoletes() const { return _obsoletes; }


    static std::list<std::string> PkgRelList2StringList ( const PkgRelList_type & rellist_r );
    static PkgRelList_type StringList2PkgRelList ( const std::list<std::string>& relationlist );

    // for convenience: directly return an iterator for relation lists
#define decl_PkgRelList_iterators(name)                                 \
        PkgRelList_iterator name##_begin() {                            \
                return _##name.begin(); }                               \
        PkgRelList_const_iterator name##_begin() const {                \
                return _##name.begin(); }                               \
        PkgRelList_iterator name##_end() {                              \
                return _##name.end(); }                                 \
        PkgRelList_const_iterator name##_end() const {                  \
                return _##name.end(); }

    decl_PkgRelList_iterators(requires)
    decl_PkgRelList_iterators(conflicts)
    decl_PkgRelList_iterators(provides)
    decl_PkgRelList_iterators(obsoletes)
};


extern std::ostream & operator<<( std::ostream&, const PMSolvable::PkgRelList_type & );


#endif // PMSolvable_h

---