libzypp 17.31.7
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
18namespace zypp
19{
21 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
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
Convenience char* constructible from std::string and char*, it maps (char*)0 to an empty string.
Definition: String.h:91
const char * c_str() const
Definition: String.h:116
const char * c_str() const
Definition: IdStringType.h:105
Access to the sat-pools string space.
Definition: IdString.h:43
const char * c_str() const
Conversion to const char *
Definition: IdString.cc:50
IdType id() const
Expert backdoor.
Definition: IdString.h:122
Combining sat::Solvable and ResStatus.
Definition: PoolItem.h:51
Resolvable kinds.
Definition: ResKind.h:33
static const ResKind srcpackage
Definition: ResKind.h:44
static const ResKind package
Definition: ResKind.h:40
TraitsType::constPtrType constPtr
Definition: ResObject.h:43
Main filter selecting PoolItems by name and kind.
Definition: ByIdent.h:27
sat::detail::IdType makeIdent(ResKind kind_r, IdString name_r)
Definition: ByIdent.h:69
bool operator()(sat::Solvable slv_r) const
Definition: ByIdent.h:50
bool operator()(ResObject::constPtr p_r) const
Definition: ByIdent.h:59
bool operator()(const PoolItem &pi_r) const
Definition: ByIdent.h:56
sat::detail::IdType _id
negative _id for srcpackage, as they use the same ident as package.
Definition: ByIdent.h:94
ByIdent(ResKind kind_r, const C_Str &name_r)
Definition: ByIdent.h:45
sat::detail::IdType get() const
Definition: ByIdent.h:88
sat::detail::IdType makeIdent(ResKind kind_r, const C_Str &name_r)
Definition: ByIdent.h:78
ByIdent(sat::Solvable slv_r)
Definition: ByIdent.h:33
ByIdent(ResKind kind_r, IdString name_r)
Definition: ByIdent.h:41
ByIdent(IdString ident_r)
Definition: ByIdent.h:37
sat::detail::IdType makeIdent(sat::Solvable slv_r)
Definition: ByIdent.h:63
A Solvable object within the sat Pool.
Definition: Solvable.h:54
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
Definition: Solvable.cc:302
IdString ident() const
The identifier.
Definition: Solvable.cc:269
int IdType
Generic Id type.
Definition: PoolMember.h:104
std::string form(const char *format,...) __attribute__((format(printf
Printf style construction of std::string.
Definition: String.cc:36
Easy-to use interface to the ZYPP dependency resolver.
Definition: CodePitfalls.doc:2
Solvable satSolvable() const
Return the corresponding sat::Solvable.
Definition: SolvableType.h:57