zypp/ResTraits.h

   1 /*---------------------------------------------------------------------\
   2 |                          ____ _   __ __ ___                          |
   3 |                         |__  / \ / / . \ . \                         |
   4 |                           / / \ V /|  _/  _/                         |
   5 |                          / /__ | | | | | |                           |
   6 |                         /_____||_| |_| |_|                           |
   7 |                                                                      |
   8 \---------------------------------------------------------------------*/
   9 /** \file zypp/ResTraits.h
  10  *
  11 */
  12 #ifndef ZYPP_RESTRAITS_H
  13 #define ZYPP_RESTRAITS_H
  14
  15 #include "zypp/base/PtrTypes.h"
  16 #include "zypp/ResKind.h"
  17
  18 ///////////////////////////////////////////////////////////////////
  19 namespace zypp
  20 { /////////////////////////////////////////////////////////////////
  21
  22   ///////////////////////////////////////////////////////////////////
  23   namespace traits
  24   { /////////////////////////////////////////////////////////////////
  25
  26     /** Those are denoted to be installed, if the
  27      *  solver verifies them as being satisfied. */
  28     inline bool isPseudoInstalled( ResKind kind_r )
  29     { return( kind_r == ResKind::patch ); }
  30
  31     /////////////////////////////////////////////////////////////////
  32   } // namespace traits
  33   ///////////////////////////////////////////////////////////////////
  34
  35    /** \defgroup ZYPP_RESOLVABLE_SMART_POINTER_TYPES
  36    * Resolvable smart pointer types.
  37    *
  38    * Forward declaration of all Resolvable smart pointer
  39    * types provided in \c ResTraits.h (recommended in header files):
  40    * \code
  41    * #include "zypp/ResTraits.h"
  42    *
  43    * Resolvable_Ptr                      // Resolvable *
  44    * ResTraits<Resolvable>::PtrType      // same as above
  45    *
  46    * Resolvable_constPtr                 // const Resolvable *
  47    * ResTraits<Resolvable>::constPtrType // same as above
  48    * \endcode
  49    *
  50    * Synonym, but requires \c Resolvable.h being included:
  51    * \code
  52    * #include "zypp/Resolvable.h"
  53    *
  54    * Resolvable::Ptr        // same as Resolvable_Ptr but requires Resolvable.h
  55    * Resolvable::constPtr   // same as Resolvable_constPtr but requires Resolvable.h
  56    * \endcode
  57    *
  58    * \note When adding a \c NewResolvable type here, dont forgett to
  59    * put <tt>IMPL_PTR_TYPE(NewResolvable);</tt> into the \c NewResolvable.cc.
  60    * Also check class \ref ResKind, ResKind.cc, ResObject.cc(makeResObject)
  61    */
  62   //@{
  63   DEFINE_PTR_TYPE( Resolvable );
  64   DEFINE_PTR_TYPE( ResObject );
  65
  66   DEFINE_PTR_TYPE( Package );
  67   DEFINE_PTR_TYPE( SrcPackage );
  68   DEFINE_PTR_TYPE( Pattern );
  69   DEFINE_PTR_TYPE( Product );
  70   DEFINE_PTR_TYPE( Patch );
  71   DEFINE_PTR_TYPE( Application );
  72   //@}
  73
  74   /** Frequently associated. */
  75   class PoolItem;
  76
  77   /** ResTraits. Defines common types and the ResKind value. */
  78   template<typename TRes>
  79     struct ResTraits
  80     {
  81       typedef ResKind                   KindType;
  82       typedef intrusive_ptr<TRes>       PtrType;
  83       typedef intrusive_ptr<const TRes> constPtrType;
  84
  85       static const ResKind              kind;   ///< Defined in ResKind.cc
  86
  87       /** Those are denoted to be installed, if the
  88        *  solver verifies them as being satisfied. */
  89       static bool isPseudoInstalled()   { return traits::isPseudoInstalled( kind ); }
  90     };
  91
  92   /** ResTraits specialisation for Resolvable.
  93    * Resolvable is common base and has no Kind value.
  94    */
  95   template<>
  96     struct ResTraits<Resolvable>
  97     {
  98       typedef ResKind                         KindType;
  99       typedef intrusive_ptr<Resolvable>       PtrType;
 100       typedef intrusive_ptr<const Resolvable> constPtrType;
 101     };
 102
 103   /** ResTraits specialisation for ResObject.
 104    * ResObject is common base and has no Kind value.
 105    */
 106   template<>
 107     struct ResTraits<ResObject>
 108     {
 109       typedef ResKind                        KindType;
 110       typedef intrusive_ptr<ResObject>       PtrType;
 111       typedef intrusive_ptr<const ResObject> constPtrType;
 112     };
 113
 114   /** Convenient access to well known ResKinds.
 115    * \code
 116    * ResKind packagekind = ResKind::package;
 117    * ResKind packagekind = resKind<Package>();
 118    * \endcode
 119   */
 120   template<typename TRes>
 121     inline ResKind resKind() { return ResTraits<TRes>::kind; }
 122
 123   /** Convenient test for ResKinds.
 124    * \code
 125    * ResKind value;
 126    * if ( ResKind::package == value )
 127    * if ( resKind<Package>() == value )
 128    * if ( isKind<Package>( value ) )
 129    * \endcode
 130    */
 131   template<typename TRes>
 132     inline bool isKind( const ResKind & val_r )
 133     { return( resKind<TRes>() == val_r ); }
 134   /** \overload */
 135   template<typename TRes>
 136     inline bool isKind( const std::string & val_r )
 137     { return( resKind<TRes>() == val_r ); }
 138   /** \overload */
 139   template<typename TRes>
 140     inline bool isKind( const char * val_r )
 141     { return( resKind<TRes>() == val_r ); }
 142
 143
 144   /////////////////////////////////////////////////////////////////
 145 } // namespace zypp
 146 ///////////////////////////////////////////////////////////////////
 147 #endif // ZYPP_RESTRAITS_H