From 1dc9553357147884c56711f72bf7ddc0ed4f1a99 Mon Sep 17 00:00:00 2001 From: Michael Andres Date: Wed, 11 Apr 2012 15:49:50 +0200 Subject: [PATCH] Rename zypp::sat::AttrMatcher to zypp::StrMatcher (base/StrMatcher.h) The implementation uses libsolv, but the class is not sat:: specific as it matches arbitrary strings. --- tests/sat/CMakeLists.txt | 1 - tests/sat/LookupAttr_test.cc | 10 +- tests/zypp/CMakeLists.txt | 1 + .../StrMatcher_test.cc} | 30 +- zypp/CMakeLists.txt | 5 +- zypp/PoolQuery.cc | 76 ++-- zypp/PoolQuery.h | 2 +- zypp/base/Regex.h | 2 +- zypp/base/StrMatcher.cc | 324 ++++++++++++++++ zypp/base/StrMatcher.h | 409 +++++++++++++++++++++ zypp/sat/AttrMatcher.cc | 342 ----------------- zypp/sat/AttrMatcher.h | 404 +------------------- zypp/sat/LookupAttr.cc | 22 +- zypp/sat/LookupAttr.h | 19 +- 14 files changed, 822 insertions(+), 825 deletions(-) rename tests/{sat/AttrMatcher_test.cc => zypp/StrMatcher_test.cc} (86%) create mode 100644 zypp/base/StrMatcher.cc create mode 100644 zypp/base/StrMatcher.h delete mode 100644 zypp/sat/AttrMatcher.cc diff --git a/tests/sat/CMakeLists.txt b/tests/sat/CMakeLists.txt index aa09fe5..4bf1afd 100644 --- a/tests/sat/CMakeLists.txt +++ b/tests/sat/CMakeLists.txt @@ -3,7 +3,6 @@ INCLUDE_DIRECTORIES( ${LIBZYPP_SOURCE_DIR}/tests/zypp ) ADD_TESTS( - AttrMatcher IdString LookupAttr Pool diff --git a/tests/sat/LookupAttr_test.cc b/tests/sat/LookupAttr_test.cc index f82606c..936307a 100644 --- a/tests/sat/LookupAttr_test.cc +++ b/tests/sat/LookupAttr_test.cc @@ -1,6 +1,6 @@ #include "TestSetup.h" #include -#include +#include #include static TestSetup test( Arch_x86_64 ); @@ -54,10 +54,10 @@ BOOST_AUTO_TEST_CASE(LookupAttr_existingattr_matcher) { sat::LookupAttr q( sat::SolvAttr::name ); - BOOST_CHECK_THROW( q.setAttrMatcher( sat::AttrMatcher("[]ypper",Match::REGEX) ), MatchInvalidRegexException ); - BOOST_CHECK( ! q.attrMatcher() ); - BOOST_CHECK_NO_THROW( q.setAttrMatcher( sat::AttrMatcher("[zZ]ypper",Match::REGEX) ) ); - BOOST_CHECK( q.attrMatcher() ); + BOOST_CHECK_THROW( q.setStrMatcher( StrMatcher("[]ypper",Match::REGEX) ), MatchInvalidRegexException ); + BOOST_CHECK( ! q.strMatcher() ); + BOOST_CHECK_NO_THROW( q.setStrMatcher( StrMatcher("[zZ]ypper",Match::REGEX) ) ); + BOOST_CHECK( q.strMatcher() ); BOOST_CHECK_EQUAL( q.size(), 9 ); for_(it,q.begin(),q.end()) diff --git a/tests/zypp/CMakeLists.txt b/tests/zypp/CMakeLists.txt index 3872f7d..b2cfee6 100644 --- a/tests/zypp/CMakeLists.txt +++ b/tests/zypp/CMakeLists.txt @@ -35,6 +35,7 @@ ADD_TESTS( ResKind ResStatus Selectable + StrMatcher Target Url Vendor diff --git a/tests/sat/AttrMatcher_test.cc b/tests/zypp/StrMatcher_test.cc similarity index 86% rename from tests/sat/AttrMatcher_test.cc rename to tests/zypp/StrMatcher_test.cc index 98a679c..ec2e157 100644 --- a/tests/sat/AttrMatcher_test.cc +++ b/tests/zypp/StrMatcher_test.cc @@ -1,6 +1,6 @@ #include "TestSetup.h" #include -#include +#include #include /////////////////////////////////////////////////////////////////// @@ -69,13 +69,13 @@ BOOST_AUTO_TEST_CASE(Match_operator) /////////////////////////////////////////////////////////////////// // -// CLASS NAME : AttrMatcher +// CLASS NAME : StrMatcher // /////////////////////////////////////////////////////////////////// -BOOST_AUTO_TEST_CASE(AttrMatcher_defaultconstructed) +BOOST_AUTO_TEST_CASE(StrMatcher_defaultconstructed) { - sat::AttrMatcher m; + StrMatcher m; BOOST_CHECK_EQUAL( m.flags(), Match::NOTHING ); BOOST_CHECK( !m ); // eval in boolean context BOOST_CHECK( m.searchstring().empty() ); @@ -90,15 +90,15 @@ BOOST_AUTO_TEST_CASE(AttrMatcher_defaultconstructed) BOOST_CHECK( m ); // eval in boolean context } -BOOST_AUTO_TEST_CASE(AttrMatcher_OTHER) +BOOST_AUTO_TEST_CASE(StrMatcher_OTHER) { - sat::AttrMatcher m( "fau", Match::OTHER ); + StrMatcher m( "fau", Match::OTHER ); BOOST_CHECK_THROW( m.compile(), MatchUnknownModeException ); } -BOOST_AUTO_TEST_CASE(AttrMatcher_STRING) +BOOST_AUTO_TEST_CASE(StrMatcher_STRING) { - sat::AttrMatcher m( "fau" ); + StrMatcher m( "fau" ); BOOST_CHECK_EQUAL( m.flags(), Match::STRING ); BOOST_CHECK( !m( "" ) ); BOOST_CHECK( !m( "a" ) ); @@ -106,9 +106,9 @@ BOOST_AUTO_TEST_CASE(AttrMatcher_STRING) BOOST_CHECK( !m( "default" ) ); } -BOOST_AUTO_TEST_CASE(AttrMatcher_STRINGSTART) +BOOST_AUTO_TEST_CASE(StrMatcher_STRINGSTART) { - sat::AttrMatcher m( "fau", Match::STRINGSTART ); + StrMatcher m( "fau", Match::STRINGSTART ); BOOST_CHECK( !m( "" ) ); BOOST_CHECK( !m( "a" ) ); BOOST_CHECK( m( "fau" ) ); @@ -116,9 +116,9 @@ BOOST_AUTO_TEST_CASE(AttrMatcher_STRINGSTART) BOOST_CHECK( !m( "default" ) ); } -BOOST_AUTO_TEST_CASE(AttrMatcher_STRINGEND) +BOOST_AUTO_TEST_CASE(StrMatcher_STRINGEND) { - sat::AttrMatcher m( "fau", Match::STRINGEND ); + StrMatcher m( "fau", Match::STRINGEND ); BOOST_CHECK( !m( "" ) ); BOOST_CHECK( !m( "a" ) ); BOOST_CHECK( m( "fau" ) ); @@ -126,9 +126,9 @@ BOOST_AUTO_TEST_CASE(AttrMatcher_STRINGEND) BOOST_CHECK( !m( "default" ) ); } -BOOST_AUTO_TEST_CASE(AttrMatcher_REGEX) +BOOST_AUTO_TEST_CASE(StrMatcher_REGEX) { - sat::AttrMatcher m( "fau" ); + StrMatcher m( "fau" ); BOOST_CHECK( !m.isCompiled() ); BOOST_CHECK_NO_THROW( m.compile() ); @@ -150,7 +150,7 @@ BOOST_AUTO_TEST_CASE(AttrMatcher_REGEX) } #if 0 -BOOST_AUTO_TEST_CASE(AttrMatcher_) +BOOST_AUTO_TEST_CASE(StrMatcher_) { base::LogControl::TmpLineWriter shutUp( new log::FileLineWriter( "/tmp/YLOG" ) ); MIL << "GO" << endl; diff --git a/zypp/CMakeLists.txt b/zypp/CMakeLists.txt index a2ecac1..641835a 100644 --- a/zypp/CMakeLists.txt +++ b/zypp/CMakeLists.txt @@ -200,6 +200,8 @@ SET( zypp_base_SRCS base/InputStream.cc base/ReferenceCounted.cc base/String.cc + base/StrMatcher.h + base/StrMatcher.cc base/Regex.cc base/Unit.cc base/ExternalDataSource.cc @@ -247,6 +249,7 @@ SET( zypp_base_HEADERS base/SafeBool.h base/Signal.h base/String.h + base/StrMatcher.h base/Regex.h base/Sysconfig.h base/Tr1hash.h @@ -536,7 +539,6 @@ SET( zypp_sat_SRCS sat/LocaleSupport.cc sat/LookupAttr.cc sat/SolvAttr.cc - sat/AttrMatcher.cc ) SET( zypp_sat_HEADERS @@ -553,7 +555,6 @@ SET( zypp_sat_HEADERS sat/LookupAttr.h sat/LookupAttrTools.h sat/SolvAttr.h - sat/AttrMatcher.h ) INSTALL( FILES diff --git a/zypp/PoolQuery.cc b/zypp/PoolQuery.cc index a2dba81..ec7bc45 100644 --- a/zypp/PoolQuery.cc +++ b/zypp/PoolQuery.cc @@ -21,7 +21,7 @@ #include "zypp/sat/Pool.h" #include "zypp/sat/Solvable.h" -#include "zypp/sat/AttrMatcher.h" +#include "zypp/base/StrMatcher.h" #include "zypp/PoolQuery.h" @@ -165,13 +165,13 @@ namespace zypp ///////////////////////////////////////////////////////////////// /** Match data per attribtue. * - * This includes the attribute itself, an optional \ref sat::AttrMatcher + * This includes the attribute itself, an optional \ref StrMatcher * to restrict the query to certain string values, and an optional * boolean \ref Predicate that may apply further restrictions that can - * not be expressed by the \ref attrMatcher. + * not be expressed by the \ref strMatcher. * * Example for such a \ref predicate would be an additional edition range - * check whan looking for dependencies. The \ref attrMatcher would + * check whan looking for dependencies. The \ref strMatcher would * find potential matches by looking at the dependencies name, the * predicate will then check the edition ranges. * @@ -191,15 +191,15 @@ namespace zypp AttrMatchData() {} - AttrMatchData( sat::SolvAttr attr_r, const sat::AttrMatcher & attrMatcher_r ) + AttrMatchData( sat::SolvAttr attr_r, const StrMatcher & strMatcher_r ) : attr( attr_r ) - , attrMatcher( attrMatcher_r ) + , strMatcher( strMatcher_r ) {} - AttrMatchData( sat::SolvAttr attr_r, const sat::AttrMatcher & attrMatcher_r, + AttrMatchData( sat::SolvAttr attr_r, const StrMatcher & strMatcher_r, const Predicate & predicate_r, const std::string & predicateStr_r ) : attr( attr_r ) - , attrMatcher( attrMatcher_r ) + , strMatcher( strMatcher_r ) , predicate( predicate_r ) , predicateStr( predicateStr_r ) {} @@ -225,11 +225,11 @@ namespace zypp { std::string ret( "AttrMatchData" ); str::appendEscaped( ret, attr.asString() ); - str::appendEscaped( ret, attrMatcher.searchstring() ); + str::appendEscaped( ret, strMatcher.searchstring() ); // TODO: Actually the flag should be serialized too, but for PoolQuery // it's by now sufficient to differ between mode OTHER and others, // i.e. whether to compile or not compile. - str::appendEscaped( ret, attrMatcher.flags().mode() == Match::OTHER ? "C" : "X" ); + str::appendEscaped( ret, strMatcher.flags().mode() == Match::OTHER ? "C" : "X" ); str::appendEscaped( ret, predicateStr ); return ret; } @@ -248,9 +248,9 @@ namespace zypp AttrMatchData ret; ret.attr = sat::SolvAttr( words[1] ); - ret.attrMatcher = sat::AttrMatcher( words[2] ); + ret.strMatcher = StrMatcher( words[2] ); if ( words[3] == "C" ) - ret.attrMatcher.setFlags( Match::OTHER ); + ret.strMatcher.setFlags( Match::OTHER ); ret.predicateStr = words[4]; // now the predicate @@ -301,7 +301,7 @@ namespace zypp } sat::SolvAttr attr; - sat::AttrMatcher attrMatcher; + StrMatcher strMatcher; Predicate predicate; std::string predicateStr; }; @@ -309,7 +309,7 @@ namespace zypp /** \relates AttrMatchData */ inline std::ostream & operator<<( std::ostream & str, const AttrMatchData & obj ) { - str << obj.attr << ": " << obj.attrMatcher; + str << obj.attr << ": " << obj.strMatcher; if ( obj.predicate ) str << " +(" << obj.predicateStr << ")"; return str; @@ -319,7 +319,7 @@ namespace zypp inline bool operator==( const AttrMatchData & lhs, const AttrMatchData & rhs ) { return ( lhs.attr == rhs.attr - && lhs.attrMatcher == rhs.attrMatcher + && lhs.strMatcher == rhs.strMatcher && lhs.predicateStr == rhs.predicateStr ); } @@ -332,8 +332,8 @@ namespace zypp { if ( lhs.attr != rhs.attr ) return ( lhs.attr < rhs.attr ); - if ( lhs.attrMatcher != rhs.attrMatcher ) - return ( lhs.attrMatcher < rhs.attrMatcher ); + if ( lhs.strMatcher != rhs.strMatcher ) + return ( lhs.strMatcher < rhs.strMatcher ); if ( lhs.predicateStr != rhs.predicateStr ) return ( lhs.predicateStr < rhs.predicateStr ); return false; @@ -420,11 +420,11 @@ namespace zypp public: /** Compile the regex. * Basically building the \ref _attrMatchList from strings. - * \throws MatchException Any of the exceptions thrown by \ref AttrMatcher::compile. + * \throws MatchException Any of the exceptions thrown by \ref StrMatcher::compile. */ void compile() const; - /** AttrMatcher per attribtue. */ + /** StrMatcher per attribtue. */ mutable AttrMatchList _attrMatchList; private: @@ -501,7 +501,7 @@ namespace zypp if (joined.size() > 1) // switch to regex for multiple strings cflags.setModeRegex(); _attrMatchList.push_back( AttrMatchData( _attrs.begin()->first, - sat::AttrMatcher( rcstrings, cflags ) ) ); + StrMatcher( rcstrings, cflags ) ) ); } // // MULTIPLE ATTRIBUTES @@ -559,8 +559,8 @@ attremptycheckend: } if (joined.size() > 1) // switch to regex for multiple strings cflags.setModeRegex(); - // May use the same AttrMatcher for all - sat::AttrMatcher matcher( rcstrings, cflags ); + // May use the same StrMatcher for all + StrMatcher matcher( rcstrings, cflags ); for_( ai, _attrs.begin(), _attrs.end() ) { _attrMatchList.push_back( AttrMatchData( ai->first, matcher ) ); @@ -582,7 +582,7 @@ attremptycheckend: if (joined.size() > 1) // switch to regex for multiple strings cflags.setModeRegex(); _attrMatchList.push_back( AttrMatchData( ai->first, - sat::AttrMatcher( s, cflags ) ) ); + StrMatcher( s, cflags ) ) ); } } } @@ -594,11 +594,11 @@ attremptycheckend: invokeOnEach( _strings.begin(), _strings.end(), EmptyFilter(), MyInserter(global) ); for_( it, _uncompiledPredicated.begin(), _uncompiledPredicated.end() ) { - if ( it->attrMatcher.flags().mode() == Match::OTHER ) + if ( it->strMatcher.flags().mode() == Match::OTHER ) { // need to compile: StrContainer joined( global ); - const std::string & mstr( it->attrMatcher.searchstring() ); + const std::string & mstr( it->strMatcher.searchstring() ); if ( ! mstr.empty() ) joined.insert( mstr ); @@ -608,7 +608,7 @@ attremptycheckend: cflags.setModeRegex(); _attrMatchList.push_back( AttrMatchData( it->attr, - sat::AttrMatcher( rcstrings, cflags ), + StrMatcher( rcstrings, cflags ), it->predicate, it->predicateStr ) ); } else @@ -627,13 +627,13 @@ attremptycheckend: if ( _strings.size() > 1 ) // switch to regex for multiple strings cflags.setModeRegex(); _attrMatchList.push_back( AttrMatchData( sat::SolvAttr::allAttr, - sat::AttrMatcher( rcstrings, cflags ) ) ); + StrMatcher( rcstrings, cflags ) ) ); } // Finally check here, whether all involved regex compile. for_( it, _attrMatchList.begin(), _attrMatchList.end() ) { - it->attrMatcher.compile(); // throws on error + it->strMatcher.compile(); // throws on error } //DBG << asString() << endl; } @@ -865,7 +865,7 @@ attremptycheckend: // Match::OTHER indicates need to compile // (merge global search strings into name). - AttrMatchData attrMatchData( attr, sat::AttrMatcher( name, Match::OTHER ) ); + AttrMatchData attrMatchData( attr, StrMatcher( name, Match::OTHER ) ); if ( isDependencyAttribute( attr ) ) attrMatchData.addPredicate( EditionRangePredicate( op, edition, arch ) ); @@ -882,7 +882,7 @@ attremptycheckend: return; // Matches STRING per default. (won't get compiled!) - AttrMatchData attrMatchData( attr, sat::AttrMatcher( cap.name().asString() ) ); + AttrMatchData attrMatchData( attr, StrMatcher( cap.name().asString() ) ); if ( isDependencyAttribute( attr ) ) attrMatchData.addPredicate( CapabilityMatchPredicate( cap_r ) ); @@ -1487,8 +1487,8 @@ attremptycheckend: { const AttrMatchData & matchData( *mi ); sat::LookupAttr q( matchData.attr, inSolvable ); - if ( matchData.attrMatcher ) // an empty searchstring matches always - q.setAttrMatcher( matchData.attrMatcher ); + if ( matchData.strMatcher ) // an empty searchstring matches always + q.setStrMatcher( matchData.strMatcher ); if ( ! q.empty() ) // there are matches. { @@ -1535,7 +1535,7 @@ attremptycheckend: _edition = query_r->_edition; // Status restriction: _status_flags = query_r->_status_flags; - // AttrMatcher + // StrMatcher _attrMatchList = query_r->_attrMatchList; } @@ -1561,8 +1561,8 @@ attremptycheckend: { const AttrMatchData & matchData( _attrMatchList.front() ); q.setAttr( matchData.attr ); - if ( matchData.attrMatcher ) // empty searchstring matches always - q.setAttrMatcher( matchData.attrMatcher ); + if ( matchData.strMatcher ) // empty searchstring matches always + q.setStrMatcher( matchData.strMatcher ); } else // more than 1 attr (but not all) { @@ -1635,8 +1635,8 @@ attremptycheckend: { const AttrMatchData & matchData( *mi ); sat::LookupAttr q( matchData.attr, inSolvable ); - if ( matchData.attrMatcher ) // an empty searchstring matches always - q.setAttrMatcher( matchData.attrMatcher ); + if ( matchData.strMatcher ) // an empty searchstring matches always + q.setStrMatcher( matchData.strMatcher ); if ( ! q.empty() ) // there are matches. { @@ -1669,7 +1669,7 @@ attremptycheckend: Edition _edition; /** Installed status filter flags. \see PoolQuery::StatusFilter */ int _status_flags; - /** AttrMatcher per attribtue. */ + /** StrMatcher per attribtue. */ AttrMatchList _attrMatchList; }; /////////////////////////////////////////////////////////////////// diff --git a/zypp/PoolQuery.h b/zypp/PoolQuery.h index e1bc285..aeb3b4b 100644 --- a/zypp/PoolQuery.h +++ b/zypp/PoolQuery.h @@ -22,7 +22,7 @@ #include "zypp/sat/SolvIterMixin.h" #include "zypp/sat/LookupAttr.h" -#include "zypp/sat/AttrMatcher.h" +#include "zypp/base/StrMatcher.h" #include "zypp/sat/Pool.h" /////////////////////////////////////////////////////////////////// diff --git a/zypp/base/Regex.h b/zypp/base/Regex.h index 7eb01b0..1eca7ff 100644 --- a/zypp/base/Regex.h +++ b/zypp/base/Regex.h @@ -30,7 +30,7 @@ namespace zypp /// \defgroup ZYPP_STR_REGEX Regular expression matching /// \brief Regular expressions using the glibc regex library. /// - /// \see also \ref sat::AttrMatcher string matcher also supporting globing, etc. + /// \see also \ref StrMatcher string matcher also supporting globing, etc. /// /// \code /// str::regex rxexpr( "^(A)?([0-9]*) im" ); diff --git a/zypp/base/StrMatcher.cc b/zypp/base/StrMatcher.cc new file mode 100644 index 0000000..2c5dfb3 --- /dev/null +++ b/zypp/base/StrMatcher.cc @@ -0,0 +1,324 @@ +/*---------------------------------------------------------------------\ +| ____ _ __ __ ___ | +| |__ / \ / / . \ . \ | +| / / \ V /| _/ _/ | +| / /__ | | | | | | | +| /_____||_| |_| |_| | +| | +\---------------------------------------------------------------------*/ +/** \file zypp/base/StrMatcher.cc + * +*/ +extern "C" +{ +#include +} + +#include +#include + +#include "zypp/base/LogTools.h" +#include "zypp/base/Gettext.h" +#include "zypp/base/String.h" + +#include "zypp/base/StrMatcher.h" + +using std::endl; + +/////////////////////////////////////////////////////////////////// +namespace zypp +{ + /////////////////////////////////////////////////////////////////// + // class Match + /////////////////////////////////////////////////////////////////// + + const int Match::_modemask = SEARCH_STRINGMASK; + const int Match::_flagmask = ~_modemask; + + // option flags + const Match Match::NOCASE (SEARCH_NOCASE); + + // sat::LookupAttr option flags + const Match Match::NO_STORAGE_SOLVABLE(SEARCH_NO_STORAGE_SOLVABLE); + const Match Match::SUB (SEARCH_SUB); + const Match Match::ARRAYSENTINEL (SEARCH_ARRAYSENTINEL); + const Match Match::DISABLED_REPOS (SEARCH_DISABLED_REPOS); + const Match Match::COMPLETE_FILELIST (SEARCH_COMPLETE_FILELIST); + const Match Match::SKIP_KIND (SEARCH_SKIP_KIND); + const Match Match::FILES (SEARCH_FILES); + const Match Match::CHECKSUMS (SEARCH_CHECKSUMS); + + Match::Mode Match::mode() const + { + switch ( modeval() ) + { + case 0: return NOTHING; break; + case SEARCH_STRING: return STRING; break; + case SEARCH_STRINGSTART: return STRINGSTART; break; + case SEARCH_STRINGEND: return STRINGEND; break; + case SEARCH_SUBSTRING: return SUBSTRING; break; + case SEARCH_GLOB: return GLOB; break; + case SEARCH_REGEX: return REGEX; break; + } + return OTHER; + } + + int Match::modeval( Mode mode_r ) + { + switch ( mode_r ) + { + case NOTHING: return 0; break; + case STRING: return SEARCH_STRING; break; + case STRINGSTART: return SEARCH_STRINGSTART; break; + case STRINGEND: return SEARCH_STRINGEND; break; + case SUBSTRING: return SEARCH_SUBSTRING; break; + case GLOB: return SEARCH_GLOB; break; + case REGEX: return SEARCH_REGEX; break; + case OTHER: return SEARCH_STRINGMASK; break; + } + return SEARCH_STRINGMASK; + } + + std::string Match::asString() const + { std::ostringstream str; str << *this; return str.str(); } + + std::ostream & operator<<( std::ostream & str, Match::Mode obj ) + { + switch ( obj ) + { +#define OUTS(V) case Match::V: return str << #V; break + OUTS( NOTHING ); + OUTS( STRING ); + OUTS( STRINGSTART ); + OUTS( STRINGEND ); + OUTS( SUBSTRING ); + OUTS( GLOB ); + OUTS( REGEX ); + OUTS( OTHER ); +#undef OUTS + } + return str << "Match::Mode::UNKNOWN"; + } + + std::ostream & operator<<( std::ostream & str, const Match & obj ) + { + if ( ! obj ) + return str << "NOTHING"; + + const char * sep = "|"; + Match::Mode mode( obj.mode() ); + switch ( mode ) + { + case Match::NOTHING: + sep = 0; // suppress 'NOTHING|' + break; + case Match::OTHER: + str << mode<<"("< _matcher; + + private: + friend Impl * rwcowClone( const Impl * rhs ); + /** clone for RWCOW_pointer */ + Impl * clone() const + { return new Impl( _search, _flags ); } + }; + + /** \relates StrMatcher::Impl Stream output */ + inline std::ostream & operator<<( std::ostream & str, const StrMatcher::Impl & obj ) + { + return str << "\"" << obj.searchstring() << "\"{" << obj.flags() << "}"; + } + + /////////////////////////////////////////////////////////////////// + // class StrMatcher + /////////////////////////////////////////////////////////////////// + + StrMatcher::StrMatcher() + : _pimpl( new Impl ) + {} + + StrMatcher::StrMatcher( const std::string & search_r ) + : _pimpl( new Impl( search_r, Match::STRING ) ) + {} + + StrMatcher::StrMatcher( const std::string & search_r, const Match & flags_r ) + : _pimpl( new Impl( search_r, flags_r ) ) + {} + + StrMatcher::StrMatcher( const std::string & search_r, const Match::Mode & flags_r ) + : _pimpl( new Impl( search_r, flags_r ) ) + {} + + StrMatcher::StrMatcher( const std::string & search_r, int flags_r ) + : _pimpl( new Impl( search_r, Match(flags_r) ) ) + {} + + void StrMatcher::compile() const + { return _pimpl->compile(); } + + bool StrMatcher::isCompiled() const + { return _pimpl->isCompiled(); } + + bool StrMatcher::doMatch( const char * string_r ) const + { return _pimpl->doMatch( string_r ); } + + const std::string & StrMatcher::searchstring() const + { return _pimpl->searchstring(); } + + void StrMatcher::setSearchstring( const std::string & string_r ) + { _pimpl->setSearchstring( string_r ); } + + void StrMatcher::setSearchstring( const std::string & string_r, const Match & flags_r ) + { + _pimpl->setSearchstring( string_r ); + _pimpl->setFlags( flags_r ); + } + + const Match & StrMatcher::flags() const + { return _pimpl->flags(); } + + void StrMatcher::setFlags( const Match & flags_r ) + { _pimpl->setFlags( flags_r ); } + + std::ostream & operator<<( std::ostream & str, const StrMatcher & obj ) + { return str << *obj._pimpl; } + + bool operator==( const StrMatcher & lhs, const StrMatcher & rhs ) + { + return ( lhs.flags() == rhs.flags() + && lhs.searchstring() == rhs.searchstring() ); + } + + bool operator<( const StrMatcher & lhs, const StrMatcher & rhs ) + { + if ( lhs.flags().get() != rhs.flags().get() ) + return ( lhs.flags().get() < rhs.flags().get() ); + + return ( lhs.searchstring() < rhs.searchstring() ); + } + +} // namespace zypp +/////////////////////////////////////////////////////////////////// diff --git a/zypp/base/StrMatcher.h b/zypp/base/StrMatcher.h new file mode 100644 index 0000000..5fdfb3a --- /dev/null +++ b/zypp/base/StrMatcher.h @@ -0,0 +1,409 @@ +/*---------------------------------------------------------------------\ +| ____ _ __ __ ___ | +| |__ / \ / / . \ . \ | +| / / \ V /| _/ _/ | +| / /__ | | | | | | | +| /_____||_| |_| |_| | +| | +\---------------------------------------------------------------------*/ +/** \file zypp/base/StrMatcher.h + * +*/ +#ifndef ZYPP_BASE_STRMATCHER_H +#define ZYPP_BASE_STRMATCHER_H + +#include +#include + +#include "zypp/base/PtrTypes.h" +#include "zypp/base/SafeBool.h" +#include "zypp/base/Exception.h" + +/////////////////////////////////////////////////////////////////// +namespace zypp +{ + /////////////////////////////////////////////////////////////////// + /// \class Match + /// \brief String matching option flags as used e.g. by \ref StrMatcher. + /// + /// \code + /// Match mode( Match::GLOB | Match::NOCASE ); + /// \endcode + /////////////////////////////////////////////////////////////////// + class Match : private base::SafeBool + { + private: + static const int _modemask; + static const int _flagmask; + + public: + /** Mode flags (mutual exclusive). */ + enum Mode + { + NOTHING, //!< Match nothing + STRING, //!< Excat matching + STRINGSTART, //!< Match at string start + STRINGEND, //!< Match at string end + SUBSTRING, //!< Match substring + GLOB, //!< Glob + REGEX, //!< Regular Expression + OTHER //!< Something else. + }; + + /** \name \ref Option flags + * Most flags are actually \ref sat::LookupAttr specific, as they tell + * how to retrieve the attribute values from solv-files. The plain + * \ref StrMatcher will ignore those flags and use the ones related + * to string matching only. + */ + //@{ + static const Match NOCASE; //!< If set, match case insensitive. + //@} + + /** \name \ref sat::LookupAttr option flags + * These flags are actually \ref sat::LookupAttr specific, as they tell + * how to retrieve the attribute values from solv-files. The plain + * \ref StrMatcher will ignore these flags and use the ones related + * to string matching only. + */ + //@{ + static const Match NO_STORAGE_SOLVABLE; //!< LookupAttr: internal + static const Match SUB; //!< LookupAttr: internal + static const Match ARRAYSENTINEL; //!< LookupAttr: internal + static const Match DISABLED_REPOS; //!< LookupAttr: internal + static const Match COMPLETE_FILELIST; //!< LookupAttr: internal + static const Match SKIP_KIND; //!< LookupAttr: skip any \c kind: prefix when looking at a \ref Solvable name. + static const Match FILES; //!< LookupAttr: match full path when matching in filelists, otherwise just the basenames. + static const Match CHECKSUMS; //!< LookupAttr: also look for matches in checksums + //@} + + public: + /** Default ctor \c 0 or \ref NOTHING. */ + Match() + : _val( 0 ) + {} + + /** Ctor from \ref Mode value. */ + Match( Mode val_r ) + : _val( modeval( val_r ) ) + {} + + /** Just in case one needs it. */ + explicit Match( int val_r ) + : _val( val_r ) + {} + +#ifndef SWIG // Swig treats it as syntax error + /** Evaluate in a boolean context ( != 0 ). */ + using base::SafeBool::operator bool_type; +#endif + + public: + /** Test whether \c all of the \a rhs bits are set (same mode if \a rhs has one). */ + bool test( const Match & rhs ) const + { return ( ( flagval() & rhs.flagval() ) == rhs.flagval() ) && ( !rhs.modeval() || rhs.modeval() == modeval() ); } + + /** Whether at least one of the \a rhs bits is set (or the same mode). */ + bool testAnyOf( const Match & rhs ) const + { return ( flagval() & rhs.flagval() ) || ( rhs.modeval() && rhs.modeval() == modeval() ); } + + /** Set all of the \a rhs bits (setting a new mode if \a rhs has one). */ + void set( const Match & rhs ) + { + if ( rhs.modeval() ) + _val = rhs._val | flagval(); // also set the rhs mode + else + _val |= rhs._val; // just set the flags + } + + /** Unset all of the \a rhs bits (unsets mode if the same as \a rhs). */ + void unset( const Match & rhs ) + { + if ( modeval() == rhs.modeval() ) + _val = flagval() & ~rhs.flagval(); // also unset mode + else + _val &= ~rhs.flagval(); // just unset falgs + } + + /** Depending on the value of \a onoff, set or unset flags. */ + void turn( const Match & rhs, bool onoff ) + { onoff ? set( rhs ) : unset( rhs ); } + + /** Add flags. */ + Match & operator|=( const Match & rhs ) + { set( rhs ); return *this; } + + /** Remove flags.*/ + Match & operator-=( const Match & rhs ) + { unset( rhs ); return *this; } + + public: + /** Return the \c mode part. */ + Mode mode() const; + + /** Return the \c flags part. */ + Match flags() const + { return Match( flagval() ); } + + public: + /** \name Low level integer representation. */ + //@{ + /** Return the integer representation. */ + int get() const { return _val; } + /** Return the modes integer representation. */ + int modeval() const { return _val & _modemask; } + /** Return the flags integer representation. */ + int flagval() const { return _val & _flagmask; } + //@} + + public: + /** \name Mode flag manip/query convenience. */ + //@{ + /** Whether this has mode \a rhs */ + bool isMode( Mode rhs ) const + { return modeval() == modeval( rhs ); } + /** Whether this has mode \ref STRING. */ + bool isModeString() const + { return isMode( STRING ); } + /** Whether this has mode \ref STRINGSTART. */ + bool isModeStringstart() const + { return isMode( STRINGSTART ); } + /** Whether this has mode \ref STRINGEND. */ + bool isModeStringend() const + { return isMode( STRINGEND ); } + /** Whether this has mode \ref SUBSTRING. */ + bool isModeSubstring() const + { return isMode( SUBSTRING ); } + /** Whether this has mode \ref GLOB. */ + bool isModeGlob() const + { return isMode( GLOB ); } + /** Whether this has mode \ref REGEX. */ + bool isModeRegex() const + { return isMode( REGEX ); } + + /** Set the mode part to \a rhs . */ + void setMode( Mode rhs ) + { _val = modeval( rhs ) | flagval(); } + /** Set the mode \ref STRING. */ + void setModeString() + { setMode( STRING ); } + /** Set the mode \ref STRINGSTART. */ + void setModeStringstart() + { setMode( STRINGSTART ); } + /** Set the mode \ref STRINGEND. */ + void setModeStringend() + { setMode( STRINGEND ); } + /** Set the mode \ref SUBSTRING. */ + void setModeSubstring() + { setMode( SUBSTRING ); } + /** Set the mode \ref GLOB. */ + void setModeGlob() + { setMode( GLOB ); } + /** Set the mode \ref REGEX. */ + void setModeRegex() + { setMode( REGEX ); } + //@} + + /** String representation. */ + std::string asString() const; + + private: + friend base::SafeBool::operator bool_type() const; + bool boolTest() const { return _val; } + + /** Numeric value for enum (short for Match(m).get()). */ + static int modeval( Mode mode_r ); + + private: + int _val; + }; + + /** \relates Match */ + inline bool operator==( const Match & lhs, const Match & rhs ) + { return lhs.get() == rhs.get(); } + /** \relates Match */ + inline bool operator!=( const Match & lhs, const Match & rhs ) + { return lhs.get() != rhs.get(); } + + /** \relates Match */ + inline Match operator|( const Match & lhs, const Match & rhs ) + { return Match(lhs) |= rhs; } + /** \relates Match \overload to disambiguate 'int|int'. */ + inline Match operator|( Match::Mode lhs, Match::Mode rhs ) + { return Match(lhs) |= rhs; } + + /** \relates Match */ + inline Match operator-( const Match & lhs, const Match & rhs ) + { return Match(lhs) -= rhs; } + /** \relates Match \overload to disambiguate 'int-int'. */ + inline Match operator-( Match::Mode lhs, Match::Mode rhs ) + { return Match(lhs) -= rhs; } + + /** \relates Match::Mode Stream output */ + std::ostream & operator<<( std::ostream & str, Match::Mode obj ); + + /** \relates Match Stream output */ + std::ostream & operator<<( std::ostream & str, const Match & obj ); + + /////////////////////////////////////////////////////////////////// + /// \class MatchException + /// \brief Exceptions thrown from attribute matching. + /////////////////////////////////////////////////////////////////// + struct MatchException : public Exception + { + /** Supplied message. */ + explicit MatchException( const std::string & msg_r ) : Exception( msg_r ) {} + }; + + /////////////////////////////////////////////////////////////////// + /// \class MatchUnknownModeException + /// \brief Unknown match mode. + /////////////////////////////////////////////////////////////////// + struct MatchUnknownModeException : public MatchException + { + /** Supplied message. */ + explicit MatchUnknownModeException( const std::string & msg_r ) : MatchException( msg_r ) {} + + /** Build message including the \a mode and optional the pattern string. */ + MatchUnknownModeException( const Match & mode_r, const std::string & msg_r = std::string() ); + }; + + /////////////////////////////////////////////////////////////////// + /// \class MatchInvalidRegexException + /// \brief Invalid regular expression (failed ::regcomp). + /////////////////////////////////////////////////////////////////// + struct MatchInvalidRegexException : public MatchException + { + /** Supplied message. */ + explicit MatchInvalidRegexException( const std::string & msg_r ) : MatchException( msg_r ) {} + + /** Build message including the \a regex and \c ::regcomp returncode (use \c 0 if unknown). */ + MatchInvalidRegexException( const std::string & regex_r, int regcomp_r ); + }; + + /////////////////////////////////////////////////////////////////// + /// \class StrMatcher + /// \brief String matching (STRING|SUBSTRING|GLOB|REGEX). + /// + /// Used by e.g. \ref PoolQuery and \ref LookupAttr for queries, + /// but it can also be used for matching arbitrary strings. + /// + /// \code + /// StrMatcher matches( "foo", Match::SUBSTRING ); + /// for_( it, stringlist.begin(), stringlist().end() ) + /// { + /// if ( matches( *it ) ) + /// cout << *it << " has substring 'foo'" << endl; + /// } + /// \endcode + /// + /// \Note Those flags are always set: REG_EXTENDED | REG_NOSUB | REG_NEWLINE + /////////////////////////////////////////////////////////////////// + class StrMatcher : private base::SafeBool + { + friend std::ostream & operator<<( std::ostream & str, const StrMatcher & obj ); + + public: + typedef MatchException Exception; + + public: + /** Implementation */ + class Impl; + + public: + /** Default ctor matches nothing. */ + StrMatcher(); + + /** Ctor from string matches in \ref Match::STRING mode per default. */ + StrMatcher( const std::string & search_r ); + + /** Ctor taking string and \ref Match flags. */ + StrMatcher( const std::string & search_r, const Match & flags_r ); + + /** Ctor taking string and \ref Match::Mode. + * Needed because we want them to be treated as \ref Match, + * and not as \ref int as the compiler woud do. + */ + StrMatcher( const std::string & search_r, const Match::Mode & flags_r ); + + /** Low level interface wraps \a flags into \ref Match. */ + StrMatcher( const std::string & search_r, int flags_r ); + + #ifndef SWIG // Swig treats it as syntax error + /** Evaluate in a boolean context ( ! searchstring().empty() ). */ + using base::SafeBool::operator bool_type; + #endif + + public: + /** Return whether string matches. + * You can use it with any class that impements \c c_str. + * (\c std::string, \ref Pathname, \ref IdString, ...). + * \Note \c NULL never matches. + */ + template + bool operator()( const _Tp & string_r ) const + { return doMatch( string_r.c_str() ); } + /** \overload */ + bool operator()( const char * string_r ) const + { return doMatch( string_r ); } + + public: + /** The current searchstring. */ + const std::string & searchstring() const; + + /** Set a new searchstring. */ + void setSearchstring( const std::string & string_r ); + + /** Set a new searchstring and flags. */ + void setSearchstring( const std::string & string_r, const Match & flags_r ); + + /** The current search flags. */ + const Match & flags() const; + + /** Set new search flags. */ + void setFlags( const Match & flags_r ); + + public: + /** Compile the pattern e.g. in case of \c REGEX. + * \throws MatchUnknownModeException If the \ref Match flag more than + * one mode bit set. + * \throws MatchInvalidRegexException If \ref Match::REGEX is set + * and \ref searchstring is not a valid regular expression. + */ + void compile() const; + + /** Whether the \ref StrMatcher is already compiled. */ + bool isCompiled() const; + + /** Return whether string matches. + * Compiles the \ref StrMatcher if this was not yet done. + * \throws MatchException Any of the exceptions thrown by \ref StrMatcher::compile. + */ + bool doMatch( const char * string_r ) const; + + private: + friend base::SafeBool::operator bool_type() const; + bool boolTest() const + { return !searchstring().empty(); } + + private: + /** Pointer to implementation */ + RWCOW_pointer _pimpl; + }; + + /** \relates StrMatcher Stream output */ + std::ostream & operator<<( std::ostream & str, const StrMatcher & obj ); + + /** \relates StrMatcher */ + bool operator==( const StrMatcher & lhs, const StrMatcher & rhs ); + + /** \relates StrMatcher */ + inline bool operator!=( const StrMatcher & lhs, const StrMatcher & rhs ) + { return !( lhs == rhs ); } + + /** \relates StrMatcher Arbitrary order for std::container. */ + bool operator<( const StrMatcher & lhs, const StrMatcher & rhs ); + +} // namespace zypp +/////////////////////////////////////////////////////////////////// +#endif // ZYPP_BASE_STRMATCHER_H diff --git a/zypp/sat/AttrMatcher.cc b/zypp/sat/AttrMatcher.cc deleted file mode 100644 index 6680ee7..0000000 --- a/zypp/sat/AttrMatcher.cc +++ /dev/null @@ -1,342 +0,0 @@ -/*---------------------------------------------------------------------\ -| ____ _ __ __ ___ | -| |__ / \ / / . \ . \ | -| / / \ V /| _/ _/ | -| / /__ | | | | | | | -| /_____||_| |_| |_| | -| | -\---------------------------------------------------------------------*/ -/** \file zypp/sat/AttrMatcher.cc - * -*/ -extern "C" -{ -#include -} - -#include -#include -#include - -#include "zypp/base/LogTools.h" -#include "zypp/base/Gettext.h" -#include "zypp/base/String.h" - -#include "zypp/sat/AttrMatcher.h" - -using std::endl; - -/////////////////////////////////////////////////////////////////// -namespace zypp -{ ///////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////// - // - // CLASS NAME : Match - // - /////////////////////////////////////////////////////////////////// - - const int Match::_modemask = SEARCH_STRINGMASK; - const int Match::_flagmask = ~_modemask; - - // option flags - const Match Match::NOCASE (SEARCH_NOCASE); - const Match Match::NO_STORAGE_SOLVABLE(SEARCH_NO_STORAGE_SOLVABLE); - const Match Match::SUB (SEARCH_SUB); - const Match Match::ARRAYSENTINEL (SEARCH_ARRAYSENTINEL); - const Match Match::SKIP_KIND (SEARCH_SKIP_KIND); - const Match Match::FILES (SEARCH_FILES); - - Match::Mode Match::mode() const - { - switch ( modeval() ) - { - case 0: return NOTHING; break; - case SEARCH_STRING: return STRING; break; - case SEARCH_STRINGSTART: return STRINGSTART; break; - case SEARCH_STRINGEND: return STRINGEND; break; - case SEARCH_SUBSTRING: return SUBSTRING; break; - case SEARCH_GLOB: return GLOB; break; - case SEARCH_REGEX: return REGEX; break; - } - return OTHER; - } - - int Match::modeval( Mode mode_r ) - { - switch ( mode_r ) - { - case NOTHING: return 0; break; - case STRING: return SEARCH_STRING; break; - case STRINGSTART: return SEARCH_STRINGSTART; break; - case STRINGEND: return SEARCH_STRINGEND; break; - case SUBSTRING: return SEARCH_SUBSTRING; break; - case GLOB: return SEARCH_GLOB; break; - case REGEX: return SEARCH_REGEX; break; - case OTHER: return SEARCH_STRINGMASK; break; - } - return SEARCH_STRINGMASK; - } - - std::string Match::asString() const - { std::ostringstream str; str << *this; return str.str(); } - - std::ostream & operator<<( std::ostream & str, Match::Mode obj ) - { - switch ( obj ) - { -#define OUTS(V) case Match::V: return str << #V; break - OUTS( NOTHING ); - OUTS( STRING ); - OUTS( STRINGSTART ); - OUTS( STRINGEND ); - OUTS( SUBSTRING ); - OUTS( GLOB ); - OUTS( REGEX ); - OUTS( OTHER ); -#undef OUTS - } - return str << "Match::Mode::UNKNOWN"; - } - - std::ostream & operator<<( std::ostream & str, const Match & obj ) - { - if ( ! obj ) - return str << "NOTHING"; - - const char * sep = "|"; - Match::Mode mode( obj.mode() ); - switch ( mode ) - { - case Match::NOTHING: - sep = 0; // suppress 'NOTHING|' - break; - case Match::OTHER: - str << mode<<"("< _matcher; - - private: - friend Impl * rwcowClone( const Impl * rhs ); - /** clone for RWCOW_pointer */ - Impl * clone() const - { return new Impl( _search, _flags ); } - }; - /////////////////////////////////////////////////////////////////// - - /** \relates AttrMatcher::Impl Stream output */ - inline std::ostream & operator<<( std::ostream & str, const AttrMatcher::Impl & obj ) - { - return str << "\"" << obj.searchstring() << "\"{" << obj.flags() << "}"; - } - - /////////////////////////////////////////////////////////////////// - // - // CLASS NAME : AttrMatcher - // - /////////////////////////////////////////////////////////////////// - - AttrMatcher::AttrMatcher() - : _pimpl( new Impl ) - {} - - AttrMatcher::AttrMatcher( const std::string & search_r ) - : _pimpl( new Impl( search_r, Match::STRING ) ) - {} - - AttrMatcher::AttrMatcher( const std::string & search_r, const Match & flags_r ) - : _pimpl( new Impl( search_r, flags_r ) ) - {} - - AttrMatcher::AttrMatcher( const std::string & search_r, const Match::Mode & flags_r ) - : _pimpl( new Impl( search_r, flags_r ) ) - {} - - AttrMatcher::AttrMatcher( const std::string & search_r, int flags_r ) - : _pimpl( new Impl( search_r, Match(flags_r) ) ) - {} - - void AttrMatcher::compile() const - { return _pimpl->compile(); } - - bool AttrMatcher::isCompiled() const - { return _pimpl->isCompiled(); } - - bool AttrMatcher::doMatch( const char * string_r ) const - { return _pimpl->doMatch( string_r ); } - - const std::string & AttrMatcher::searchstring() const - { return _pimpl->searchstring(); } - - void AttrMatcher::setSearchstring( const std::string & string_r ) - { _pimpl->setSearchstring( string_r ); } - - void AttrMatcher::setSearchstring( const std::string & string_r, const Match & flags_r ) - { - _pimpl->setSearchstring( string_r ); - _pimpl->setFlags( flags_r ); - } - - const Match & AttrMatcher::flags() const - { return _pimpl->flags(); } - - void AttrMatcher::setFlags( const Match & flags_r ) - { _pimpl->setFlags( flags_r ); } - - /****************************************************************** - ** - ** FUNCTION NAME : operator<< - ** FUNCTION TYPE : std::ostream & - */ - std::ostream & operator<<( std::ostream & str, const AttrMatcher & obj ) - { - return str << *obj._pimpl; - } - - bool operator==( const AttrMatcher & lhs, const AttrMatcher & rhs ) - { - return ( lhs.flags() == rhs.flags() - && lhs.searchstring() == rhs.searchstring() ); - } - - bool operator<( const AttrMatcher & lhs, const AttrMatcher & rhs ) - { - if ( lhs.flags().get() != rhs.flags().get() ) - return ( lhs.flags().get() < rhs.flags().get() ); - - return ( lhs.searchstring() < rhs.searchstring() ); - } - - ///////////////////////////////////////////////////////////////// - } // namespace sat - /////////////////////////////////////////////////////////////////// - ///////////////////////////////////////////////////////////////// -} // namespace zypp -/////////////////////////////////////////////////////////////////// diff --git a/zypp/sat/AttrMatcher.h b/zypp/sat/AttrMatcher.h index e557b07..7e04922 100644 --- a/zypp/sat/AttrMatcher.h +++ b/zypp/sat/AttrMatcher.h @@ -11,414 +11,20 @@ */ #ifndef ZYPP_SAT_ATTRMATCHER_H #define ZYPP_SAT_ATTRMATCHER_H +#warning sat::AttrMatcher was renamed to StrMatcher. Deprecated include of zypp/sat/AttrMatcher.h use zypp/base/StrMatcher.h -extern "C" -{ -struct _Datamatcher; -} - -#include -#include - -#include "zypp/base/PtrTypes.h" -#include "zypp/base/SafeBool.h" -#include "zypp/base/Exception.h" +#include "zypp/base/StrMatcher.h" /////////////////////////////////////////////////////////////////// namespace zypp -{ ///////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////// - // - // CLASS NAME : Match - // - /** String matching option flags as used e.g. by \ref sat::AttrMatcher. - * - * \code - * Match mode( Match::GLOB | Match::NOCASE ); - * \endcode - */ - class Match : private base::SafeBool - { - private: - static const int _modemask; - static const int _flagmask; - - public: - /** Mode flags (mutual exclusive). */ - enum Mode - { - NOTHING, //!< Match nothing - STRING, //!< Excat matching - STRINGSTART, //!< Match at string start - STRINGEND, //!< Match at string end - SUBSTRING, //!< Match substring - GLOB, //!< Glob - REGEX, //!< Regular Expression - OTHER //!< Something else. - }; - - /** \name Option flags - * Some flags are actually \ref sat::LookupAttr specific, as they tell - * how to retrieve the attribute values. The plain \ref sat::AttrMatcher - * will ignore those flags and use the ones related to string matching only - * (like \ref NOCASE). - */ - //@{ - /** If set, match case insensitive. */ - static const Match NOCASE; - /** internal */ - static const Match NO_STORAGE_SOLVABLE; - /** internal */ - static const Match SUB; - /** internal */ - static const Match ARRAYSENTINEL; - /** If set, skip any \c kind: prefix when looking at a \ref Solvable name. */ - static const Match SKIP_KIND; - /** If set, match full path when matching in filelists, otherwise just the basenames. */ - static const Match FILES; - //@} - - public: - /** Default ctor \c 0 or \ref NOTHING. */ - Match() - : _val( 0 ) - {} - - /** Ctor from \ref Mode value. */ - Match( Mode val_r ) - : _val( modeval( val_r ) ) - {} - - /** Just in case one needs it. */ - explicit Match( int val_r ) - : _val( val_r ) - {} - -#ifndef SWIG // Swig treats it as syntax error - /** Evaluate in a boolean context ( != 0 ). */ - using base::SafeBool::operator bool_type; -#endif - - public: - /** Test whether \c all of the \a rhs bits are set (same mode if \a rhs has one). */ - bool test( const Match & rhs ) const - { return ( ( flagval() & rhs.flagval() ) == rhs.flagval() ) - && ( !rhs.modeval() || rhs.modeval() == modeval() ); } - - /** Whether at least one of the \a rhs bits is set (or the same mode). */ - bool testAnyOf( const Match & rhs ) const - { return ( flagval() & rhs.flagval() ) - || ( rhs.modeval() && rhs.modeval() == modeval() ); } - - /** Set all of the \a rhs bits (setting a new mode if \a rhs has one). */ - void set( const Match & rhs ) - { - if ( rhs.modeval() ) - _val = rhs._val | flagval(); // also set the rhs mode - else - _val |= rhs._val; // just set the flags - } - - /** Unset all of the \a rhs bits (unsets mode if the same as \a rhs). */ - void unset( const Match & rhs ) - { - if ( modeval() == rhs.modeval() ) - _val = flagval() & ~rhs.flagval(); // also unset mode - else - _val &= ~rhs.flagval(); // just unset falgs - } - - /** Depending on the value of \a onoff, set or unset flags. */ - void turn( const Match & rhs, bool onoff ) - { onoff ? set( rhs ) : unset( rhs ); } - - /** Add flags. */ - Match & operator|=( const Match & rhs ) - { set( rhs ); return *this; } - - /** Remove flags.*/ - Match & operator-=( const Match & rhs ) - { unset( rhs ); return *this; } - - public: - /** Return the \c mode part. */ - Mode mode() const; - - /** Return the \c flags part. */ - Match flags() const - { return Match( flagval() ); } - - public: - /** \name Low level integer representation. */ - //@{ - /** Return the integer representation. */ - int get() const { return _val; } - /** Return the modes integer representation. */ - int modeval() const { return _val & _modemask; } - /** Return the flags integer representation. */ - int flagval() const { return _val & _flagmask; } - //@} - - public: - /** \name Mode flag manip/query convenience. */ - //@{ - /** Whether this has mode \a rhs */ - bool isMode( Mode rhs ) const - { return modeval() == modeval( rhs ); } - /** Whether this has mode \ref STRING. */ - bool isModeString() const - { return isMode( STRING ); } - /** Whether this has mode \ref STRINGSTART. */ - bool isModeStringstart() const - { return isMode( STRINGSTART ); } - /** Whether this has mode \ref STRINGEND. */ - bool isModeStringend() const - { return isMode( STRINGEND ); } - /** Whether this has mode \ref SUBSTRING. */ - bool isModeSubstring() const - { return isMode( SUBSTRING ); } - /** Whether this has mode \ref GLOB. */ - bool isModeGlob() const - { return isMode( GLOB ); } - /** Whether this has mode \ref REGEX. */ - bool isModeRegex() const - { return isMode( REGEX ); } - - /** Set the mode part to \a rhs . */ - void setMode( Mode rhs ) - { _val = modeval( rhs ) | flagval(); } - /** Set the mode \ref STRING. */ - void setModeString() - { setMode( STRING ); } - /** Set the mode \ref STRINGSTART. */ - void setModeStringstart() - { setMode( STRINGSTART ); } - /** Set the mode \ref STRINGEND. */ - void setModeStringend() - { setMode( STRINGEND ); } - /** Set the mode \ref SUBSTRING. */ - void setModeSubstring() - { setMode( SUBSTRING ); } - /** Set the mode \ref GLOB. */ - void setModeGlob() - { setMode( GLOB ); } - /** Set the mode \ref REGEX. */ - void setModeRegex() - { setMode( REGEX ); } - //@} - - /** String representation. */ - std::string asString() const; - - private: - friend base::SafeBool::operator bool_type() const; - bool boolTest() const { return _val; } - - /** Numeric value for enum (short for Match(m).get()). */ - static int modeval( Mode mode_r ); - - private: - int _val; - }; - - /** \relates Match */ - inline bool operator==( const Match & lhs, const Match & rhs ) - { return lhs.get() == rhs.get(); } - /** \relates Match */ - inline bool operator!=( const Match & lhs, const Match & rhs ) - { return lhs.get() != rhs.get(); } - - /** \relates Match */ - inline Match operator|( const Match & lhs, const Match & rhs ) - { return Match(lhs) |= rhs; } - /** \relates Match \overload to disambiguate 'int|int'. */ - inline Match operator|( Match::Mode lhs, Match::Mode rhs ) - { return Match(lhs) |= rhs; } - - /** \relates Match */ - inline Match operator-( const Match & lhs, const Match & rhs ) - { return Match(lhs) -= rhs; } - /** \relates Match \overload to disambiguate 'int-int'. */ - inline Match operator-( Match::Mode lhs, Match::Mode rhs ) - { return Match(lhs) -= rhs; } - - /** \relates Match::Mode Stream output */ - std::ostream & operator<<( std::ostream & str, Match::Mode obj ); - - /** \relates Match Stream output */ - std::ostream & operator<<( std::ostream & str, const Match & obj ); - - - /////////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////// - // - // CLASS NAME : MatchException - // - /** Exceptions thrown from attribute matching. */ - struct MatchException : public Exception - { - /** Supplied message. */ - explicit MatchException( const std::string & msg_r ) : Exception( msg_r ) {} - }; - - /** Unknown match mode. */ - struct MatchUnknownModeException : public MatchException - { - /** Supplied message. */ - explicit MatchUnknownModeException( const std::string & msg_r ) : MatchException( msg_r ) {} - - /** Build message including the \a mode and optional the pattern string. */ - MatchUnknownModeException( const Match & mode_r, const std::string & msg_r = std::string() ); - }; - - /** Invalid regular expression (failed ::regcomp). */ - struct MatchInvalidRegexException : public MatchException - { - /** Supplied message. */ - explicit MatchInvalidRegexException( const std::string & msg_r ) : MatchException( msg_r ) {} - - /** Build message including the \a regex and \c ::regcomp returncode (use \c 0 if unknown). */ - MatchInvalidRegexException( const std::string & regex_r, int regcomp_r ); - }; - - /////////////////////////////////////////////////////////////////// - +{ /////////////////////////////////////////////////////////////////// namespace sat - { ///////////////////////////////////////////////////////////////// - - /////////////////////////////////////////////////////////////////// - // - // CLASS NAME : AttrMatcher - // - /** String matching (STRING|SUBSTRING|GLOB|REGEX). - * - * Used by e.g. \ref PoolQuery and \ref LookupAttr for queries, - * but it can also be used for matching arbitrary strings. - * - * \code - * AttrMatcher matches( "foo" ); - * for_( it, stringlist.begin(), stringlist().end() ) - * { - * if ( matches( *it ) ) - * cout << *it << " has substring 'foo'" << endl; - * } - * \endcode - * - * \Note Those flags are always set: REG_EXTENDED | REG_NOSUB | REG_NEWLINE - */ - class AttrMatcher : private base::SafeBool - { - friend std::ostream & operator<<( std::ostream & str, const AttrMatcher & obj ); - - public: - typedef MatchException Exception; - - public: - /** Implementation */ - class Impl; - - public: - /** Default ctor matches nothing. */ - AttrMatcher(); - - /** Ctor from string matches in \ref Match::STRING mode per default. */ - AttrMatcher( const std::string & search_r ); - - /** Ctor taking string and \ref Match flags. */ - AttrMatcher( const std::string & search_r, const Match & flags_r ); - - /** Ctor taking string and \ref Match::Mode. - * Needed because we want them to be treated as \ref Match, - * and not as \ref int as the compiler woud do. - */ - AttrMatcher( const std::string & search_r, const Match::Mode & flags_r ); - - /** Low level interface wraps \a flags into \ref Match. */ - AttrMatcher( const std::string & search_r, int flags_r ); - -#ifndef SWIG // Swig treats it as syntax error - /** Evaluate in a boolean context ( ! searchstring().empty() ). */ - using base::SafeBool::operator bool_type; -#endif - - public: - /** Return whether string matches. - * You can use it with any class that impements \c c_str. - * (\c std::string, \ref Pathname, \ref IdString, ...). - * \Note \c NULL never matches. - */ - template - bool operator()( const _Tp & string_r ) const - { return doMatch( string_r.c_str() ); } - /** \overload */ - bool operator()( const char * string_r ) const - { return doMatch( string_r ); } - - public: - /** The current searchstring. */ - const std::string & searchstring() const; - - /** Set a new searchstring. */ - void setSearchstring( const std::string & string_r ); - - /** Set a new searchstring and flags. */ - void setSearchstring( const std::string & string_r, const Match & flags_r ); - - /** The current search flags. */ - const Match & flags() const; - - /** Set new search flags. */ - void setFlags( const Match & flags_r ); - - public: - /** Compile the pattern e.g. in case of \c REGEX. - * \throws MatchUnknownModeException If the \ref Match flag more than - * one mode bit set. - * \throws MatchInvalidRegexException If \ref Match::REGEX is set - * and \ref searchstring is not a valid regular expression. - */ - void compile() const; - - /** Whether the \ref AttrMatcher is already compiled. */ - bool isCompiled() const; - - /** Return whether string matches. - * Compiles the \ref AttrMatcher if this was not yet done. - * \throws MatchException Any of the exceptions thrown by \ref AttrMatcher::compile. - */ - bool doMatch( const char * string_r ) const; - - private: - friend base::SafeBool::operator bool_type() const; - bool boolTest() const - { return !searchstring().empty(); } - - private: - /** Pointer to implementation */ - RWCOW_pointer _pimpl; - }; - /////////////////////////////////////////////////////////////////// - - /** \relates AttrMatcher Stream output */ - std::ostream & operator<<( std::ostream & str, const AttrMatcher & obj ); - - /** \relates AttrMatcher */ - bool operator==( const AttrMatcher & lhs, const AttrMatcher & rhs ); - - /** \relates AttrMatcher */ - inline bool operator!=( const AttrMatcher & lhs, const AttrMatcher & rhs ) - { return !( lhs == rhs ); } - - /** \relates AttrMatcher Arbitrary order for std::container. */ - bool operator<( const AttrMatcher & lhs, const AttrMatcher & rhs ); + { + typedef StrMatcher AttrMatcher; - ///////////////////////////////////////////////////////////////// } // namespace sat /////////////////////////////////////////////////////////////////// - ///////////////////////////////////////////////////////////////// } // namespace zypp /////////////////////////////////////////////////////////////////// #endif // ZYPP_SAT_ATTRMATCHER_H diff --git a/zypp/sat/LookupAttr.cc b/zypp/sat/LookupAttr.cc index 6443847..741119a 100644 --- a/zypp/sat/LookupAttr.cc +++ b/zypp/sat/LookupAttr.cc @@ -19,7 +19,7 @@ #include "zypp/sat/Pool.h" #include "zypp/sat/LookupAttr.h" -#include "zypp/sat/AttrMatcher.h" +#include "zypp/base/StrMatcher.h" #include "zypp/CheckSum.h" @@ -80,13 +80,13 @@ namespace zypp _parent = p; } - const AttrMatcher & attrMatcher() const - { return _attrMatcher; } + const StrMatcher & strMatcher() const + { return _strMatcher; } - void setAttrMatcher( const AttrMatcher & matcher_r ) + void setStrMatcher( const StrMatcher & matcher_r ) { matcher_r.compile(); - _attrMatcher = matcher_r; + _strMatcher = matcher_r; } public: @@ -135,7 +135,7 @@ namespace zypp else if ( _repo ) whichRepo = _repo.id(); - detail::DIWrap dip( whichRepo, _solv.id(), _attr.id(), _attrMatcher.searchstring(), _attrMatcher.flags().get() ); + detail::DIWrap dip( whichRepo, _solv.id(), _attr.id(), _strMatcher.searchstring(), _strMatcher.flags().get() ); if ( _parent != SolvAttr::noAttr ) ::dataiterator_prepend_keyname( dip.get(), _parent.id() ); @@ -150,7 +150,7 @@ namespace zypp SolvAttr _parent; Repository _repo; Solvable _solv; - AttrMatcher _attrMatcher; + StrMatcher _strMatcher; private: friend Impl * rwcowClone( const Impl * rhs ); @@ -199,11 +199,11 @@ namespace zypp void LookupAttr::setAttr( SolvAttr attr_r ) { _pimpl->setAttr( attr_r ); } - const AttrMatcher & LookupAttr::attrMatcher() const - { return _pimpl->attrMatcher(); } + const StrMatcher & LookupAttr::strMatcher() const + { return _pimpl->strMatcher(); } - void LookupAttr::setAttrMatcher( const AttrMatcher & matcher_r ) - { _pimpl->setAttrMatcher( matcher_r ); } + void LookupAttr::setStrMatcher( const StrMatcher & matcher_r ) + { _pimpl->setStrMatcher( matcher_r ); } /////////////////////////////////////////////////////////////////// diff --git a/zypp/sat/LookupAttr.h b/zypp/sat/LookupAttr.h index e5aeeba..d7e45db 100644 --- a/zypp/sat/LookupAttr.h +++ b/zypp/sat/LookupAttr.h @@ -31,13 +31,12 @@ namespace zypp class CheckSum; class Match; class MatchException; + class StrMatcher; /////////////////////////////////////////////////////////////////// namespace sat { ///////////////////////////////////////////////////////////////// - class AttrMatcher; - /////////////////////////////////////////////////////////////////// // // CLASS NAME : LookupAttr @@ -179,23 +178,23 @@ namespace zypp /** \name Restrict attributes to match a pattern. */ //@{ /** The pattern to match. - * You can also evaluate \ref AttrMatcher in a boolean context, - * in order to test whether an \ref AttrMatcher is set: + * You can also evaluate \ref StrMatcher in a boolean context, + * in order to test whether an \ref StrMatcher is set: * \code * LookupAttr q; - * if ( q.attrMatcher() ) - * ...; // an AttrMatcher is set + * if ( q.strMatcher() ) + * ...; // an StrMatcher is set * \endcode */ - const AttrMatcher & attrMatcher() const; + const StrMatcher & strMatcher() const; /** Set the pattern to match. - * \throws MatchException Any of the exceptions thrown by \ref AttrMatcher::compile. + * \throws MatchException Any of the exceptions thrown by \ref StrMatcher::compile. */ - void setAttrMatcher( const AttrMatcher & matcher_r ); + void setStrMatcher( const StrMatcher & matcher_r ); /** Reset the pattern to match. */ - void resetAttrMatcher(); + void resetStrMatcher(); //@} public: -- 2.7.4