libzypp: zypp/pool/ByIdent.h Source File

libzypp 17.25.10

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