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