Resolvable.h

Go to the documentation of this file.

/*---------------------------------------------------------------------\
|                          ____ _   __ __ ___                          |
|                         |__  / \ / / . \ . \                         |
|                           / / \ V /|  _/  _/                         |
|                          / /__ | | | | | |                           |
|                         /_____||_| |_| |_|                           |
|                                                                      |
\---------------------------------------------------------------------*/
#ifndef ZYPP_RESOLVABLE_H
#define ZYPP_RESOLVABLE_H

#include <iosfwd>
#include <string>

#include "zypp/base/Deprecated.h"

#include "zypp/base/ReferenceCounted.h"
#include "zypp/base/NonCopyable.h"
#include "zypp/base/PtrTypes.h"

#include "zypp/sat/Solvable.h"

namespace zypp
{ 

  class PoolItem;

  //
  //    CLASS NAME : Resolvable
  //
  class Resolvable : protected sat::Solvable,
                     public base::ReferenceCounted, private base::NonCopyable
  {
    friend std::ostream & operator<<( std::ostream & str, const Resolvable & obj );

  public:
    typedef Resolvable               Self;
    typedef ResTraits<Self>          TraitsType;
    typedef TraitsType::KindType     Kind;
    typedef TraitsType::PtrType      Ptr;
    typedef TraitsType::constPtrType constPtr;

  public:
#ifndef SWIG // Swig treats it as syntax error

    using sat::Solvable::operator bool_type;
#endif

    bool isSystem() const
    { return sat::Solvable::isSystem(); }

    bool onSystemByUser() const
    { return sat::Solvable::onSystemByUser(); }

    IdString ident() const
    { return sat::Solvable::ident(); }

    ResKind kind() const
    { return sat::Solvable::kind(); }

    bool isKind( const ResKind & kind_r ) const
    { return sat::Solvable::isKind( kind_r ); }

    template<class _Res>
    bool isKind() const
    { return sat::Solvable::isKind<_Res>(); }

    std::string name() const
    { return sat::Solvable::name(); }

    Edition edition() const
    { return sat::Solvable::edition(); }

    Arch arch() const
    { return sat::Solvable::arch(); }

    bool multiversionInstall() const
    { return sat::Solvable::multiversionInstall(); }

    Capabilities dep( Dep which_r ) const
    { return operator[]( which_r ); }

    Capabilities operator[]( Dep which_r ) const
    { return sat::Solvable::operator[]( which_r ); }

    Capabilities provides()    const
    { return sat::Solvable::provides(); }

    Capabilities requires()    const
    { return sat::Solvable::requires(); }

    Capabilities conflicts()   const
    { return sat::Solvable::conflicts(); }

    Capabilities obsoletes()   const
    { return sat::Solvable::obsoletes(); }

    Capabilities recommends()  const
    { return sat::Solvable::recommends(); }

    Capabilities suggests()    const
    { return sat::Solvable::suggests(); }

    Capabilities enhances()    const
    { return sat::Solvable::enhances(); }

    Capabilities supplements() const
    { return sat::Solvable::supplements(); }

    Capabilities prerequires() const
    { return sat::Solvable::prerequires(); }

    CapabilitySet providesNamespace( const std::string & namespace_r ) const
    { return sat::Solvable::providesNamespace( namespace_r ); }

    CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const
    { return sat::Solvable::valuesOfNamespace( namespace_r ); }

  public:
    const sat::Solvable & satSolvable() const { return *this; }

    PoolItem poolItem() const;

  protected:
    Resolvable( const sat::Solvable & solvable_r );
    virtual ~Resolvable();
    virtual std::ostream & dumpOn( std::ostream & str ) const;
 };

 inline std::ostream & operator<<( std::ostream & str, const Resolvable & obj )
 { return obj.dumpOn( str ); }

 inline std::ostream & dumpOn( std::ostream & str, const Resolvable & obj )
 { return dumpOn( str, obj.satSolvable() ); }

  template<class _Res>
    inline bool isKind( const Resolvable::constPtr & p )
    { return p && p->kind() == ResTraits<_Res>::kind; }

  // Specialization for Resolvable: Always true.
  template<>
    inline bool isKind<Resolvable>( const Resolvable::constPtr & p )
    { return p; }

  // Specialization for ResObject: Always true.
  template<>
    inline bool isKind<ResObject>( const Resolvable::constPtr & p )
    { return p; }


  template<class _Res>
    inline typename ResTraits<_Res>::PtrType asKind( const Resolvable::Ptr & p )
    { return dynamic_pointer_cast<_Res>(p); }

  template<class _Res>
    inline typename ResTraits<_Res>::constPtrType asKind( const Resolvable::constPtr & p )
    { return dynamic_pointer_cast<const _Res>(p); }


  inline int compareByN( const Resolvable::constPtr & lhs,
                         const Resolvable::constPtr & rhs )
  {
    if ( lhs == rhs )
      return 0;
    if ( ! (lhs && rhs) )
      return lhs ? 1 : -1;
    int res = 0;
    if ( (res = lhs->kind().compare( rhs->kind() )) )
      return res;
    return lhs->name().compare( rhs->name() );
  }

  inline int compareByNVR( const Resolvable::constPtr & lhs,
                           const Resolvable::constPtr & rhs )
  {
    if ( lhs == rhs )
      return 0;
    if ( ! (lhs && rhs) )
      return lhs ? 1 : -1;
    int res = 0;
    if ( (res = lhs->kind().compare( rhs->kind() )) )
      return res;
    if ( (res = lhs->name().compare( rhs->name() )) )
      return res;
    return lhs->edition().compare( rhs->edition() );
  }

  inline int compareByNVRA( const Resolvable::constPtr & lhs,
                            const Resolvable::constPtr & rhs )
  {
    if ( lhs == rhs )
      return 0;
    if ( ! (lhs && rhs) )
      return lhs ? 1 : -1;
    int res = 0;
    if ( (res = lhs->kind().compare( rhs->kind() )) )
      return res;
    if ( (res = lhs->name().compare( rhs->name() )) )
      return res;
    if ( (res = lhs->edition().compare( rhs->edition() )) )
      return res;
    return lhs->arch().compare( rhs->arch() );
  }

} // namespace zypp
#endif // ZYPP_RESOLVABLE_H