libzypp  17.32.5
ResTraits.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_RESTRAITS_H
13 #define ZYPP_RESTRAITS_H
14 
15 #include <zypp/base/PtrTypes.h>
16 #include <zypp/ResKind.h>
17 
19 namespace zypp
20 {
21 
23  namespace traits
24  {
25 
28  inline bool isPseudoInstalled( const ResKind& kind_r )
29  { return( kind_r == ResKind::patch ); }
30 
32  } // namespace traits
34 
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 );
73 
75  class PoolItem;
76 
78  template<typename TRes>
79  struct ResTraits
80  {
81  using KindType = ResKind;
82  using PtrType = intrusive_ptr<TRes>;
83  using constPtrType = intrusive_ptr<const TRes>;
84 
85  static const ResKind kind;
86 
89  static bool isPseudoInstalled() { return traits::isPseudoInstalled( kind ); }
90  };
91 
92  // Defined in ResKind.cc
94  template<> const ResKind ResTraits<Patch>::kind;
99 
103  template<>
105  {
106  using KindType = ResKind;
107  using PtrType = intrusive_ptr<Resolvable>;
108  using constPtrType = intrusive_ptr<const Resolvable>;
109  };
110 
114  template<>
116  {
117  using KindType = ResKind;
118  using PtrType = intrusive_ptr<ResObject>;
119  using constPtrType = intrusive_ptr<const ResObject>;
120  };
121 
128  template<typename TRes>
129  inline ResKind resKind() { return ResTraits<TRes>::kind; }
130 
139  template<typename TRes>
140  inline bool isKind( const ResKind & val_r )
141  { return( resKind<TRes>() == val_r ); }
143  template<typename TRes>
144  inline bool isKind( const std::string & val_r )
145  { return( resKind<TRes>() == val_r ); }
147  template<typename TRes>
148  inline bool isKind( const char * val_r )
149  { return( resKind<TRes>() == val_r ); }
150 
151 
153 } // namespace zypp
155 #endif // ZYPP_RESTRAITS_H
intrusive_ptr< const Resolvable > constPtrType
Definition: ResTraits.h:108
bool isKind(const ResKind &val_r)
Convenient test for ResKinds.
Definition: ResTraits.h:140
Base for resolvable objects.
Definition: Resolvable.h:49
intrusive_ptr< Resolvable > PtrType
Definition: ResTraits.h:107
ResTraits.
Definition: ResTraits.h:79
intrusive_ptr< const TRes > constPtrType
Definition: ResTraits.h:83
const ResKind kind
Definition: ResTraits.h:93
intrusive_ptr< ResObject > PtrType
Definition: ResTraits.h:118
DEFINE_PTR_TYPE(Application)
ResKind resKind()
Convenient access to well known ResKinds.
Definition: ResTraits.h:129
Base for resolvable objects.
Definition: ResObject.h:37
intrusive_ptr< TRes > PtrType
Definition: ResTraits.h:82
static bool isPseudoInstalled()
Those are denoted to be installed, if the solver verifies them as being satisfied.
Definition: ResTraits.h:89
bool isPseudoInstalled(const ResKind &kind_r)
Those are denoted to be installed, if the solver verifies them as being satisfied.
Definition: ResTraits.h:28
Resolvable kinds.
Definition: ResKind.h:32
Easy-to use interface to the ZYPP dependency resolver.
Definition: Application.cc:19
static const ResKind patch
Definition: ResKind.h:41
intrusive_ptr< const ResObject > constPtrType
Definition: ResTraits.h:119
static const ResKind kind
Defined in ResKind.cc.
Definition: ResTraits.h:85