ref: refs/heads/ma-misc commit e4e79389d3652d62784fe0bf5828f58993f23993 Author: Michael Andres Date: Tue Jun 30 16:38:23 2009 +0200 Enhance LookupAttr to allow direct query of attributes within flexarrays. --- tests/sat/LookupAttr_test.cc | 28 ++++++++++++ zypp/sat/LookupAttr.cc | 99 +++++++++++++++++++++++++++++++++++------- zypp/sat/LookupAttr.h | 37 +++++++++++++++- 3 files changed, 146 insertions(+), 18 deletions(-) diff --git a/tests/sat/LookupAttr_test.cc b/tests/sat/LookupAttr_test.cc index ab8c545..6ee003d 100644 --- a/tests/sat/LookupAttr_test.cc +++ b/tests/sat/LookupAttr_test.cc @@ -180,7 +180,35 @@ BOOST_AUTO_TEST_CASE(LookupAttr_solvable_attribute_substructure) BOOST_CHECK_EQUAL( res.subFind( sat::SolvAttr::updateReferenceHref ), res.subFind( "href" ) ); BOOST_CHECK_EQUAL( res.subFind( sat::SolvAttr::updateReferenceId ), res.subFind( "id" ) ); BOOST_CHECK_EQUAL( res.subFind( sat::SolvAttr::updateReferenceTitle ), res.subFind( "title" ) ); + + // NOTE: Unfortunately the satsolver dataiterator loses constect information when + // entering a sub-structure. That's why one can't invoke e.g subBegin on an iterator + // that was retieved by subFind. + // The test below will fail, once libsatsolver fixes the dataiterator. The expected + // result then is, that subBegin brings you to the beginning again. + BOOST_CHECK_EQUAL( res.subFind( sat::SolvAttr::updateReferenceType ).subBegin(), res.subEnd() ); + // BOOST_CHECK_EQUAL( res.subFind( sat::SolvAttr::updateReferenceType ).subBegin(), res.subBegin() ); } + + // search substructure id without parent-structure won't work: + q = sat::LookupAttr( sat::SolvAttr::updateReferenceId ); + BOOST_CHECK_EQUAL( q.size(), 0 ); + + // search id in parent-structure: + q = sat::LookupAttr( sat::SolvAttr::updateReferenceId, sat::SolvAttr::updateReference ); + BOOST_CHECK_EQUAL( q.size(), 303 ); + + // search id in any parent-structure: + q = sat::LookupAttr( sat::SolvAttr::updateReferenceId, sat::SolvAttr::allAttr ); + BOOST_CHECK_EQUAL( q.size(), 303 ); + + // search any id in parent-structure: (4 ids per updateReference) + q = sat::LookupAttr( sat::SolvAttr::allAttr, sat::SolvAttr::updateReference ); + BOOST_CHECK_EQUAL( q.size(), 1212 ); + + // search any id in any parent-structure: + q = sat::LookupAttr( sat::SolvAttr::allAttr, sat::SolvAttr::allAttr ); + BOOST_CHECK_EQUAL( q.size(), 10473 ); } BOOST_AUTO_TEST_CASE(LookupAttr_repoattr) diff --git a/zypp/sat/LookupAttr.cc b/zypp/sat/LookupAttr.cc index 750b081..71acfab 100644 --- a/zypp/sat/LookupAttr.cc +++ b/zypp/sat/LookupAttr.cc @@ -58,13 +58,13 @@ namespace zypp Impl() {} Impl( SolvAttr attr_r, Location loc_r ) - : _attr( attr_r ), _solv( loc_r == REPO_ATTR ? SOLVID_META : noSolvableId ) + : _attr( attr_r ), _parent( SolvAttr::noAttr ), _solv( loc_r == REPO_ATTR ? SOLVID_META : noSolvableId ) {} Impl( SolvAttr attr_r, Repository repo_r, Location loc_r ) - : _attr( attr_r ), _repo( repo_r ), _solv( loc_r == REPO_ATTR ? SOLVID_META : noSolvableId ) + : _attr( attr_r ), _parent( SolvAttr::noAttr ), _repo( repo_r ), _solv( loc_r == REPO_ATTR ? SOLVID_META : noSolvableId ) {} Impl( SolvAttr attr_r, Solvable solv_r ) - : _attr( attr_r ), _solv( solv_r ) + : _attr( attr_r ), _parent( SolvAttr::noAttr ), _solv( solv_r ) {} public: @@ -111,6 +111,13 @@ namespace zypp _solv = solv_r; } + SolvAttr parent() const + { return _parent; } + + void setParent( SolvAttr attr_r ) + { _parent = attr_r; } + + public: LookupAttr::iterator begin() const { if ( _attr == SolvAttr::noAttr || sat::Pool::instance().reposEmpty() ) @@ -123,6 +130,8 @@ namespace zypp whichRepo = _repo.id(); detail::DIWrap dip( whichRepo, _solv.id(), _attr.id(), _attrMatcher.searchstring(), _attrMatcher.flags().get() ); + if ( _parent != SolvAttr::noAttr ) + ::dataiterator_prepend_keyname( dip.get(), _parent.id() ); return iterator( dip ); // iterator takes over ownership! } @@ -131,6 +140,7 @@ namespace zypp private: SolvAttr _attr; + SolvAttr _parent; Repository _repo; Solvable _solv; AttrMatcher _attrMatcher; @@ -155,14 +165,24 @@ namespace zypp LookupAttr::LookupAttr( SolvAttr attr_r, Location loc_r ) : _pimpl( new Impl( attr_r, loc_r ) ) {} + LookupAttr::LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Location loc_r ) + : _pimpl( new Impl( attr_r, loc_r ) ) + { _pimpl->setParent( parent_r ); } LookupAttr::LookupAttr( SolvAttr attr_r, Repository repo_r, Location loc_r ) : _pimpl( new Impl( attr_r, repo_r, loc_r ) ) {} + LookupAttr::LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Repository repo_r, Location loc_r ) + : _pimpl( new Impl( attr_r, repo_r, loc_r ) ) + { _pimpl->setParent( parent_r ); } LookupAttr::LookupAttr( SolvAttr attr_r, Solvable solv_r ) : _pimpl( new Impl( attr_r, solv_r ) ) {} + LookupAttr::LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Solvable solv_r ) + : _pimpl( new Impl( attr_r, solv_r ) ) + { _pimpl->setParent( parent_r ); } + /////////////////////////////////////////////////////////////////// @@ -198,6 +218,12 @@ namespace zypp void LookupAttr::setSolvable( Solvable solv_r ) { _pimpl->setSolvable( solv_r ); } + SolvAttr LookupAttr::parent() const + { return _pimpl->parent(); } + + void LookupAttr::setParent( SolvAttr attr_r ) + { _pimpl->setParent( attr_r ); } + /////////////////////////////////////////////////////////////////// LookupAttr::iterator LookupAttr::begin() const @@ -417,10 +443,25 @@ namespace zypp return false; } - bool LookupAttr::iterator::solvAttrSubEntry() const + /////////////////////////////////////////////////////////////////// + namespace { - return solvAttrType() == REPOKEY_TYPE_FLEXARRAY; + enum SubType { ST_NONE, // no sub-structure + ST_FLEX, // flexarray + ST_SUB }; // inside sub-structure + SubType subType( const detail::DIWrap & dip ) + { + if ( ! dip ) + return ST_NONE; + if ( dip.get()->key->type == REPOKEY_TYPE_FLEXARRAY ) + return ST_FLEX; + return dip.get()->kv.parent ? ST_SUB : ST_NONE; + } } + /////////////////////////////////////////////////////////////////// + + bool LookupAttr::iterator::solvAttrSubEntry() const + { return subType( _dip ) != ST_NONE; } /////////////////////////////////////////////////////////////////// // Iterate sub-structures. @@ -439,12 +480,18 @@ namespace zypp LookupAttr::iterator LookupAttr::iterator::subBegin() const { - if ( ! solvAttrSubEntry() ) - return subEnd(); - - // remember this position - ::dataiterator_setpos( _dip.get() ); - + switch ( subType( _dip ) ) + { + case ST_NONE: + return subEnd(); + break; + case ST_FLEX: + ::dataiterator_setpos( _dip.get() ); + break; + case ST_SUB: + ::dataiterator_setpos_parent( _dip.get() ); + break; + } // setup the new sub iterator with the remembered position detail::DIWrap dip( 0, SOLVID_POS, 0, 0, 0 ); return iterator( dip ); // iterator takes over ownership! @@ -471,9 +518,29 @@ namespace zypp if ( attrname_r.empty() ) return subBegin(); + SubType subtype( subType( _dip ) ); + if ( subtype == ST_NONE ) + return subBegin(); + std::string subattr( inSolvAttr().asString() ); - subattr += ":"; - subattr += attrname_r; + if ( subtype == ST_FLEX ) + { + // append ":attrname" + subattr += ":"; + subattr += attrname_r; + } + else + { + // replace "oldname" after ':' with "attrname" + std::string::size_type pos( subattr.rfind( ':' ) ); + if ( pos != std::string::npos ) + { + subattr.erase( pos+1 ); + subattr += attrname_r; + } + else + subattr = attrname_r; // no ':' so replace all. + } return subFind( SolvAttr( subattr ) ); } @@ -577,7 +644,7 @@ namespace zypp { str << " " << it.inSolvAttr() << " = " << it.asString() << endl; } - str << "}" << endl; + str << "}"; return str.str(); } break; @@ -695,8 +762,8 @@ namespace zypp else if ( obj.inRepo() ) str << obj.inRepo(); - str << '<' << obj.inSolvAttr() - << ">(" << IdString(obj.solvAttrType()) << ") = " << obj.asString(); + str << '<' << obj.inSolvAttr() << (obj.solvAttrSubEntry() ? ">(*" : ">(") + << IdString(obj.solvAttrType()) << ") = " << obj.asString(); return str; } diff --git a/zypp/sat/LookupAttr.h b/zypp/sat/LookupAttr.h index 944563b..5af9688 100644 --- a/zypp/sat/LookupAttr.h +++ b/zypp/sat/LookupAttr.h @@ -60,6 +60,20 @@ namespace zypp * * Use \ref SolvAttr::allAttr to search all attributes. * + * To search for attributes located in a sub-structure (flexarray) + * you also have to pass the sub-structures attribute as parent. + * Passing \ref SolvAttr::allAttr a parent will lookup the attribute + * in \c any sub-structure. + * + * \code + * // Lookup all 'name' attributes: + * sat::LookupAttr q( sat::SolvAttr::name ); + * // Lookup all 'name' attributes within a sub-structure 'data': + * sat::LookupAttr q( sat::SolvAttr::name, sat::SolvAttr::data ); + * // Lookup all 'name' attributes within any sub-structure: + * sat::LookupAttr q( sat::SolvAttr::name, sat::SolvAttr::allAttr ); + * \endcode + * * \code * // look for all attributes of one solvable * void ditest( sat::Solvable slv_r ) @@ -113,12 +127,18 @@ namespace zypp /** Lookup \ref SolvAttr in \ref Pool (all repositories). */ explicit LookupAttr( SolvAttr attr_r, Location = SOLV_ATTR ); + /** \overload SolvAttr within sub-structure \a parent_r. */ + LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Location = SOLV_ATTR ); /** Lookup \ref SolvAttr in one\ref Repository. */ - explicit LookupAttr( SolvAttr attr_r, Repository repo_r, Location = SOLV_ATTR ); + LookupAttr( SolvAttr attr_r, Repository repo_r, Location = SOLV_ATTR ); + /** \overload SolvAttr within sub-structure \a parent_r. */ + LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Repository repo_r, Location = SOLV_ATTR ); /** Lookup \ref SolvAttr in one \ref Solvable. */ LookupAttr( SolvAttr attr_r, Solvable solv_r ); + /** \overload SolvAttr within sub-structure \a parent_r. */ + LookupAttr( SolvAttr attr_r, SolvAttr parent_r, Solvable solv_r ); public: /** \name Search result. */ @@ -196,6 +216,12 @@ namespace zypp /** Set search in one \ref Solvable. */ void setSolvable( Solvable solv_r ); + + /** Whether to search within a sub-structure (\ref SolvAttr::noAttr if not) */ + SolvAttr parent() const; + + /** Set search within a sub-structure (\ref SolvAttr::noAttr for none) */ + void setParent( SolvAttr attr_r ); //@} private: @@ -376,7 +402,7 @@ namespace zypp /** The current \ref SolvAttr. */ SolvAttr inSolvAttr() const; - /** Whether this points to the end of a query. */ + /** Whether this points to the end of a query (Iterator is invalid). */ bool atEnd() const { return !_dip; } //@} @@ -409,6 +435,13 @@ namespace zypp * * These are usable iff \ref solvAttrSubEntry is \c true. * + * \note Unfortunately the underlying satsolver dataiterator as returned + * by \ref subBegin and \ref subFind loses some context when being created. + * Thus it's not possible to invoke \ref subBegin and \ref subFind on an + * iterator that was previously returned by one of those methods. The result + * will be an \c end iterator. For the same reason it is not possible for an + * iterator to leave the sub-structure again. + * * \code * // Lookup all "update:reference" entries for a specific solvable * sat::LookupAttr q( sat::SolvAttr::updateReference, p->satSolvable() ); -- To unsubscribe, e-mail: zypp-commit+unsubscribe@opensuse.org For additional commands, e-mail: zypp-commit+help@opensuse.org