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   /** \defgroup ZYPP_RESOLVABLE_SMART_POINTER_TYPES
  23    * Resolvable smart pointer types.
  24    *
  25    * Forward declaration of all Resolvable smart pointer
  26    * types provided in \c ResTraits.h (recommended in header files):
  27    * \code
  28    * #include<zypp/ResTraits.h>
  29    *
  30    * Resolvable_Ptr                      // Resolvable *
  31    * ResTraits<Resolvable>::PtrType      // same as above
  32    *
  33    * Resolvable_constPtr                 // const Resolvable *
  34    * ResTraits<Resolvable>::constPtrType // same as above
  35    * \endcode
  36    *
  37    * Synonym, but requires \c Resolvable.h being included:
  38    * \code
  39    * #include<zypp/Resolvable.h>
  40    *
  41    * Resolvable::Ptr        // same as Resolvable_Ptr but requires Resolvable.h
  42    * Resolvable::constPtr   // same as Resolvable_constPtr but requires Resolvable.h
  43    * \endcode
  44    *
  45    * \note When adding a \c NewResolvable type here, dont forgett to
  46    * put <tt>IMPL_PTR_TYPE(NewResolvable);</tt> into the \c NewResolvable.cc.
  47    */
  48   //@{
  49   DEFINE_PTR_TYPE( Resolvable );
  50   DEFINE_PTR_TYPE( ResObject );
  51
  52   DEFINE_PTR_TYPE( Package );
  53   DEFINE_PTR_TYPE( SrcPackage );
  54   DEFINE_PTR_TYPE( Pattern );
  55   DEFINE_PTR_TYPE( Product );
  56   DEFINE_PTR_TYPE( Patch );
  57   //@}
  58
  59   /** ResTraits. Defines common types and the ResKind value. */
  60   template<typename _Res>
  61     struct ResTraits
  62     {
  63       typedef ResKind                   KindType;
  64       typedef intrusive_ptr<_Res>       PtrType;
  65       typedef intrusive_ptr<const _Res> constPtrType;
  66
  67       static const ResKind              kind;
  68     };
  69
  70   /** ResTraits specialisation for Resolvable.
  71    * Resolvable is common base and has no Kind value.
  72    */
  73   template<>
  74     struct ResTraits<Resolvable>
  75     {
  76       typedef ResKind                         KindType;
  77       typedef intrusive_ptr<Resolvable>       PtrType;
  78       typedef intrusive_ptr<const Resolvable> constPtrType;
  79     };
  80
  81   /** ResTraits specialisation for ResObject.
  82    * ResObject is common base and has no Kind value.
  83    */
  84   template<>
  85     struct ResTraits<ResObject>
  86     {
  87       typedef ResKind                        KindType;
  88       typedef intrusive_ptr<ResObject>       PtrType;
  89       typedef intrusive_ptr<const ResObject> constPtrType;
  90     };
  91
  92   /** Convenient access to well known ResKinds.
  93    * \code
  94    * ResKind packagekind = ResTraits<Package>::kind;
  95    * ResKind packagekind = resKind<Package>();
  96    * \endcode
  97   */
  98   template<typename _Res>
  99     inline ResKind resKind() { return ResTraits<_Res>::kind; }
 100
 101   /** Convenient test for ResKinds.
 102    * \code
 103    * ResKind value;
 104    * if ( ResTraits<Package>::kind == value )
 105    * if ( resKind<Package>() == value )
 106    * if ( isKind<Package>( value ) )
 107    * \endcode
 108    */
 109   template<typename _Res>
 110     inline bool isKind( const ResKind & val_r )
 111     { return( resKind<_Res>() == val_r ); }
 112   /** \overload */
 113   template<typename _Res>
 114     inline bool isKind( const std::string & val_r )
 115     { return( resKind<_Res>() == val_r ); }
 116   /** \overload */
 117   template<typename _Res>
 118     inline bool isKind( const char * val_r )
 119     { return( resKind<_Res>() == val_r ); }
 120
 121
 122   /////////////////////////////////////////////////////////////////
 123 } // namespace zypp
 124 ///////////////////////////////////////////////////////////////////
 125 #endif // ZYPP_RESTRAITS_H