29#undef ZYPP_BASE_LOGGER_LOGGROUP 
   30#define ZYPP_BASE_LOGGER_LOGGROUP "PoolQuery" 
   69    struct EditionRangePredicate
 
   71      EditionRangePredicate( 
const Rel & op, 
const Edition & edition )
 
   72        : _range( op, edition )
 
   75      EditionRangePredicate( 
const Rel & op, 
const Edition & edition, 
const Arch & arch )
 
   76        : _range( op, edition )
 
   93      std::string serialize()
 const 
   95        std::string ret( 
"EditionRange" );
 
  107    struct SolvableRangePredicate
 
  109      SolvableRangePredicate( 
const Rel & op, 
const Edition & edition )
 
  110        : _range( op, edition )
 
  114      SolvableRangePredicate( 
const Rel & op, 
const Edition & edition, 
const Arch & arch )
 
  115        : _range( op, edition )
 
  126      std::string serialize()
 const 
  128        std::string ret( 
"SolvableRange" );
 
  143    struct CapabilityMatchPredicate
 
  154      std::string serialize()
 const 
  156        std::string ret( 
"CapabilityMatch" );
 
  203        : attr(std::move( attr_r ))
 
  207        : attr(std::move( attr_r ))
 
  208        , strMatcher(std::move( strMatcher_r ))
 
  212                     Predicate  predicate_r, std::string  predicateStr_r )
 
  213        : attr(std::move( attr_r ))
 
  214        , strMatcher(std::move( strMatcher_r ))
 
  215        , predicate(std::move( predicate_r ))
 
  216        , predicateStr(std::move( predicateStr_r ))
 
  224      template<
class TPredicate>
 
  225      void addPredicate( 
const TPredicate & predicate_r )
 
  227        predicate    = predicate_r;
 
  228        predicateStr = predicate_r.serialize();
 
  236      std::string serialize()
 const 
  238        std::string ret( 
"AttrMatchData" );
 
  249      static AttrMatchData 
deserialize( 
const std::string & str_r )
 
  251        std::vector<std::string> words;
 
  253        if ( words.empty() || words[0] != 
"AttrMatchData" )
 
  255        if ( words.size() != 5 )
 
  261        if ( 
Match::Mode mode = deserializeMode( words[3] ) )
 
  262          ret.strMatcher.setFlags( mode );
 
  263        ret.predicateStr = words[4];
 
  268        if ( ! words.empty() )
 
  270          if ( words[0] == 
"EditionRange" )
 
  272            switch( words.size() )
 
  275                ret.predicate = EditionRangePredicate( 
Rel(words[1]), Edition(words[2]) );
 
  278                ret.predicate = EditionRangePredicate( 
Rel(words[1]), Edition(words[2]), Arch(words[3]) );
 
  285          else if ( words[0] == 
"SolvableRange" )
 
  287            switch( words.size() )
 
  290                ret.predicate = SolvableRangePredicate( 
Rel(words[1]), Edition(words[2]) );
 
  293                ret.predicate = SolvableRangePredicate( 
Rel(words[1]), Edition(words[2]), Arch(words[3]) );
 
  300          else if ( words[0] == 
"CapabilityMatch" )
 
  302            if ( words.size() != 2 )
 
  304            ret.predicate = CapabilityMatchPredicate( 
Capability(words[1]) );
 
  315      std::string      predicateStr;
 
  320      static std::string serializeMode( 
Match::Mode mode_r )
 
  327#define OUTS(M,S) case Match::M: return #S; break 
  332          OUTS( STRINGSTART,        S );
 
  333          OUTS( STRINGEND,  E );
 
  334          OUTS( SUBSTRING,  B );
 
  346      static Match::Mode deserializeMode( 
const std::string & str_r )
 
  350#define OUTS(M,C) case *#C: return Match::M; break 
  355          OUTS( STRINGSTART,        S );
 
  356          OUTS( STRINGEND,  E );
 
  357          OUTS( SUBSTRING,  B );
 
  370    inline std::ostream & 
operator<<( std::ostream & 
str, 
const AttrMatchData & obj )
 
  372      str << obj.attr << 
": " << obj.strMatcher;
 
  373      if ( obj.kindPredicate )
 
  374        str << 
" +(" << obj.kindPredicate << 
")";
 
  376        str << 
" +(" << obj.predicateStr << 
")";
 
  381    inline bool operator==( 
const AttrMatchData & lhs, 
const AttrMatchData & rhs )
 
  383      return ( lhs.attr == rhs.attr
 
  384               && lhs.strMatcher == rhs.strMatcher
 
  385               && lhs.predicateStr == rhs.predicateStr );
 
  389    inline bool operator!=( 
const AttrMatchData & lhs, 
const AttrMatchData & rhs )
 
  390    { 
return !( lhs == rhs ); }
 
  393    inline bool operator<( 
const AttrMatchData & lhs, 
const AttrMatchData & rhs )
 
  395      if ( lhs.attr != rhs.attr )
 
  396        return (  lhs.attr < rhs.attr );
 
  397      if ( lhs.strMatcher != rhs.strMatcher )
 
  398        return (  lhs.strMatcher < rhs.strMatcher );
 
  399      if ( lhs.predicateStr != rhs.predicateStr )
 
  400        return (  lhs.predicateStr < rhs.predicateStr );
 
  404    using AttrMatchList = std::list<AttrMatchData>;
 
  471#define OUTS(A) if ( A != rhs.A ) return A < rhs.A; 
 
  537    { 
return new Impl( *
this ); }
 
 
 
  589    else if (
_attrs.size() == 1)
 
  602      bool attrvals_empty = 
true;
 
  605        if ( ai->second.empty() )
 
  607        for_( it, ai->second.begin(), ai->second.end() )
 
  611            attrvals_empty = 
false;
 
  615        if ( ! attrvals_empty )
 
  620      bool attrvals_thesame = 
true;
 
  621      AttrRawStrMap::const_iterator ai = 
_attrs.begin();
 
  624      for (; ai != 
_attrs.end(); ++ai)
 
  628          set1.begin(), set1.end(),
 
  629          ai->second.begin(), ai->second.end(),
 
  630          inserter(result, result.begin()));
 
  633          attrvals_thesame = 
false;
 
  642      if (attrvals_empty || attrvals_thesame)
 
  691          const std::string & mstr( it->strMatcher.searchstring() );
 
  692          if ( ! mstr.empty() )
 
  693            joined.insert( mstr );
 
  696          AttrMatchData nattr( *it );
 
  717      it->strMatcher.compile(); 
 
 
  729    std::string rxEscape( std::string str_r, 
const Match & flags_r )
 
  744    if ( container_r.empty() )
 
  748      return StrMatcher( *container_r.begin(), flags_r );
 
  753    Match retflags( flags_r );
 
  764    for ( const::std::string & s : container_r )
 
  766      ret << sep << rxEscape( s, flags_r );
 
 
  782    std::ostringstream o;
 
  789      for(Kinds::const_iterator it = 
_kinds.begin();
 
  800      for(StrContainer::const_iterator it = 
_repos.begin();
 
  806    o << 
"version: "<< 
_op << 
" " << 
_edition.asString() << endl;
 
  810    o << 
"string match flags: " << 
Match(
_flags) << endl;
 
  814    for(StrContainer::const_iterator it = 
_strings.begin();
 
  819    o << 
"attributes: " << endl;
 
  820    for(AttrRawStrMap::const_iterator ai = 
_attrs.begin(); ai != 
_attrs.end(); ++ai)
 
  822      o << 
"* " << ai->first << 
": ";
 
  823      for(StrContainer::const_iterator vi = ai->second.begin();
 
  824          vi != ai->second.end(); ++vi)
 
  829    o << 
"predicated: " << endl;
 
  832      o << 
"* " << *it << endl;
 
  836    o << 
"last attribute matcher compiled: " << endl;
 
  839      o << 
"not yet compiled" << endl;
 
  845        o << 
"* " << *it << endl;
 
 
  868    if (repoalias.empty())
 
  870      WAR << 
"ignoring an empty repository alias" << endl;
 
  873    _pimpl->_repos.insert(repoalias);
 
 
  883  { 
_pimpl->_strings.insert(value); }
 
 
  886  { 
_pimpl->_attrs[attr].insert(value); }
 
 
  922    AttrMatchData attrMatchData( attr );
 
  924      attrMatchData.strMatcher = 
StrMatcher( name, mode );
 
  928      attrMatchData.strMatcher = 
StrMatcher( strchr( name.c_str(), 
':')+1, mode );
 
  929      attrMatchData.kindPredicate = explicitKind;
 
  932    if ( isDependencyAttribute( attr ) )
 
  933      attrMatchData.addPredicate( EditionRangePredicate( op, 
edition, arch ) );
 
  935      attrMatchData.addPredicate( SolvableRangePredicate( op, 
edition, arch ) );
 
  937    _pimpl->_uncompiledPredicated.insert( attrMatchData );
 
 
  949    if ( isDependencyAttribute( attr ) )
 
  950      attrMatchData.addPredicate( CapabilityMatchPredicate( cap_r ) );
 
  952      attrMatchData.addPredicate( SolvableRangePredicate( cap.
op(), cap.
ed() ) );
 
  954    _pimpl->_uncompiledPredicated.insert( attrMatchData );
 
 
  970  { 
return _pimpl->_flags; }
 
 
  985  { 
return _pimpl->_strings; }
 
 
  989  { 
return _pimpl->_attrs; }
 
 
  995    AttrRawStrMap::const_iterator it = 
_pimpl->_attrs.find(attr);
 
  996    return it != 
_pimpl->_attrs.end() ? it->second : nocontainer;
 
 
 1000  { 
return _pimpl->_edition; }
 
 
 1007  { 
return _pimpl->_kinds; }
 
 
 1011  { 
return _pimpl->_repos; }
 
 
 1015  { 
return _pimpl->_comment; }
 
 
 1034  { 
return _pimpl->_status_flags; }
 
 
 1154    bool finded_something = 
false; 
 
 1160      getline( 
str, s, delim );
 
 1162      if ((!s.empty()) && s[0]==
'#') 
 
 1167      std::string::size_type pos = s.find(
':');
 
 1168      if (s.empty() || pos == s.npos) 
 
 1170        if (finded_something) 
 
 1180      finded_something = 
true;
 
 1182      std::string attrName(
str::trim(std::string(s,0,pos))); 
 
 1183      std::string attrValue(
str::trim(std::string(s,pos+1,s.npos))); 
 
 1231          WAR << 
"unknown string type " << attrValue << endl;
 
 1235          WAR << 
"forget recover some attribute defined as String type attribute: " << attrValue << endl;
 
 1255          WAR << 
"unknown boolean value " << attrValue << endl;
 
 1260        if( attrValue == 
"all" )
 
 1264        else if( attrValue == 
"installed" )
 
 1268        else if( attrValue == 
"not-installed" )
 
 1274          WAR << 
"Unknown value for install status " << attrValue << endl;
 
 1279        std::string::size_type pos = 0;
 
 1281        if (attrValue.find_first_of(
"=<>!") == 0)
 
 1283          pos = attrValue.find_last_of(
"=<>");
 
 1284          rel = 
Rel(attrValue.substr(0, pos+1));
 
 1285          attrValue = 
str::trim(attrValue.substr(pos+1, attrValue.npos));
 
 1294          _pimpl->_uncompiledPredicated.insert( AttrMatchData::deserialize( attrValue ) );
 
 1304        WAR << 
"empty attribute name" << endl;
 
 1308        std::string s = attrName;
 
 1344      const AttrMatchData & attrmatch {  *
_pimpl->_uncompiledPredicated.begin() };
 
 1350        std::vector<std::string> words;
 
 1352        if ( words.size() < 4 || words[3].empty() )
 
 1364          if ( attrmatch.kindPredicate )
 
 1367            addKind( attrmatch.kindPredicate );
 
 1374          std::vector<std::string> words;
 
 1376          if ( ! words.empty() )
 
 1378            if ( words[0] == 
"EditionRange" || words[0] == 
"SolvableRange" )
 
 1385          _pimpl->_uncompiledPredicated.clear();
 
 1390    return finded_something;
 
 
 1402      str << 
"repo: " << *it << delim ;
 
 1408          << it->idStr() << delim ;
 
 1423            << 
": substring" << delim;
 
 1438      str << 
"case_sensitive: ";
 
 1441        str << 
"on" << delim;
 
 1445        str << 
"off" << delim;
 
 1454        str << 
"install_status: all" << delim;
 
 1457        str << 
"install_status: installed" << delim;
 
 1460        str << 
"install_status: not-installed" << delim;
 
 1472      std::string s = it->first.asString();
 
 1474      for_( it2,it->second.begin(),it->second.end() )
 
 1476        str << s <<
": "<< *it2 << delim;
 
 1480    for_( it, 
_pimpl->_uncompiledPredicated.begin(), 
_pimpl->_uncompiledPredicated.end() )
 
 1482      str << 
"complex: "<< it->serialize() << delim;
 
 1485    if ( 
const std::string & c { 
comment() }; not c.empty() )
 
 
 1493  { 
return _pimpl->asString(); }
 
 
 1545          if ( base_r == 
end() )
 
 1553          while ( base_r != 
end() )
 
 
 1568          if ( base_r == 
end() )
 
 1579            base.stayInThisSolvable(); 
 
 1580            return_r.push_back( 
base );
 
 1582            const AttrMatchData::Predicate & predicate( 
_attrMatchList.front().predicate );
 
 1583            for ( ++
base; 
base.inSolvable() == inSolvable; ++
base ) 
 
 1585              if ( ! predicate || predicate( 
base ) )
 
 1586                return_r.push_back( 
base );
 
 1594              const AttrMatchData & matchData( *mi );
 
 1596              if ( matchData.strMatcher ) 
 
 1602                const AttrMatchData::Predicate & predicate( matchData.predicate );
 
 1605                  if ( ! predicate || predicate( it ) )
 
 1606                    return_r.push_back( it );
 
 
 1629          for_( it, query_r->_repos.begin(), query_r->_repos.end() )
 
 1643          _kinds = query_r->_kinds;
 
 
 1666          if ( 
_repos.size() == 1 )
 
 1675            if ( matchData.strMatcher ) 
 
 
 1738            if ( matchData.kindPredicate )
 
 1740              if ( matchData.kindPredicate != inSolvable.
kind() )
 
 1746            else if ( !globalKindOk )
 
 1749            if ( !matchData.predicate || matchData.predicate( base_r ) )
 
 1758            const AttrMatchData & matchData( *mi );
 
 1760            if ( matchData.kindPredicate )
 
 1762              if ( matchData.kindPredicate != inSolvable.
kind() )
 
 1765            else if ( !globalKindOk )
 
 1769            if ( matchData.strMatcher ) 
 
 1775              const AttrMatchData::Predicate & predicate( matchData.predicate );
 
 1780                  if ( predicate( it ) )
 
 
 
 1817      if ( ! 
_matcher->advance( base_reference() ) )
 
 
 1845          str << endl << 
"    " << it->inSolvAttr() << 
"\t" << it->asString();
 
 
 
bool empty() const
Test for an empty Arch (this is Arch_epmty, not Arch_noarch ).
bool operator()(const zypp::Arch &lhs, const zypp::Arch &rhs) const
Default order for std::container based Arch::compare.
Helper providing more detailed information about a Capability.
static const CapMatch yes
Integral type with defined initial value when default constructed.
Edition represents [epoch:]version[-release]
Range< Edition, Match > MatchRange
Edition Range based on Match.
static const Edition noedition
Value representing noedition ("") This is in fact a valid Edition.
Base class for Exception.
std::string asUserHistory() const
A single (multiline) string composed of asUserString and historyAsString.
Access to the sat-pools string space.
std::string asString() const
Conversion to std::string
String matching option flags as used e.g.
Mode
Mode flags (mutual exclusive).
@ REGEX
Regular Expression.
@ SUBSTRING
Match substring.
bool isModeString() const
Whether this has mode STRING.
static const Match FILES
LookupAttr: match full path when matching in filelists, otherwise just the basenames.
void setModeRegex()
Set the mode REGEX.
static const Match NOCASE
If set, match case insensitive.
bool isModeGlob() const
Whether this has mode GLOB.
bool isModeRegex() const
Whether this has mode REGEX.
Edition _edition
Edition condition operand.
Kinds _kinds
Kinds to search.
StrContainer _repos
Repos to search.
StatusFilter _status_flags
Sat solver status flags.
Rel _op
Operator for edition condition.
Match _flags
Sat solver search flags.
std::string _comment
Optional comment string for serialization.
void compile() const
Compile the regex.
friend Impl * rwcowClone(const Impl *rhs)
bool operator<(const PoolQuery::Impl &rhs) const
bool operator!=(const PoolQuery::Impl &rhs) const
StrContainer _strings
Raw search strings.
std::set< AttrMatchData > _uncompiledPredicated
Uncompiled attributes with predicate.
StrMatcher joinedStrMatcher(const StrContainer &container_r, const Match &flags_r) const
Join patterns in container_r according to flags_r into a single StrMatcher.
AttrRawStrMap _attrs
Raw attributes.
Impl(const Impl &)=default
Impl & operator=(const Impl &)=delete
AttrMatchList _attrMatchList
StrMatcher per attribtue.
Impl & operator=(Impl &&)=delete
bool operator==(const PoolQuery::Impl &rhs) const
Impl * clone() const
clone for RWCOW_pointer
std::string asString() const
String representation.
Match flags() const
Free function to get libsolv repo search flags.
void addString(const std::string &value)
Add a global query string.
const Rel editionRel() const
bool matchSubstring() const
const StrContainer & repos() const
void setMatchExact()
Set to match exact string instead of substring.
void setMatchWord()
Set substring to match words.
void setMatchRegex()
Set to use the query strings as regexes.
void setFlags(const Match &flags)
Free function to set libsolv repo search flags.
RW_pointer< Impl > _pimpl
Pointer to implementation.
void setCaseSensitive(bool value=true)
Turn case sentitivity on or off (unsets or sets SEARCH_NOCASE flag).
void setComment(const std::string &comment) const
Set an optional comment string describing the purpose of the query.
void execute(ProcessResolvable fnc)
Executes the query with the current settings.
std::string asString() const
Return a human-readable description of the query.
void setStatusFilterFlags(StatusFilter flags)
Set status filter directly.
bool empty() const
Whether the result is empty.
void addKind(const ResKind &kind)
Filter by selectable kind.
bool operator==(const PoolQuery &b) const
void setRequireAll(bool require_all=true) ZYPP_DEPRECATED
function< bool(const sat::Solvable &)> ProcessResolvable
void addAttribute(const sat::SolvAttr &attr, const std::string &value="")
Filter by the value of the specified attr attribute.
bool requireAll() const ZYPP_DEPRECATED
std::map< sat::SolvAttr, StrContainer > AttrRawStrMap
const std::string & comment() const
bool filesMatchFullPath() const
Whether searching in filelists looks at the full path or just at the basenames.
void addRepo(const std::string &repoalias)
Filter by repo.
const Kinds & kinds() const
Match::Mode matchMode() const
Returns string matching mode as enum.
void setInstalledOnly()
Return only @System repo packages.
const Edition edition() const
const_iterator end() const
An iterator pointing to the end of the query result.
StatusFilter statusFilterFlags() const
const StrContainer & strings() const
Search strings added via addString()
std::set< std::string > StrContainer
size_type size() const
Number of solvables in the query result.
const_iterator begin() const
Query result accessers.
bool recover(std::istream &str, char delim='\n')
Reads from stream query.
void serialize(std::ostream &str, char delim='\n') const
Writes a machine-readable string representation of the query to stream.
const AttrRawStrMap & attributes() const
Map (map<SolvAttr, StrContainer>) of attribute values added via addAttribute(), addDep in string form...
void addDependency(const sat::SolvAttr &attr, const std::string &name, const Rel &op, const Edition &edition)
Query "name|global op edition".
StatusFilter
Installed status filter setters.
void setEdition(const Edition &edition, const Rel &op=Rel::EQ)
Set version condition.
const StrContainer & attribute(const sat::SolvAttr &attr) const
void setMatchSubstring()
Set to substring (the default).
void setFilesMatchFullPath(bool value=true)
If set (default), look at the full path when searching in filelists.
std::set< ResKind > Kinds
void setUninstalledOnly()
Return only packages from repos other than @System.
void setMatchGlob()
Set to match globs.
bool operator<(const PoolQuery &b) const
bool caseSensitive() const
returns true if search is case sensitive
bool isSystemRepo() const
Return whether this is the system repository.
static ResKind explicitBuiltin(const char *str_r)
Return the builtin kind if str_r explicitly prefixed.
static const ResKind nokind
Value representing nokind ("")
String matching (STRING|SUBSTRING|GLOB|REGEX).
static const StringTypeAttr substringAttr
static const StringTypeAttr wordAttr
StringTypeAttr(const char *cstr_r)
StringTypeAttr(const std::string &str_r)
static const StringTypeAttr noAttr
static const StringTypeAttr globAttr
static const StringTypeAttr exactAttr
static const StringTypeAttr regexAttr
PoolQuery iterator as returned by PoolQuery::begin.
const Matches & matches() const
matches_iterator matchesEnd() const
End of matches.
bool matchesEmpty() const
False unless this is the end iterator.
shared_ptr< Matches > _matches
matches_iterator matchesBegin() const
Begin of matches.
shared_ptr< PoolQueryMatcher > _matcher
std::vector< sat::LookupAttr::iterator > Matches
PoolQueryIterator()
Default ctor is also end.
Store PoolQuery settings and assist PoolQueryIterator.
PoolQueryMatcher(PoolQueryMatcher &&)=default
sat::LookupAttr::iterator base_iterator
std::set< Repository > _repos
Repositories include in the search.
PoolQueryMatcher & operator=(const PoolQueryMatcher &)=default
PoolQueryMatcher(const PoolQueryMatcher &)=default
bool isAMatch(base_iterator &base_r) const
Check whether we are on a match.
bool advance(base_iterator &base_r) const
PoolQueryMatcher(const shared_ptr< const PoolQuery::Impl > &query_r)
Ctor stores the PoolQuery settings.
std::set< ResKind > _kinds
Resolvable kinds to include.
AttrMatchList _attrMatchList
StrMatcher per attribtue.
const base_iterator & end() const
DefaultIntegral< bool, false > _neverMatchRepo
void matchDetail(const base_iterator &base_r, std::vector< base_iterator > &return_r) const
Provide all matching attributes within this solvable.
base_iterator startNewQyery() const
Initialize a new base query.
int _status_flags
Installed status filter flags.
PoolQueryMatcher & operator=(PoolQueryMatcher &&)=default
detail::IdType id() const
Tp asType() const
Templated return type.
void nextSkipSolvable()
On the next call to operator++ advance to the next Solvable.
Solvable inSolvable() const
The current Solvable.
void nextSkipRepo()
On the next call to operator++ advance to the next Repository.
Repository inRepo() const
The current Repository.
Lightweight attribute value lookup.
iterator end() const
Iterator behind the end of query results.
bool empty() const
Whether the query is empty.
void setStrMatcher(const StrMatcher &matcher_r)
Set the pattern to match.
void setAttr(SolvAttr attr_r)
Set the SolvAttr to search.
void setRepo(Repository repo_r, Location=SOLV_ATTR)
Set search in one Repository.
iterator begin() const
Iterator to the begin of query results.
Repository reposFind(const std::string &alias_r) const
Find a Repository named alias_r.
static Pool instance()
Singleton ctor.
static const SolvAttr dep_requires
static const SolvAttr name
static const SolvAttr dep_enhances
static const SolvAttr dep_obsoletes
static const SolvAttr dep_suggests
static const SolvAttr dep_provides
static const SolvAttr dep_conflicts
static const SolvAttr allAttr
Value to request searching all Attributes (0).
static const SolvAttr dep_recommends
static const SolvAttr dep_supplements
A Solvable object within the sat Pool.
ResKind kind() const
The Solvables ResKind.
Edition edition() const
The edition (version-release).
Arch arch() const
The architecture.
bool isKind(const ResKind &kind_r) const
Test whether a Solvable is of a certain ResKind.
bool compareByRel(Rel op, const Tp &lhs, const Tp &rhs, TCompare compare)
Comparison of two elements using relational operator op.
String related utilities and Regular expression matching.
std::string & replaceAll(std::string &str_r, const std::string &from_r, const std::string &to_r)
Replace all occurrences of from_r with to_r in str_r (inplace).
bool strToTrue(const C_Str &str)
Parsing boolean from string.
std::string rxEscapeGlob(std::string str_r)
Escape GLOB str_r for use in a regex (not anchored by "^" or "$").
void appendEscaped(std::string &str_r, const C_Str &next_r, const char sep_r=' ')
Escape next_r and append it to str_r using separator sep_r.
std::string rxEscapeStr(std::string str_r)
Escape plain STRING str_r for use in a regex (not anchored by "^" or "$").
bool strToFalse(const C_Str &str)
Return false if str is 0, false, no, off, never.
unsigned splitEscaped(const C_Str &line_r, TOutputIterator result_r, const C_Str &sepchars_r=" \t", bool withEmpty=false)
Split line_r into words with respect to escape delimeters.
std::string trim(const std::string &s, const Trim trim_r)
Easy-to use interface to the ZYPP dependency resolver.
bool operator<(const StrMatcher &lhs, const StrMatcher &rhs)
std::ostream & dumpRange(std::ostream &str, TIterator begin, TIterator end, const std::string &intro="{", const std::string &pfx="\n  ", const std::string &sep="\n  ", const std::string &sfx="\n", const std::string &extro="}")
Print range defined by iterators (multiline style).
bool operator==(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
std::ostream & dumpOn(std::ostream &str, const Capability &obj)
bool overlaps(const Range< Tp, TCompare > &lhs, const Range< Tp, TCompare > &rhs)
const Arch Arch_empty(IdString::Empty)
std::ostream & operator<<(std::ostream &str, const SerialNumber &obj)
const ResKind ResTraits< Package >::kind(ResKind::package)
bool operator!=(const SetRelation::Enum &lhs, const SetCompare &rhs)
This is an overloaded member function, provided for convenience. It differs from the above function o...
bool deserialize(const std::string &str_r, DownloadMode &result_r)
int invokeOnEach(TIterator begin_r, TIterator end_r, TFilter filter_r, TFunction fnc_r)
Iterate through [begin_r,end_r) and invoke fnc_r on each item that passes filter_r.
bool operator()(const std::string &str)
PoolQuery::StrContainer & _cont
bool operator()(const std::string &str)
MyInserter(PoolQuery::StrContainer &cont)
represents all atributes in PoolQuery except SolvAtributes, which are used as is (not needed extend a...
PoolQueryAttr(const std::string &str_r)
static const PoolQueryAttr stringAttr
static const PoolQueryAttr kindAttr
static const PoolQueryAttr editionAttr
static const PoolQueryAttr installStatusAttr
static const PoolQueryAttr commentAttr
static const PoolQueryAttr repoAttr
static const PoolQueryAttr requireAllAttr
PoolQueryAttr(const char *cstr_r)
static const PoolQueryAttr caseSensitiveAttr
static const PoolQueryAttr noAttr
static const PoolQueryAttr complexAttr
static const PoolQueryAttr stringTypeAttr
Convenient building of std::string via std::ostringstream Basically a std::ostringstream autoconverti...
#define arrayBegin(A)
Simple C-array iterator.
#define for_(IT, BEG, END)
Convenient for-loops using iterator.
#define ZYPP_THROW(EXCPT)
Drops a logline and throws the Exception.