ref: refs/heads/ma-misc
commit 3beabd0d425a6266321b3181a85e4e7de1899974
Author: Michael Andres
Date: Wed Sep 2 15:50:13 2009 +0200
Fix PoolQuery comparison (bnc #528755)
---
tests/zypp/PoolQuery_test.cc | 93 +++++++++++++++++++++-------
zypp/PoolQuery.cc | 139 +++++++++++++++++++++++++++++++-----------
zypp/PoolQuery.h | 4 +-
3 files changed, 176 insertions(+), 60 deletions(-)
diff --git a/tests/zypp/PoolQuery_test.cc b/tests/zypp/PoolQuery_test.cc
index ed92e65..d2a44fe 100644
--- a/tests/zypp/PoolQuery_test.cc
+++ b/tests/zypp/PoolQuery_test.cc
@@ -20,6 +20,9 @@ BOOST_AUTO_TEST_CASE(pool_query_init)
}
/////////////////////////////////////////////////////////////////////////////
+static std::ofstream devNull;
+#define COUT devNull
+
struct PrintAndCount
{
PrintAndCount() : _count(0) {}
@@ -27,7 +30,7 @@ struct PrintAndCount
bool operator()( const sat::Solvable & solvable )
{
zypp::PoolItem pi( zypp::ResPool::instance().find( solvable ) );
- cout << pi.resolvable() << endl;
+ COUT << pi.resolvable() << endl;
++_count;
return true;
}
@@ -645,27 +648,73 @@ BOOST_AUTO_TEST_CASE(pool_query_serialize)
BOOST_AUTO_TEST_CASE(pool_query_equal)
{
cout << "****equal****" << endl;
- PoolQuery q;
- q.addString("zypp");
- q.addAttribute(sat::SolvAttr::name);
- q.setMatchGlob();
- PoolQuery q2;
- q2.addString("zypp");
- q2.addAttribute(sat::SolvAttr::name);
- q2.setMatchGlob();
- PoolQuery q3;
- q3.addString("zypp");
- q3.addAttribute(sat::SolvAttr::name);
- q3.setMatchGlob();
- q3.setRequireAll(true);
- PoolQuery q4;
- q4.addAttribute(sat::SolvAttr::name,"zypp");
- q4.setMatchGlob();
-
- BOOST_CHECK(q==q2);
- BOOST_CHECK(q!=q3);
- BOOST_CHECK(q==q4);
- BOOST_CHECK(q4!=q3);
+ std::vector<PoolQuery> v;
+ {
+ PoolQuery q;
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addAttribute( sat::SolvAttr::name, "zypper" );
+ q.setMatchExact();
+ q.setCaseSensitive(true);
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addAttribute( sat::SolvAttr::name, "libzypp" ); // different
+ q.setMatchExact();
+ q.setCaseSensitive(true);
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addAttribute( sat::SolvAttr::vendor, "zypper" ); // different
+ q.setMatchExact();
+ q.setCaseSensitive(true);
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addAttribute( sat::SolvAttr::name, "zypper" );
+ q.setMatchExact();
+ q.setCaseSensitive(false); // different
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addAttribute( sat::SolvAttr::name, "zypper" );
+ q.setMatchSubstring(); // different
+ q.setCaseSensitive(true);
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addDependency( sat::SolvAttr::provides, "zypper" );
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addDependency( sat::SolvAttr::provides, "zypper", Rel::GT, Edition("1.0") );
+ v.push_back( q );
+ }
+ {
+ PoolQuery q;
+ q.addDependency( sat::SolvAttr::provides, "zypper", Rel::GT, Edition("2.0") );
+ v.push_back( q );
+ }
+
+ for_( li, 0U, v.size() )
+ {
+ for_( ri, 0U, v.size() )
+ {
+ COUT << li << " <> " << ri << endl;
+ bool equal( v[li] == v[ri] );
+ bool nequal( v[li] != v[ri] );
+ BOOST_CHECK_EQUAL( equal, li==ri );
+ BOOST_CHECK_EQUAL( equal, !nequal );
+ }
+ }
}
/////////////////////////////////////////////////////////////////////////////
diff --git a/zypp/PoolQuery.cc b/zypp/PoolQuery.cc
index 79f5ee6..5f7f51c 100644
--- a/zypp/PoolQuery.cc
+++ b/zypp/PoolQuery.cc
@@ -54,6 +54,8 @@ namespace zypp
* As the \ref predicate takes an iterator pointing to the current
* match, it's also suitable for sub-structure (flexarray) inspection
* (\see \ref sat::LookupAttr::iterator::solvAttrSubEntry).
+ *
+ * \note: \see \ref addPredicate for further constraints.
*/
struct AttrMatchData
{
@@ -67,20 +69,63 @@ namespace zypp
, attrMatcher( attrMatcher_r )
{}
- AttrMatchData( sat::SolvAttr attr_r, const sat::AttrMatcher & attrMatcher_r, const Predicate & predicate_r )
+ AttrMatchData( sat::SolvAttr attr_r, const sat::AttrMatcher & attrMatcher_r,
+ const Predicate & predicate_r, const std::string & predicateStr_r )
: attr( attr_r )
, attrMatcher( attrMatcher_r )
, predicate( predicate_r )
+ , predicateStr( predicateStr_r )
{}
+ /** A usable Predicate must provide a string representation.
+ * As there is no \c operator== for \ref Predicate, we compare it's
+ * string representation instead. Actually Predicate deserves to become
+ * a class which is also serializable, so we can store predicated queries.
+ */
+ template<class _Predicate>
+ void addPredicate( const _Predicate & predicate_r )
+ {
+ predicate = predicate_r;
+ predicateStr = predicate_r.stringRep();
+ }
+
sat::SolvAttr attr;
sat::AttrMatcher attrMatcher;
Predicate predicate;
+ std::string predicateStr;
};
- std::ostream & operator<<( std::ostream & str, const AttrMatchData & obj )
+ /** \relates AttrMatchData */
+ inline std::ostream & operator<<( std::ostream & str, const AttrMatchData & obj )
+ {
+ str << obj.attr << ": " << obj.attrMatcher;
+ if ( obj.predicate )
+ str << " +(" << obj.predicateStr << ")";
+ return str;
+ }
+
+ /** \relates AttrMatchData */
+ inline bool operator==( const AttrMatchData & lhs, const AttrMatchData & rhs )
+ {
+ return ( lhs.attr == rhs.attr
+ && lhs.attrMatcher == rhs.attrMatcher
+ && lhs.predicateStr == rhs.predicateStr );
+ }
+
+ /** \relates AttrMatchData */
+ inline bool operator!=( const AttrMatchData & lhs, const AttrMatchData & rhs )
+ { return !( lhs == rhs ); }
+
+ /** \relates AttrMatchData Arbitrary order for std::container. */
+ inline bool operator<( const AttrMatchData & lhs, const AttrMatchData & rhs )
{
- return str << obj.attr << ": " << obj.attrMatcher << ( obj.predicate ? " (+predicate)" : "" );
+ if ( lhs.attr != rhs.attr )
+ return ( lhs.attr < rhs.attr );
+ if ( lhs.attrMatcher != rhs.attrMatcher )
+ return ( lhs.attrMatcher < rhs.attrMatcher );
+ if ( lhs.predicateStr != rhs.predicateStr )
+ return ( lhs.predicateStr < rhs.predicateStr );
+ return false;
}
typedef std::list<AttrMatchData> AttrMatchList;
@@ -127,6 +172,13 @@ namespace zypp
return overlaps( Edition::MatchRange( cap.op(), cap.ed() ), _range );
}
+ std::string stringRep() const
+ {
+ std::ostringstream str;
+ str << "EditionRange " << _range.op << " " << _range.value;
+ return str.str();
+ }
+
Edition::MatchRange _range;
};
@@ -142,6 +194,13 @@ namespace zypp
return overlaps( Edition::MatchRange( Rel::EQ, iter_r.inSolvable().edition() ), _range );
}
+ std::string stringRep() const
+ {
+ std::ostringstream str;
+ str << "SolvableRange " << _range.op << " " << _range.value;
+ return str.str();
+ }
+
Edition::MatchRange _range;
};
@@ -160,6 +219,13 @@ namespace zypp
return _cap.matches( iter_r.asType<Capability>() ) == CapMatch::yes;
}
+ std::string stringRep() const
+ {
+ std::ostringstream str;
+ str << "CapabilityMatch " << _cap;
+ return str.str();
+ }
+
Capability _cap;
};
@@ -196,7 +262,7 @@ namespace zypp
/** Raw attributes */
AttrRawStrMap _attrs;
/** Uncompiled attributes with predicate. */
- AttrMatchList _uncompiledPredicated;
+ std::set<AttrMatchData> _uncompiledPredicated;
/** Sat solver search flags */
Match _flags;
@@ -219,6 +285,26 @@ namespace zypp
//@}
public:
+
+ bool operator==( const PoolQuery::Impl & rhs ) const
+ {
+ return ( _strings == rhs._strings
+ && _attrs == rhs._attrs
+ && _uncompiledPredicated == rhs._uncompiledPredicated
+ && _flags == rhs._flags
+ && _match_word == rhs._match_word
+ && _require_all == rhs._require_all
+ && _status_flags == rhs._status_flags
+ && _edition == rhs._edition
+ && _op == rhs._op
+ && _repos == rhs._repos
+ && _kinds == rhs._kinds );
+ }
+
+ bool operator!=( const PoolQuery::Impl & rhs ) const
+ { return ! operator==( rhs ); }
+
+ public:
/** Compile the regex.
* Basically building the \ref _attrMatchList from strings.
* \throws MatchException Any of the exceptions thrown by \ref AttrMatcher::compile.
@@ -239,6 +325,7 @@ namespace zypp
{ return new Impl( *this ); }
};
+ ///////////////////////////////////////////////////////////////////
struct MyInserter
{
@@ -409,7 +496,7 @@ attremptycheckend:
_attrMatchList.push_back( AttrMatchData( it->attr,
sat::AttrMatcher( rcstrings, cflags ),
- it->predicate ) );
+ it->predicate, it->predicateStr ) );
}
else
{
@@ -656,16 +743,16 @@ attremptycheckend:
break;
}
- // Match::OTHER indicates need to compile.
- sat::AttrMatcher matcher( name, Match::OTHER );
+ // Match::OTHER indicates need to compile
+ // (merge global search strings into name).
+ AttrMatchData attrMatchData( attr, sat::AttrMatcher( name, Match::OTHER ) );
- AttrMatchData::Predicate pred;
if ( isDependencyAttribute( attr ) )
- pred = EditionRangePredicate( op, edition );
+ attrMatchData.addPredicate( EditionRangePredicate( op, edition ) );
else
- pred = SolvableRangePredicate( op, edition );
+ attrMatchData.addPredicate( SolvableRangePredicate( op, edition ) );
- _pimpl->_uncompiledPredicated.push_back( AttrMatchData( attr, matcher, pred ) );
+ _pimpl->_uncompiledPredicated.insert( attrMatchData );
}
void PoolQuery::addDependency( const sat::SolvAttr & attr, Capability cap_r )
@@ -675,15 +762,14 @@ attremptycheckend:
return;
// Matches STRING per default. (won't get compiled!)
- sat::AttrMatcher matcher( cap.name().asString() );
+ AttrMatchData attrMatchData( attr, sat::AttrMatcher( cap.name().asString() ) );
- AttrMatchData::Predicate pred;
if ( isDependencyAttribute( attr ) )
- pred = CapabilityMatchPredicate( cap_r );
+ attrMatchData.addPredicate( CapabilityMatchPredicate( cap_r ) );
else
- pred = SolvableRangePredicate( cap.op(), cap.ed() );
+ attrMatchData.addPredicate( SolvableRangePredicate( cap.op(), cap.ed() ) );
- _pimpl->_uncompiledPredicated.push_back( AttrMatchData( attr, matcher, pred ) );
+ _pimpl->_uncompiledPredicated.insert( attrMatchData );
}
void PoolQuery::setEdition(const Edition & edition, const Rel & op)
@@ -1156,25 +1242,8 @@ attremptycheckend:
ostream & operator<<( ostream & str, const PoolQuery & obj )
{ return str << obj.asString(); }
- bool PoolQuery::operator==(const PoolQuery& a) const
- {
- if( flags() != a.flags() )
- return false;
- if( a.matchWord() != matchWord())
- return false;
- if( a.requireAll() != requireAll() )
- return false;
- if ( a.kinds() != kinds() )
- return false;
- if ( a.repos() != repos() )
- return false;
- if(a.edition() != edition())
- return false;
- if(a.editionRel() != editionRel())
- return false;
-
- return true;
- }
+ bool PoolQuery::operator==( const PoolQuery & rhs ) const
+ { return *_pimpl == *rhs._pimpl; }
///////////////////////////////////////////////////////////////////
namespace detail
diff --git a/zypp/PoolQuery.h b/zypp/PoolQuery.h
index 4238155..8f783fa 100644
--- a/zypp/PoolQuery.h
+++ b/zypp/PoolQuery.h
@@ -84,11 +84,9 @@ namespace zypp
class PoolQuery : public sat::SolvIterMixin
{
public:
- typedef std::setstd::string StrContainer;
typedef std::set<ResKind> Kinds;
+ typedef std::setstd::string StrContainer;
typedef std::map AttrRawStrMap;
- typedef std::map AttrCompiledStrMap;
- typedef std::map AttrRegexMap;
typedef detail::PoolQueryIterator const_iterator;
typedef unsigned int size_type;
--
To unsubscribe, e-mail: zypp-commit+unsubscribe@opensuse.org
For additional commands, e-mail: zypp-commit+help@opensuse.org
