zypp/sat/Solvable.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file       zypp/sat/Solvable.h
  10  *
  11 */
  12 #ifndef ZYPP_SAT_SOLVABLE_H
  13 #define ZYPP_SAT_SOLVABLE_H
  14
  15 #include <iosfwd>
  16
  17 #include "zypp/base/SafeBool.h"
  18
  19 #include "zypp/sat/detail/PoolMember.h"
  20 #include "zypp/sat/IdStr.h"
  21
  22 ///////////////////////////////////////////////////////////////////
  23 namespace zypp
  24 { /////////////////////////////////////////////////////////////////
  25   ///////////////////////////////////////////////////////////////////
  26   namespace sat
  27   { /////////////////////////////////////////////////////////////////
  28
  29     ///////////////////////////////////////////////////////////////////
  30     //
  31     //  CLASS NAME : Solvable
  32     //
  33     /** */
  34     class Solvable : protected detail::PoolMember,
  35                      private base::SafeBool<Solvable>
  36     {
  37       public:
  38         /** Default ctor creates \ref nosolvable.*/
  39         Solvable()
  40         : _id( detail::noSolvableId ) {}
  41
  42         /** \ref PoolImpl ctor. */
  43         explicit Solvable( detail::SolvableIdType id_r )
  44         : _id( id_r ) {}
  45
  46       public:
  47         /** Represents no \ref Solvable. */
  48         static const Solvable nosolvable;
  49
  50         /** Evaluate \ref Solvable in a boolean context (\c != \c nosolvable). */
  51         using base::SafeBool<Solvable>::operator bool_type;
  52
  53         /** Return whether this \ref Solvable belongs to the system repo. */
  54         bool isSystem() const;
  55
  56       public:
  57         NameId   name() const;
  58         EvrId    evr() const;
  59         ArchId   arch() const;
  60         VendorId vendor() const;
  61
  62       public:
  63         Repo repo() const;
  64
  65       public:
  66         /** Return next Solvable in \ref Pool (or \ref nosolvable). */
  67         Solvable nextInPool() const;
  68         /** Return next Solvable in \ref Repo (or \ref nosolvable). */
  69         Solvable nextInRepo() const;
  70       public:
  71         /** Expert backdoor. */
  72         ::_Solvable * get() const;
  73         /** Expert backdoor. */
  74         detail::SolvableIdType id() const { return _id; }
  75       private:
  76         friend base::SafeBool<Solvable>::operator bool_type() const;
  77         bool boolTest() const { return get(); }
  78       private:
  79         detail::SolvableIdType _id;
  80     };
  81     ///////////////////////////////////////////////////////////////////
  82
  83     /** \relates Solvable Stream output */
  84     std::ostream & operator<<( std::ostream & str, const Solvable & obj );
  85
  86     /** \relates Solvable */
  87     inline bool operator==( const Solvable & lhs, const Solvable & rhs )
  88     { return lhs.get() == rhs.get(); }
  89
  90     /** \relates Solvable */
  91     inline bool operator!=( const Solvable & lhs, const Solvable & rhs )
  92     { return lhs.get() != rhs.get(); }
  93
  94     /** \relates Solvable */
  95     inline bool operator<( const Solvable & lhs, const Solvable & rhs )
  96     { return lhs.get() < rhs.get(); }
  97
  98     ///////////////////////////////////////////////////////////////////
  99     namespace detail
 100     { /////////////////////////////////////////////////////////////////
 101       ///////////////////////////////////////////////////////////////////
 102       //
 103       //        CLASS NAME : SolvableIterator
 104       //
 105       /** */
 106       class SolvableIterator : public boost::iterator_adaptor<
 107           SolvableIterator                   // Derived
 108           , ::_Solvable*                     // Base
 109           , Solvable                         // Value
 110           , boost::single_pass_traversal_tag // CategoryOrTraversal
 111           , Solvable                         // Reference
 112           >
 113       {
 114         public:
 115           SolvableIterator()
 116           : SolvableIterator::iterator_adaptor_( 0 )
 117           {}
 118
 119           explicit SolvableIterator( const Solvable & val_r )
 120           : SolvableIterator::iterator_adaptor_( 0 )
 121           { assignVal( val_r ); }
 122
 123           explicit SolvableIterator( SolvableIdType id_r )
 124           : SolvableIterator::iterator_adaptor_( 0 )
 125           { assignVal( Solvable( id_r ) ); }
 126
 127         private:
 128           friend class boost::iterator_core_access;
 129
 130           void increment()
 131           { assignVal( _val.nextInPool() ); }
 132
 133           Solvable dereference() const
 134           { return _val; }
 135
 136           void assignVal( const Solvable & val_r )
 137           { _val = val_r; base_reference() = _val.get(); }
 138
 139           Solvable _val;
 140       };
 141       ///////////////////////////////////////////////////////////////////
 142       /////////////////////////////////////////////////////////////////
 143     } // namespace detail
 144     ///////////////////////////////////////////////////////////////////
 145
 146    /////////////////////////////////////////////////////////////////
 147   } // namespace sat
 148   ///////////////////////////////////////////////////////////////////
 149   /////////////////////////////////////////////////////////////////
 150 } // namespace zypp
 151 ///////////////////////////////////////////////////////////////////
 152 #endif // ZYPP_SAT_SOLVABLE_H