Mailinglist Archive: zypp-commit (171 mails)

< Previous Next >
[zypp-commit] <libzypp> master : Enhance LookupAttr to allow direct query of attributes within flexarrays.
  • From: Michael Andres <ma@xxxxxxx>
  • Date: Tue, 30 Jun 2009 16:38:23 +0200
  • Message-id: <E1MLeWb-0007qc-Tm@xxxxxxxxxxxxxxxx>
ref: refs/heads/master
commit e4e79389d3652d62784fe0bf5828f58993f23993
Author: Michael Andres <ma@xxxxxxx>
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@xxxxxxxxxxxx
For additional commands, e-mail: zypp-commit+help@xxxxxxxxxxxx

< Previous Next >
This Thread
  • No further messages