Solvable.h

Go to the documentation of this file.

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

#include <iosfwd>

#include "zypp/sat/detail/PoolMember.h"
#include "zypp/sat/SolvAttr.h"
#include "zypp/ResTraits.h"
#include "zypp/IdString.h"
#include "zypp/Edition.h"
#include "zypp/Arch.h"
#include "zypp/Dep.h"
#include "zypp/Capabilities.h"
#include "zypp/Capability.h"
#include "zypp/Locale.h"

namespace zypp
{ 

  class CheckSum;
  class OnMediaLocation;

  namespace sat
  { 

    //
    //  CLASS NAME : Solvable
    //
    class Solvable : protected detail::PoolMember
    {
      public:
        typedef sat::detail::SolvableIdType IdType;

      public:
        Solvable()
        : _id( detail::noSolvableId ) {}

        explicit Solvable( IdType id_r )
        : _id( id_r ) {}

      public:
        static const Solvable noSolvable;

        explicit operator bool() const
        { return get(); }

        bool isSystem() const;

        bool onSystemByUser() const;

        Repository repository() const;

      public:

        std::string lookupStrAttribute( const SolvAttr & attr ) const;
        std::string lookupStrAttribute( const SolvAttr & attr, const Locale & lang_r ) const;

        unsigned long long lookupNumAttribute( const SolvAttr & attr ) const;

        bool lookupBoolAttribute( const SolvAttr & attr ) const;

        detail::IdType lookupIdAttribute( const SolvAttr & attr ) const;

        CheckSum lookupCheckSumAttribute( const SolvAttr & attr ) const;

        OnMediaLocation lookupLocation() const;

      public:
        IdString     ident()    const;

        ResKind      kind()     const;
        bool isKind( const ResKind & kind_r ) const;
        template<class _Res>
        bool isKind() const
        { return isKind( resKind<_Res>() ); }
        template<class _Iterator>
        bool isKind( _Iterator begin, _Iterator end )
        { for_( it, begin, end ) if ( isKind( *it ) ) return true; return false; }

        std::string  name()     const;
        Edition      edition()  const;
        Arch         arch()     const;

        IdString     vendor()   const;

        bool         multiversionInstall() const;

        std::string asString() const;

        std::string asUserString() const;

        bool identical( Solvable rhs ) const;

        bool sameNVRA( Solvable rhs ) const
        { return( ident() == rhs.ident() && edition() == rhs.edition() && arch() == rhs.arch() ); }

     public:

        Capabilities operator[]( Dep which_r ) const;

        Capabilities provides()    const;
        Capabilities requires()    const;
        Capabilities conflicts()   const;
        Capabilities obsoletes()   const;
        Capabilities recommends()  const;
        Capabilities suggests()    const;
        Capabilities enhances()    const;
        Capabilities supplements() const;
        Capabilities prerequires() const;

        CapabilitySet providesNamespace( const std::string & namespace_r ) const;

        CapabilitySet valuesOfNamespace( const std::string & namespace_r ) const;

      public:
        bool supportsLocales() const;
        bool supportsLocale( const Locale & locale_r ) const;
        bool supportsLocale( const LocaleSet & locales_r ) const;
        bool supportsRequestedLocales() const;
        void getSupportedLocales( LocaleSet & locales_r ) const;
        LocaleSet getSupportedLocales() const
        { LocaleSet ret; getSupportedLocales( ret ); return ret; }

      public:
        Solvable nextInPool() const;
        Solvable nextInRepo() const;

        class SplitIdent
        {
          public:
            SplitIdent() {}
            SplitIdent( IdString ident_r );
            SplitIdent( const char * ident_r );
            SplitIdent( const std::string & ident_r );
            SplitIdent( ResKind kind_r, IdString name_r );
            SplitIdent( ResKind kind_r, const C_Str & name_r );

            IdString ident() const { return _ident; }
            ResKind  kind()  const { return _kind; }
            IdString name()  const { return _name; }

          private:
            IdString  _ident;
            ResKind   _kind;
            IdString  _name;
        };

      public:
        detail::CSolvable * get() const;
        IdType id() const { return _id; }

      private:
        IdType _id;
    };

    std::ostream & operator<<( std::ostream & str, const Solvable & obj );

    std::ostream & dumpOn( std::ostream & str, const Solvable & obj );

    std::ostream & dumpAsXmlOn( std::ostream & str, const Solvable & obj );

    inline bool operator==( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() == rhs.get(); }

    inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() != rhs.get(); }

    inline bool operator<( const Solvable & lhs, const Solvable & rhs )
    { return lhs.get() < rhs.get(); }

    inline bool identical( Solvable lhs, Solvable rhs )
    { return lhs.identical( rhs ); }

    inline bool sameNVRA( Solvable lhs, Solvable rhs )
    { return lhs.sameNVRA( rhs ); }


    inline int compareByN( const Solvable & lhs, const Solvable & rhs )
    {
      int res = 0;
      if ( lhs != rhs )
      {
       if ( (res = lhs.kind().compare( rhs.kind() )) == 0 )
         res = lhs.name().compare( rhs.name() );
      }
      return res;
    }

    inline int compareByNVR( const Solvable & lhs, const Solvable & rhs )
    {
      int res = compareByN( lhs, rhs );
      if ( res == 0 )
       res = lhs.edition().compare( rhs.edition() );
      return res;
    }

    inline int compareByNVRA( const Solvable & lhs, const Solvable & rhs )
    {
      int res = compareByNVR( lhs, rhs );
      if ( res == 0 )
       res = lhs.arch().compare( rhs.arch() );
      return res;
    }

    namespace detail
    { 
      //
      //        CLASS NAME : SolvableIterator
      //
      class SolvableIterator : public boost::iterator_adaptor<
          SolvableIterator                   // Derived
          , detail::CSolvable*               // Base
          , const Solvable                   // Value
          , boost::forward_traversal_tag     // CategoryOrTraversal
          , const Solvable                   // Reference
          >
      {
        public:
          SolvableIterator()
          : SolvableIterator::iterator_adaptor_( 0 )
          {}

          explicit SolvableIterator( const Solvable & val_r )
          : SolvableIterator::iterator_adaptor_( 0 )
          { assignVal( val_r ); }

          explicit SolvableIterator( SolvableIdType id_r )
          : SolvableIterator::iterator_adaptor_( 0 )
          { assignVal( Solvable( id_r ) ); }

        private:
          friend class boost::iterator_core_access;

          Solvable dereference() const
          { return _val; }

          void increment()
          { assignVal( _val.nextInPool() ); }

        private:
          void assignVal( const Solvable & val_r )
          { _val = val_r; base_reference() = _val.get(); }

          Solvable _val;
      };
    } // namespace detail

  } // namespace sat

  template<class _Res>
  inline bool isKind( const sat::Solvable & solvable_r )
  { return solvable_r.isKind( ResTraits<_Res>::kind ); }

  class PoolItem;
  namespace sat
  { 

    struct asSolvable
    {
      typedef Solvable result_type;

      Solvable operator()( Solvable solv_r ) const
      { return solv_r; }

      Solvable operator()( const PoolItem & pi_r ) const;

      Solvable operator()( const ResObject_constPtr & res_r ) const;
    };
  } // namespace sat

} // namespace zypp

ZYPP_DEFINE_ID_HASHABLE( ::zypp::sat::Solvable );

#endif // ZYPP_SAT_SOLVABLE_H