libzypp  17.15.0
ByIdent.h
Go to the documentation of this file.
1 /*---------------------------------------------------------------------\
2 | ____ _ __ __ ___ |
3 | |__ / \ / / . \ . \ |
4 | / / \ V /| _/ _/ |
5 | / /__ | | | | | | |
6 | /_____||_| |_| |_| |
7 | |
8 \---------------------------------------------------------------------*/
12 #ifndef ZYPP_POOL_BYIDENT_H
13 #define ZYPP_POOL_BYIDENT_H
14 
15 #include "zypp/PoolItem.h"
16 
18 namespace zypp
19 {
20  namespace pool
22  {
23 
26  class ByIdent
27  {
28  public:
30  : _id( 0 )
31  {}
32 
33  explicit ByIdent( sat::Solvable slv_r )
34  : _id( makeIdent( slv_r ) )
35  {}
36 
37  explicit ByIdent( IdString ident_r )
38  : _id( ident_r.id() )
39  {}
40 
41  ByIdent( ResKind kind_r, IdString name_r )
42  : _id( makeIdent( kind_r, name_r ) )
43  {}
44 
45  ByIdent( ResKind kind_r, const C_Str & name_r )
46  : _id( makeIdent( kind_r, name_r ) )
47  {}
48 
49  public:
50  bool operator()( sat::Solvable slv_r ) const
51  {
52  return _id >= 0 ? ( slv_r.ident().id() == _id && ! slv_r.isKind( ResKind::srcpackage ) )
53  : ( slv_r.ident().id() == -_id && slv_r.isKind( ResKind::srcpackage ) );
54  }
55 
56  bool operator()( const PoolItem & pi_r ) const
57  { return operator()( pi_r.satSolvable() ); }
58 
59  bool operator()( ResObject::constPtr p_r ) const
60  { return p_r ? operator()( p_r->satSolvable() ) : !_id; }
61 
62  private:
64  {
65  return slv_r.isKind( ResKind::srcpackage ) ? -slv_r.ident().id()
66  : slv_r.ident().id();
67  }
68 
70  {
71  if ( kind_r == ResKind::package )
72  return name_r.id();
73  else if ( kind_r == ResKind::srcpackage )
74  return -name_r.id();
75  return IdString( str::form( "%s:%s", kind_r.c_str(), name_r.c_str() ) ).id();
76  }
77 
78  sat::detail::IdType makeIdent( ResKind kind_r, const C_Str & name_r )
79  {
80  if ( kind_r == ResKind::package )
81  return IdString( name_r ).id();
82  else if ( kind_r == ResKind::srcpackage )
83  return -(IdString( name_r ).id());
84  return IdString( str::form( "%s:%s", kind_r.c_str(), name_r.c_str() ) ).id();
85  }
86 
87  public:
88  sat::detail::IdType get() const { return _id; }
89 
90  private:
95  };
96 
98  } // namespace pool
101 } // namespace zypp
103 #endif // ZYPP_POOL_BYIDENT_H
sat::detail::IdType get() const
Definition: ByIdent.h:88
int IdType
Generic Id type.
Definition: PoolMember.h:104
A Solvable object within the sat Pool.
Definition: Solvable.h:53
sat::detail::IdType _id
negative _id for srcpackage, as they use the same ident as package.
Definition: ByIdent.h:94
static const ResKind package
Definition: ResKind.h:40
sat::detail::IdType makeIdent(sat::Solvable slv_r)
Definition: ByIdent.h:63
IdType id() const
Expert backdoor.
Definition: IdString.h:115
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
Definition: Solvable.cc:298
static const ResKind srcpackage
Definition: ResKind.h:44
Access to the sat-pools string space.
Definition: IdString.h:41
sat::detail::IdType makeIdent(ResKind kind_r, IdString name_r)
Definition: ByIdent.h:69
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
const char * c_str() const
Definition: String.h:113
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
bool operator()(ResObject::constPtr p_r) const
Definition: ByIdent.h:59
ByIdent(ResKind kind_r, IdString name_r)
Definition: ByIdent.h:41
bool operator()(const PoolItem &pi_r) const
Definition: ByIdent.h:56
sat::detail::IdType makeIdent(ResKind kind_r, const C_Str &name_r)
Definition: ByIdent.h:78
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string.
Definition: String.h:90
const char * c_str() const
Conversion to const char *
Definition: IdString.cc:50
ByIdent(IdString ident_r)
Definition: ByIdent.h:37
ByIdent(ResKind kind_r, const C_Str &name_r)
Definition: ByIdent.h:45
ByIdent(sat::Solvable slv_r)
Definition: ByIdent.h:33
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:50
bool operator()(sat::Solvable slv_r) const
Definition: ByIdent.h:50
Resolvable kinds.
Definition: ResKind.h:32
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:1
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57
const char * c_str() const
Definition: IdStringType.h:105
IdString ident() const
The identifier.
Definition: Solvable.cc:265
Main filter selecting PoolItems by name and kind.
Definition: ByIdent.h:26