From: Klaus Kaempf <kkaempf@suse.de>
Date: Mon, 23 Jan 2006 11:58:01 +0000 (+0000)
Subject: backup
X-Git-Tag: BASE-SuSE-SLE-10-SP2-Branch~3171
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=ee96ac8726128ca2997ec8470e8ad9a72bf44799;p=platform%2Fupstream%2Flibzypp.git

backup
---

diff --git a/devel/devel.kkaempf/Buffer.cc b/devel/devel.kkaempf/Buffer.cc
index 35095c0..ba6e311 100644
--- a/devel/devel.kkaempf/Buffer.cc
+++ b/devel/devel.kkaempf/Buffer.cc
@@ -502,8 +502,7 @@ bufferMapFile (const string & filename)
 	ByteArray *byte_array = NULL;
 
 	if (uncompress_memory (data, s.st_size, &byte_array)) {
-	    WAR << "Uncompression of '" << filename
-		<< "' failed" << endl;
+	    WAR << "Uncompression of '" << filename << "' failed" << endl;
 	} else {
 	    buf = (Buffer *)malloc(sizeof (Buffer));
 	    buf->data       = byte_array->data;
diff --git a/devel/devel.kkaempf/HelixExtract.cc b/devel/devel.kkaempf/HelixExtract.cc
index 917b935..7c6ad77 100644
--- a/devel/devel.kkaempf/HelixExtract.cc
+++ b/devel/devel.kkaempf/HelixExtract.cc
@@ -33,10 +33,11 @@
 
 using namespace std;
 using namespace zypp;
-using namespace zypp::solver::detail;
+
+namespace zypp {
 
 int 
-extractHelixBuffer (const char buf[], size_t len, Channel_Ptr channel, ResolvableStoreCallback callback, ResStore *store)
+extractHelixBuffer (const char *buf, size_t len, solver::detail::Channel_Ptr channel, HelixSourceImpl *impl)
 {
 //    _DBG("HelixExtract") << "extract_packages_from_helix_buffer(" << buf << "...," << (long)len << ",...)" << endl;
 
@@ -44,7 +45,7 @@ extractHelixBuffer (const char buf[], size_t len, Channel_Ptr channel, Resolvabl
 	return 1;
 
     HelixParser parser (channel);
-    parser.parseChunk (buf, len, callback, store);
+    parser.parseChunk (buf, len, impl);
     parser.done ();
 
     return 0;
@@ -52,7 +53,7 @@ extractHelixBuffer (const char buf[], size_t len, Channel_Ptr channel, Resolvabl
 
 
 int
-extractHelixFile (const std::string & filename, Channel_Ptr channel, ResolvableStoreCallback callback, ResStore *store)
+extractHelixFile (const std::string & filename, solver::detail::Channel_Ptr channel, HelixSourceImpl *impl)
 {
     Buffer *buf;
 
@@ -63,10 +64,11 @@ extractHelixFile (const std::string & filename, Channel_Ptr channel, ResolvableS
     if (buf == NULL)
 	return -1;
 
-    extractHelixBuffer ((const char *)(buf->data), buf->size, channel, callback, store);
+    extractHelixBuffer ((const char *)(buf->data), buf->size, channel, impl);
 
     bufferUnmapFile (buf);
 
     return 0;
 }
 
+} // namespace zypp
diff --git a/devel/devel.kkaempf/HelixExtract.h b/devel/devel.kkaempf/HelixExtract.h
index b5a6406..08073ee 100644
--- a/devel/devel.kkaempf/HelixExtract.h
+++ b/devel/devel.kkaempf/HelixExtract.h
@@ -32,10 +32,16 @@
 #include "zypp/solver/temporary/XmlNodePtr.h"
 #include "zypp/solver/temporary/ChannelPtr.h"
 
-typedef bool (*ResolvableStoreCallback) (zypp::Resolvable::Ptr res, zypp::ResStore *store);
+#include "HelixParser.h"
 
-int extractHelixBuffer (const char data[], size_t len, zypp::solver::detail::Channel_Ptr channel, ResolvableStoreCallback callback, zypp::ResStore *store);
-int extractHelixFile (const std::string & filename, zypp::solver::detail::Channel_Ptr channel, ResolvableStoreCallback callback, zypp::ResStore *store);
+namespace zypp {
+
+class HelixSourceImpl;
+
+int extractHelixBuffer (const char *data, size_t len, solver::detail::Channel_Ptr channel, HelixSourceImpl *impl);
+int extractHelixFile (const std::string & filename, solver::detail::Channel_Ptr channel, HelixSourceImpl *impl);
+
+}
 
 #endif /* HELIXEXTRACT_H */
 
diff --git a/devel/devel.kkaempf/HelixPackageImpl.cc b/devel/devel.kkaempf/HelixPackageImpl.cc
index 8d9e2fc..eaa3efd 100644
--- a/devel/devel.kkaempf/HelixPackageImpl.cc
+++ b/devel/devel.kkaempf/HelixPackageImpl.cc
@@ -16,320 +16,51 @@
 
 using namespace std;
 using namespace zypp::detail;
-using namespace zypp::solver::detail;
 
 ///////////////////////////////////////////////////////////////////
 namespace zypp
 { /////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////
-  namespace solver
-  { /////////////////////////////////////////////////////////////////
-    namespace detail
-    {
-      ///////////////////////////////////////////////////////////////////
-      //
-      //        CLASS NAME : HelixPackageImpl
-      //
-      ///////////////////////////////////////////////////////////////////
-
-      /** Default ctor
-      */
-      HelixPackageImpl::HelixPackageImpl(
-	const HelixParser & parsed
-      )
-      : _summary(parsed.summary),
-	_description(parsed.description),
-	_group(parsed.group),
-	_install_only(parsed.installOnly),
-        _size_package(parsed.fileSize),
-	_size_installed(parsed.installedSize)
-      {
-      }
-
-      /** Package summary */
-      Label HelixPackageImpl::summary() const
-      { return _summary; }
-
-      /** Package description */
-      Text HelixPackageImpl::description() const
-      { return _description; }
-
-      Text HelixPackageImpl::insnotify() const
-      // metadata doesn't priovide this attribute
-      { return ResObjectImplIf::insnotify(); }
-
-      Text HelixPackageImpl::delnotify() const
-      // metadata doesn't priovide this attribute
-      { return ResObjectImplIf::delnotify(); }
-
-      ByteCount HelixPackageImpl::size() const
-#warning fixme
-      { return 0; }
-
-      bool HelixPackageImpl::providesSources() const
-      { return ResObjectImplIf::providesSources(); }
-
-      Label HelixPackageImpl::instSrcLabel() const
-      { return ResObjectImplIf::instSrcLabel(); }
-      
-      Vendor HelixPackageImpl::instSrcVendor() const
-      { return ResObjectImplIf::instSrcVendor(); }
-      
-      /** */
-      Date HelixPackageImpl::buildtime() const
-      { return _buildtime; }
-
-      /** */
-      std::string HelixPackageImpl::buildhost() const
-      { return _buildhost; }
-
-      /** */
-      Date HelixPackageImpl::installtime() const
-      { return PackageImplIf::installtime(); }
-
-      /** */
-      std::string HelixPackageImpl::distribution() const
-#warning fixme
-      { return string(); }
-
-      /** */
-      Vendor HelixPackageImpl::vendor() const
-      { return _vendor; }
-
-      /** */
-      Label HelixPackageImpl::license() const
-      { return _license; }
-
-      /** */
-      std::string HelixPackageImpl::packager() const
-      { return _packager; }
-
-      /** */
-      PackageGroup HelixPackageImpl::group() const
-      { return _group; }
-
-      /** */
-      Changelog HelixPackageImpl::changelog() const
-      { return _changelog; }
-
-      /** Don't ship it as class Url, because it might be
-       * in fact anything but a legal Url. */
-      std::string HelixPackageImpl::url() const
-      { return _url; }
-
-      /** */
-      std::string HelixPackageImpl::os() const
-      // metadata doesn't priovide this attribute
-      { return PackageImplIf::os(); }
-
-      /** */
-      Text HelixPackageImpl::prein() const
-      // metadata doesn't priovide this attribute
-      { return PackageImplIf::prein(); }
-
-      /** */
-      Text HelixPackageImpl::postin() const
-      // metadata doesn't priovide this attribute
-      { return PackageImplIf::postin(); }
-
-      /** */
-      Text HelixPackageImpl::preun() const
-      // metadata doesn't priovide this attribute
-      { return PackageImplIf::preun(); }
-
-      /** */
-      Text HelixPackageImpl::postun() const
-      // metadata doesn't priovide this attribute
-      { return PackageImplIf::postun(); }
-
-      /** */
-      ByteCount HelixPackageImpl::sourcesize() const
-#warning fixme
-      { return 0; }
-
-      /** */
-      ByteCount HelixPackageImpl::archivesize() const
-#warning fixme
-      { return 0; }
-
-      /** */
-      Text HelixPackageImpl::authors() const
-      { return _authors; }
-
-      /** */
-      Text HelixPackageImpl::filenames() const
-      { return _filenames; }
-
-      License HelixPackageImpl::licenseToConfirm() const
-      { return _license_to_confirm; }
-
-      /** */
-      std::string HelixPackageImpl::type() const
-      { return _type; }
+///////////////////////////////////////////////////////////////////
+//
+//        CLASS NAME : HelixPackageImpl
+//
+///////////////////////////////////////////////////////////////////
 
-      /** */
-      std::list<std::string> HelixPackageImpl::keywords() const
-      { return _keywords; }
+/** Default ctor
+*/
+HelixPackageImpl::HelixPackageImpl (const zypp::HelixParser & parsed)
+    : _summary(parsed.summary)
+    , _description()
+    , _group(parsed.section)
+    , _install_only(parsed.installOnly)
+    , _size_installed(parsed.installedSize)
+    , _size_archive(parsed.fileSize)
+{
+    _description.push_back(parsed.description);
+}
 
-      bool HelixPackageImpl::installOnly() const
-      { return _install_only; }
+/** Package summary */
+Label HelixPackageImpl::summary() const
+{ return _summary; }
 
-      unsigned HelixPackageImpl::mediaId() const
-      { return _mediaid; }
+/** Package description */
+Text HelixPackageImpl::description() const
+{ return _description; }
 
-      CheckSum HelixPackageImpl::checksum() const
-      { return _checksum; }
+PackageGroup HelixPackageImpl::group() const
+{ return _group; }
 
-      std::list<DeltaRpm> HelixPackageImpl::deltaRpms() const
-      { return _delta_rpms; }
+ByteCount HelixPackageImpl::size() const
+{ return _size_installed; }
 
-      std::list<PatchRpm> HelixPackageImpl::patchRpms() const
-      { return _patch_rpms; }
+/** */
+ByteCount HelixPackageImpl::archivesize() const
+{ return _size_archive; }
 
-#if 0
-      /** */
-      std::list<std::string> HelixPackageImpl::insnotify() const
-      { return std::list<std::string>(); }
-      /** */
-      std::list<std::string> HelixPackageImpl::delnotify() const
-      { return std::list<std::string>(); }
-      /** */
-      unsigned HelixPackageImpl::packageSize() const
-      { return _size_package; }
-      /** */
-      unsigned HelixPackageImpl::archiveSize() const
-      { return _size_archive; }
-      /** */
-      unsigned HelixPackageImpl::installedSize() const
-      { return _size_installed; }
-// FIXME do not understand items below
-      /** */
-      bool HelixPackageImpl::providesSources() const
-      {
-	return false;
-      }
-      /** */
-      std::string HelixPackageImpl::instSrcLabel() const
-      {
-	return "";
-      }
-      /** */
-      std::string HelixPackageImpl::instSrcVendor() const
-      {
-	return "";
-      }
-      /** */
-      unsigned HelixPackageImpl::instSrcRank() const
-      {
-	return 0;
-      }
-      /** */
-      std::string HelixPackageImpl::buildhost() const
-      {
-	return _buildhost;
-      }
-      /** */
-      std::string HelixPackageImpl::distribution() const
-      {
-	return "";
-      }
-      /** */
-      std::string HelixPackageImpl::vendor() const
-      {
-	return _vendor;
-      }
-      /** */
-      std::string HelixPackageImpl::license() const
-      {
-	return _license;
-      }
-      /** */
-      std::list<std::string> HelixPackageImpl::licenseToConfirm() const
-      {
-	return std::list<std::string>();
-      }
-      /** */
-      std::string HelixPackageImpl::packager() const
-      {
-	return _packager;
-      }
-      /** */
-      std::string HelixPackageImpl::group() const
-      {
-	return _group;
-      }
-      /** */
-      std::list<std::string> HelixPackageImpl::changelog() const
-      {}
-      /** */
-      std::string HelixPackageImpl::url() const
-      {
-	return _url;
-      }
-      /** */
-      std::string HelixPackageImpl::os() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::prein() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::postin() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::preun() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::postun() const
-      {}
-      /** */
-      std::string HelixPackageImpl::sourcepkg() const
-      { return _sourcepkg; }
-      /** */
-      std::list<std::string> HelixPackageImpl::authors() const
-      { return _authors; }
-      /** */
-      std::list<std::string> HelixPackageImpl::filenames() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::recommends() const
-      {}
-      /** */
-      std::list<std::string> HelixPackageImpl::suggests() const
-      {}
-      /** */
-      std::string HelixPackageImpl::location() const
-      {}
-      /** */
-      std::string HelixPackageImpl::md5sum() const
-      {}
-      /** */
-      std::string HelixPackageImpl::externalUrl() const
-      {}
-      /** */
-      std::list<Edition> HelixPackageImpl::patchRpmBaseVersions() const
-      {}
-      /** */
-      unsigned HelixPackageImpl::patchRpmSize() const
-      {}
-      /** */
-      bool HelixPackageImpl::forceInstall() const
-      {}
-      /** */
-      std::string HelixPackageImpl::patchRpmMD5() const
-      {}
-      /** */
-      bool HelixPackageImpl::isRemote() const
-      {}
-      /** */
-      bool HelixPackageImpl::prefererCandidate() const
-      {}
+bool HelixPackageImpl::installOnly() const
+{ return _install_only; }
 
-#endif
 
-    } // namespace yum
-    /////////////////////////////////////////////////////////////////
-  } // namespace source
-  ///////////////////////////////////////////////////////////////////
   /////////////////////////////////////////////////////////////////
 } // namespace zypp
 ///////////////////////////////////////////////////////////////////
diff --git a/devel/devel.kkaempf/HelixPackageImpl.h b/devel/devel.kkaempf/HelixPackageImpl.h
index e194074..0a2b4b7 100644
--- a/devel/devel.kkaempf/HelixPackageImpl.h
+++ b/devel/devel.kkaempf/HelixPackageImpl.h
@@ -18,29 +18,22 @@
 ///////////////////////////////////////////////////////////////////
 namespace zypp
 { /////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////
-  namespace solver
-  { /////////////////////////////////////////////////////////////////
-    namespace detail
-    { //////////////////////////////////////////////////////////////
 
-      ///////////////////////////////////////////////////////////////////
-      //
-      //        CLASS NAME : HelixPackageImpl
-      //
-      /** Class representing a package
-      */
-      class HelixPackageImpl : public zypp::detail::PackageImplIf
-      {
-      public:
+///////////////////////////////////////////////////////////////////
+//
+//        CLASS NAME : HelixPackageImpl
+//
+/** Class representing a package
+*/
+class HelixPackageImpl : public detail::PackageImplIf
+{
+public:
 
 	class HelixParser;
 	/** Default ctor
 	*/
-	HelixPackageImpl(
-	  const HelixParser & data
-	);
-#if 0
+	HelixPackageImpl( const zypp::HelixParser & data );
+
 	/** Package summary */
 	virtual Label summary() const;
 	/** Package description */
@@ -51,22 +44,20 @@ namespace zypp
 	/** */
 	virtual ByteCount archivesize() const;
 	/** */
+	virtual bool installOnly() const;
+	/** */
 
-      protected:
+protected:
 	Label _summary;
 	Text _description;
 	PackageGroup _group;
+	bool _install_only;
 
 	ByteCount _size_installed;
 	ByteCount _size_archive;
-#endif
 
-       };
-      ///////////////////////////////////////////////////////////////////
-    } // namespace detail
-    /////////////////////////////////////////////////////////////////
-  } // namespace solver
-  ///////////////////////////////////////////////////////////////////
+
+ };
   /////////////////////////////////////////////////////////////////
 } // namespace zypp
 ///////////////////////////////////////////////////////////////////
diff --git a/devel/devel.kkaempf/HelixParser.cc b/devel/devel.kkaempf/HelixParser.cc
index bca7183..9c210a7 100644
--- a/devel/devel.kkaempf/HelixParser.cc
+++ b/devel/devel.kkaempf/HelixParser.cc
@@ -25,6 +25,8 @@
 #include <ctype.h>
 #include <assert.h>
 #include "HelixParser.h"
+#include "HelixPackageImpl.h"
+#include "HelixSourceImpl.h"
 
 #include "zypp/ResObject.h"
 #include "zypp/CapFactory.h"
@@ -34,42 +36,33 @@
 #include "zypp/base/String.h"
 #include "zypp/base/Logger.h"
 
-/////////////////////////////////////////////////////////////////////////
-namespace zypp
-{ ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-    namespace solver
-    { /////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////
-  namespace detail
-  { ///////////////////////////////////////////////////////////////////
-
 using namespace std;
+using namespace zypp;
 
 //---------------------------------------------------------------------------
 
 static Resolvable::Kind
 string2kind (const std::string & str)
 {
-    Resolvable::Kind kind = ResTraits<zypp::Package>::kind;
+    Resolvable::Kind kind = ResTraits<Package>::kind;
     if (!str.empty()) {
 	if (str == "package") {
 	    // empty
 	}
 	else if (str == "patch") {
-	    kind = ResTraits<zypp::Patch>::kind;
+	    kind = ResTraits<Patch>::kind;
 	}
 	else if (str == "pattern") {
-	    kind = ResTraits<zypp::Pattern>::kind;
+	    kind = ResTraits<Pattern>::kind;
 	}
 	else if (str == "script") {
-	    kind = ResTraits<zypp::Script>::kind;
+	    kind = ResTraits<Script>::kind;
 	}
 	else if (str == "message") {
-	    kind = ResTraits<zypp::Message>::kind;
+	    kind = ResTraits<Message>::kind;
 	}
 	else if (str == "product") {
-	    kind = ResTraits<zypp::Product>::kind;
+	    kind = ResTraits<Product>::kind;
 	}
 	else {
 	    ERR << "get_resItem unknown kind '" << str << "'" << endl;
@@ -82,14 +75,14 @@ string2kind (const std::string & str)
 //---------------------------------------------------------------------------
 
 static Capability
-parse_dep_attrs(bool *is_obsolete, const xmlChar **attrs)
+parse_dep_attrs(bool *is_obsolete, bool *is_pre, const xmlChar **attrs)
 {
     CapFactory  factory;
     int i;
     bool op_present = false;
     /* Temporary variables dependent upon the presense of an 'op' attribute */
 
-    Resolvable::Kind dkind = ResTraits<zypp::Package>::kind;	// default to package
+    Resolvable::Kind dkind = ResTraits<Package>::kind;	// default to package
     string dname;
     int depoch = Edition::noepoch;
     string dversion;
@@ -98,6 +91,7 @@ parse_dep_attrs(bool *is_obsolete, const xmlChar **attrs)
     Rel relation = Rel::ANY;
 
     *is_obsolete = false;
+    *is_pre = false;
 
     for (i = 0; attrs[i]; i++) {
 	const string attr ((const char *)attrs[i++]);
@@ -111,6 +105,7 @@ parse_dep_attrs(bool *is_obsolete, const xmlChar **attrs)
 	else if (attr == "release")	drelease = value;
 	else if (attr == "arch")	darch = value;
 	else if (attr == "obsoletes")	*is_obsolete = true;
+	else if (attr == "pre")		if (value && *value == '1') *is_pre = true;
 	else {
 	    _DBG("HelixParser") << "! Unknown attribute: " << attr << " = " << value << endl;
 	}
@@ -201,7 +196,7 @@ sax_characters(void *ptr, const xmlChar *ch, int len)
 {
     HelixParser *ctx = (HelixParser *)ptr;
 
-    ctx->toBuffer (str::trim (string ((const char *)ch)));
+    ctx->toBuffer (str::trim (string ((const char *)ch, len)));
     return;
 }
 
@@ -265,14 +260,15 @@ static xmlSAXHandler sax_handler = {
 
 //---------------------------------------------------------------------------
 
-HelixParser::HelixParser (Channel_constPtr channel)
+HelixParser::HelixParser (solver::detail::Channel_constPtr channel)
     : _channel (channel)
     , _processing (false)
     , _xml_context (NULL)
     , _state (PARSER_TOPLEVEL)
     , _stored(true)
-    , _toplevel_dep_list (NULL)
-    , _dep_list (NULL)
+    , _dep_set (NULL)
+    , _toplevel_dep_set (NULL)
+    , _impl (NULL)
 {
 //    _XXX("HelixParser") <<  "* Context created (" << this << ")" << endl;
 }
@@ -336,7 +332,7 @@ HelixParser::releaseBuffer ()
 // called for extracting
 
 void
-HelixParser::parseChunk(const char *xmlbuf, size_t size, ResolvableStoreCallback callback, ResStore *store)
+HelixParser::parseChunk(const char *xmlbuf, size_t size, HelixSourceImpl *impl)
 {
 //    _DBG("HelixParser") << "HelixParser::parseChunk(" << xmlbuf << "...," << (long)size << ")" << endl;
 
@@ -346,8 +342,7 @@ HelixParser::parseChunk(const char *xmlbuf, size_t size, ResolvableStoreCallback
 	_xml_context = xmlCreatePushParserCtxt(&sax_handler, this, NULL, 0, NULL);
     }
 
-    _callback = callback;
-    _store = store;
+    _impl = impl;
 
     xmlParseChunk(_xml_context, xmlbuf, size, 0);
 }
@@ -455,13 +450,13 @@ HelixParser::toplevelStart(const std::string & token, const xmlChar **attrs)
 	fileSize = 0;
 	installedSize = 0;
 	installOnly = false;
+	installed = false;
 
 	requires.clear();
 	provides.clear();
 	conflicts.clear();
 	freshens.clear();
 	enhances.clear();
-	children.clear();
 	recommends.clear();
 	suggests.clear();
 	obsoletes.clear();
@@ -491,15 +486,15 @@ HelixParser::resolvableStart(const std::string & token, const xmlChar **attrs)
     }
     else if (token == "requires") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &requires;
+	_dep_set = _toplevel_dep_set = &requires;
     }
     else if (token == "recommends") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &recommends;
+	_dep_set = _toplevel_dep_set = &recommends;
     }
     else if (token == "suggests") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &suggests;
+	_dep_set = _toplevel_dep_set = &suggests;
     }
     else if (token == "conflicts") {
 	bool is_obsolete = false;
@@ -514,26 +509,32 @@ HelixParser::resolvableStart(const std::string & token, const xmlChar **attrs)
 	}
 
 	if (is_obsolete)
-	    _dep_list = _toplevel_dep_list = &obsoletes;
+	    _dep_set = _toplevel_dep_set = &obsoletes;
 	else {
-	    _dep_list = _toplevel_dep_list = &conflicts;
+	    _dep_set = _toplevel_dep_set = &conflicts;
 	}
     }
     else if (token == "obsoletes") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &obsoletes;
+	_dep_set = _toplevel_dep_set = &obsoletes;
     }
     else if (token == "provides") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &provides;
+	_dep_set = _toplevel_dep_set = &provides;
     }
+#if 0		// disabled
     else if (token == "children") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &children;
+	_dep_set = _toplevel_dep_set = &children;
     }
+#endif
     else if (token == "freshens") {
 	_state = PARSER_DEP;
-	_dep_list = _toplevel_dep_list = &freshens;
+	_dep_set = _toplevel_dep_set = &freshens;
+    }
+    else if (token == "enhances") {
+	_state = PARSER_DEP;
+	_dep_set = _toplevel_dep_set = &enhances;
     }
     else {
 //	_XXX("HelixParser") << "! Not handling " << token << " in package start" << endl;
@@ -564,17 +565,20 @@ HelixParser::dependencyStart(const std::string & token, const xmlChar **attrs)
     if (token == "dep") {
 	Capability dep;
 	bool is_obsolete;
+	bool is_pre;
 
-	dep = parse_dep_attrs(&is_obsolete, attrs);
+	dep = parse_dep_attrs(&is_obsolete, &is_pre, attrs);
 
 	if (is_obsolete)
 	    obsoletes.insert (dep);
+	else if (is_pre)
+	    prerequires.insert (dep);
 	else {
-	    _dep_list->insert (dep);
+	    _dep_set->insert (dep);
 	}
     }
     else if (token == "or")
-	_dep_list->clear();
+	_dep_set->clear();
     else {
 	_DBG("HelixParser") <<  "! Not handling " << token << " in dependency" << endl;
     }
@@ -612,28 +616,18 @@ HelixParser::resolvableEnd (const std::string & token)
 	}
 
 	if (piter == provides.end()) {			// no self provide found, construct one
-	    _XXX("RC_SPEW") << "Adding self-provide [" << selfdep.asString() << "]" << endl;
+//	    _XXX("HelixParser") << "Adding self-provide [" << selfdep.asString() << "]" << endl;
 	    provides.insert (selfdep);
 	}
 
-	Dependencies deps;
-	deps.requires		= requires;
-	deps.provides		= provides;
-	deps.conflicts		= conflicts;
-	deps.obsoletes		= obsoletes;
-	deps.suggests		= suggests;
-	deps.recommends		= recommends;
-	deps.freshens		= freshens;
-
-#warning Resolvable complete
-#if 0
-	Package_Ptr package = new Package ( channel, kind, name, edition, arch);
+	if (_channel->system())
+	    installed = true;
 
-	if (_channel->system())				// simulate system channel by loading xml file
-	    package->setInstalled (true);
-#endif
+	if (_impl) {
+	    _impl->parserCallback (*this);
+	}
 
-//	_DBG("RC_SPEW") << package->asString(true) << endl;
+//	_DBG("HelixParser") << package->asString(true) << endl;
 //	_DBG("HelixParser") << "HelixParser::resolvableEnd(" << token << ") done: '" << package->asString(true) << "'" << endl;
 //	_XXX("HelixParser") << "HelixParser::resolvableEnd now " << _all_packages.size() << " packages" << endl;
 	_stored = true;
@@ -648,6 +642,7 @@ HelixParser::resolvableEnd (const std::string & token)
     } else if (token == "filesize") {		fileSize = str::strtonum<long>(_text_buffer);
     } else if (token == "installedsize") {	installedSize = str::strtonum<long>(_text_buffer);
     } else if (token == "install_only") {	installOnly = true;
+    } else if (token == "md5sum") {		// ignore
     } else {
 	_DBG("HelixParser") << "HelixParser::resolvableEnd(" << token << ") unknown" << endl;
     }
@@ -675,8 +670,6 @@ HelixParser::updateEnd (const std::string & token)
 {
 //    _XXX("HelixParser") << "HelixParser::updateEnd(" << token << ")" << endl;
 
-    Channel_constPtr channel;
-
     if (token == "update") {
 	_state = PARSER_HISTORY;
     } else if (token == "epoch") {		epoch = str::strtonum<int>(_text_buffer);
@@ -708,13 +701,13 @@ HelixParser::dependencyEnd (const std::string & token)
 
     if (token == "or") {
 #if 0
-	OrDependency_Ptr or_dep = OrDependency::fromDependencyList (*_dep_list);
+	OrDependency_Ptr or_dep = OrDependency::fromDependencyList (*_dep_set);
 	Dependency_Ptr dep = new Dependency (or_dep);
 
-	(*_dep_list).clear();
+	(*_dep_set).clear();
 
-	(*_toplevel_dep_list).push_back (dep);
-	_dep_list = _toplevel_dep_list;
+	(*_toplevel_dep_set).push_back (dep);
+	_dep_set = _toplevel_dep_set;
 #endif
     }
     else if (token == "dep") {
@@ -722,19 +715,9 @@ HelixParser::dependencyEnd (const std::string & token)
     }
     else {
 	/* All of the dep lists (requires, provides, etc.) */
-	_toplevel_dep_list = NULL;
-	_dep_list = NULL;
+	_toplevel_dep_set = NULL;
+	_dep_set = NULL;
 	_state = PARSER_RESOLVABLE;
     }
 }
 
-
-///////////////////////////////////////////////////////////////////
-  };// namespace detail
-  /////////////////////////////////////////////////////////////////////
-  /////////////////////////////////////////////////////////////////////
-    };// namespace solver
-    ///////////////////////////////////////////////////////////////////////
-    ///////////////////////////////////////////////////////////////////////
-};// namespace zypp
-/////////////////////////////////////////////////////////////////////////
diff --git a/devel/devel.kkaempf/HelixParser.h b/devel/devel.kkaempf/HelixParser.h
index 5f87a04..d8428ee 100644
--- a/devel/devel.kkaempf/HelixParser.h
+++ b/devel/devel.kkaempf/HelixParser.h
@@ -27,21 +27,18 @@
 #include <list>
 
 #include "zypp/CapSet.h"
-
-#include "HelixExtract.h"
+#include "zypp/ResStore.h"
+#include "zypp/Dependencies.h"
 
 #include "zypp/solver/temporary/Channel.h"
 #include "zypp/solver/temporary/XmlNode.h"
 
-/////////////////////////////////////////////////////////////////////////
-namespace zypp
-{ ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-  namespace solver
-  { /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-    namespace detail
-    { ///////////////////////////////////////////////////////////////////
+namespace zypp {
+
+class HelixParser;
+class HelixSourceImpl;
+typedef bool (*ParserCallback) (const HelixParser & parsed, HelixSourceImpl *impl);
+
 
 ///////////////////////////////////////////////////////////////////
 //
@@ -60,7 +57,7 @@ class HelixParser
     typedef enum _HelixParserState HelixParserState;
 
   private:
-    Channel_constPtr _channel;
+    solver::detail::Channel_constPtr _channel;
     bool _processing;
     xmlParserCtxtPtr _xml_context;
     HelixParserState _state;
@@ -82,21 +79,22 @@ class HelixParser
     int fileSize;
     int installedSize;
     bool installOnly;
+    bool installed;
 
-    CapSet requires;
     CapSet provides;
+    CapSet prerequires;
+    CapSet requires;
     CapSet conflicts;
-    CapSet children;
+    CapSet obsoletes;
     CapSet recommends;
     CapSet suggests;
-    CapSet obsoletes;
     CapSet freshens;
     CapSet enhances;
 
   private:
-    // these point to one of the above lists during dependency parsing
-    CapSet *_toplevel_dep_list;
-    CapSet *_dep_list;
+    // these point to one of the Dependency sets during dependency parsing
+    CapSet *_dep_set;
+    CapSet *_toplevel_dep_set;		// just needed during 'or' parsing
 
     std::string _text_buffer;
 
@@ -104,7 +102,7 @@ class HelixParser
 
   public:
 
-    HelixParser (Channel_constPtr channel);
+    HelixParser (solver::detail::Channel_constPtr channel);
     virtual ~HelixParser();
 
     // ---------------------------------- I/O
@@ -133,12 +131,11 @@ class HelixParser
     void startElement(const std::string & token, const xmlChar **attrs);
     void endElement(const std::string & token);
 
-    void parseChunk (const char *xmlbuf, size_t size, ResolvableStoreCallback callback, ResStore *store);
+    void parseChunk (const char *xmlbuf, size_t size, HelixSourceImpl *impl);
     void done (void);
 
   private:
-    ResolvableStoreCallback _callback;
-    ResStore *_store;
+    HelixSourceImpl *_impl;
 
     // internal HelixParser functions, c++-style
     void toplevelStart(const std::string & token, const xmlChar **attrs);
@@ -153,15 +150,6 @@ class HelixParser
 
 };
 
-///////////////////////////////////////////////////////////////////
-    };// namespace detail
-    /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-  };// namespace solver
-  ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-};// namespace zypp
-/////////////////////////////////////////////////////////////////////////
-
+} // namespace zypp
 
 #endif  // ZYPP_SOLVER_TEMPORARY_HELIXPARSER_H
diff --git a/devel/devel.kkaempf/HelixSourceImpl.cc b/devel/devel.kkaempf/HelixSourceImpl.cc
index a92da6d..641e283 100644
--- a/devel/devel.kkaempf/HelixSourceImpl.cc
+++ b/devel/devel.kkaempf/HelixSourceImpl.cc
@@ -19,22 +19,17 @@
  * 02111-1307, USA.
  */
 
+#include "HelixExtract.h"
 #include "HelixSourceImpl.h"
+#include "HelixPackageImpl.h"
+
 #include "zypp/solver/temporary/Channel.h"
 #include "zypp/solver/temporary/extract.h"
 #include "zypp/base/Logger.h"
 
-/////////////////////////////////////////////////////////////////////////
-namespace zypp 
-{ ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-  namespace solver
-  { /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-    namespace detail
-    { ///////////////////////////////////////////////////////////////////
 
 using namespace std;
+using namespace zypp;
 
 //---------------------------------------------------------------------------
 
@@ -43,47 +38,103 @@ HelixSourceImpl::HelixSourceImpl(media::MediaAccess::Ptr & media_r, const Pathna
     load (path_r.asString());
 }
 
+Dependencies
+HelixSourceImpl::createDependencies (const HelixParser & parsed)
+{
+    Dependencies deps;
+
+    deps.provides = parsed.provides;
+    deps.prerequires = parsed.prerequires;
+    deps.requires = parsed.requires;
+    deps.conflicts = parsed.conflicts;
+    deps.obsoletes = parsed.obsoletes;
+    deps.recommends = parsed.recommends;
+    deps.suggests = parsed.suggests;
+    deps.freshens = parsed.freshens;
+    deps.enhances = parsed.enhances;
+
+    return deps;
+}
 
-//---------------------------------------------------------------------------
+Package::Ptr
+HelixSourceImpl::createPackage (const HelixParser & parsed)
+{
+    try
+    {
+	shared_ptr<HelixPackageImpl> impl(new HelixPackageImpl(parsed));
+
+	// Collect basic Resolvable data
+	NVRAD dataCollect( parsed.name,
+			Edition( parsed.version, parsed.release, parsed.epoch ),
+			Arch( parsed.arch ),
+			createDependencies (parsed));
+	Package::Ptr package = detail::makeResolvableFromImpl(dataCollect, impl);
+	return package;
+    }
+    catch (const Exception & excpt_r)
+    {
+	ERR << excpt_r << endl;
+	throw "Cannot create package object";
+    }
+    return NULL;
+}
 
 
-static bool
-add_resolvable_cb (Resolvable::Ptr res, ResStore *store)
+Message::Ptr
+HelixSourceImpl::createMessage (const HelixParser & data)
 {
-#if 0
-    HelixSourceImpl *undump = (HelixSourceImpl *)data;
+    return NULL;
+}
+
+
+Script::Ptr
+HelixSourceImpl::createScript (const HelixParser & data)
+{
+    return NULL;
+}
 
-    undump->addResItem (res);
-#else
-    MIL << "add_resItem_cb()" << endl;
-#endif
 
-    return true;
+Patch::Ptr
+HelixSourceImpl::createPatch (const HelixParser & data)
+{
+    return NULL;
 }
 
 
+Pattern::Ptr
+HelixSourceImpl::createPattern (const HelixParser & data)
+{
+    return NULL;
+}
+
+
+Product::Ptr
+HelixSourceImpl::createProduct (const HelixParser & data)
+{
+    return NULL;
+}
+
+//-----------------------------------------------------------------------------
+
+void
+HelixSourceImpl::parserCallback (const HelixParser & data)
+{
+    if (data.kind == ResTraits<Package>::kind) {
+	Package::Ptr p = createPackage (data);
+	_store.insert (p);
+    }
+}
+
 //-----------------------------------------------------------------------------
 
 void
 HelixSourceImpl::load (const string & filename)
 {
     if (!filename.empty()) {
-	Channel_Ptr channel = new Channel ("test", "test", "test", "test");
-	channel->setType (CHANNEL_TYPE_HELIX);
+	solver::detail::Channel_Ptr channel = new solver::detail::Channel ("test", "test", "test", "test");
+	channel->setType (solver::detail::CHANNEL_TYPE_HELIX);
 //	channel->setSystem (true);
 
-	extractHelixFile (filename, channel, add_resolvable_cb, &_store);
+	extractHelixFile (filename, channel, this);
     }
 }
-
-
-///////////////////////////////////////////////////////////////////
-    };// namespace detail
-    /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-  };// namespace solver
-  ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-};// namespace zypp
-/////////////////////////////////////////////////////////////////////////
-
diff --git a/devel/devel.kkaempf/HelixSourceImpl.h b/devel/devel.kkaempf/HelixSourceImpl.h
index 7c54211..929c083 100644
--- a/devel/devel.kkaempf/HelixSourceImpl.h
+++ b/devel/devel.kkaempf/HelixSourceImpl.h
@@ -38,15 +38,7 @@
 #include "zypp/Selection.h"
 #include "zypp/Pattern.h"
 
-/////////////////////////////////////////////////////////////////////////
-namespace zypp 
-{ ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-  namespace solver
-  { /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-    namespace detail
-    { ///////////////////////////////////////////////////////////////////
+namespace zypp {
         
 ///////////////////////////////////////////////////////////////////
 //
@@ -66,15 +58,20 @@ class HelixSourceImpl : public zypp::source::SourceImpl {
     /** Default ctor */
     HelixSourceImpl(media::MediaAccess::Ptr & media_r, const Pathname & path_r = "/");
 
+    Package::Ptr createPackage (const HelixParser & data);
+    Message::Ptr createMessage (const HelixParser & data);
+    Script::Ptr  createScript (const HelixParser & data);
+    Patch::Ptr   createPatch (const HelixParser & data);
+    Pattern::Ptr createPattern (const HelixParser & data);
+    Product::Ptr createProduct (const HelixParser & data);
+
+
+    Dependencies createDependencies (const HelixParser & data);
+
+    void parserCallback (const HelixParser & data);
 };
-///////////////////////////////////////////////////////////////////
-    };// namespace detail
-    /////////////////////////////////////////////////////////////////////
-    /////////////////////////////////////////////////////////////////////
-  };// namespace solver
-  ///////////////////////////////////////////////////////////////////////
-  ///////////////////////////////////////////////////////////////////////
-};// namespace zypp
-/////////////////////////////////////////////////////////////////////////
+
+
+} // namespace zypp
 
 #endif // ZYPP_SOLVER_TEMPORARY_HELIXSOURCEIMPL_H
diff --git a/devel/devel.kkaempf/Makefile.am b/devel/devel.kkaempf/Makefile.am
index 1a9113b..e395620 100644
--- a/devel/devel.kkaempf/Makefile.am
+++ b/devel/devel.kkaempf/Makefile.am
@@ -28,7 +28,6 @@ lib@PACKAGE@_devel_kkaempf_la_SOURCES =		\
 	Buffer.cc				\
 	HelixExtract.cc				\
 	HelixParser.cc				\
-	HelixSourceImpl.cc
-
-#	HelixPackageImpl.cc
+	HelixSourceImpl.cc			\
+	HelixPackageImpl.cc
 
diff --git a/devel/devel.kkaempf/dummy-packages.xml b/devel/devel.kkaempf/dummy-packages.xml
index 566f50c..263f701 100644
--- a/devel/devel.kkaempf/dummy-packages.xml
+++ b/devel/devel.kkaempf/dummy-packages.xml
@@ -1,6 +1,6 @@
 <channel><subchannel>
 <package>
-  <name>unfulfilled</name>
+  <name>Package1</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -19,14 +19,14 @@
     </update>
   </history>
   <provides>
-    <dep name="x" op="(any)" version="1.0"/>
+    <dep name="x"/>
   </provides>
   <requires>
     <dep name="nothere"/>
   </requires>
 </package>
 <package>
-  <name>A</name>
+  <name>Package2</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -45,14 +45,14 @@
     </update>
   </history>
   <requires>
-    <dep name="b" op="(any)" version="1.0"/>
+    <dep name="b" op="=" version="1.0"/>
   </requires>
   <provides>
-    <dep name="a" op="(any)" version="1.0"/>
+    <dep name="a" op="=" version="1.0"/>
   </provides>
 </package>
 <package>
-  <name>B</name>
+  <name>Package3</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -71,17 +71,17 @@
     </update>
   </history>
   <requires>
-    <dep name="c" op="(any)" version="1.0"/>
+    <dep name="c" op="&lt;" version="1.0"/>
   </requires>
   <provides>
-    <dep name="b" op="(any)" version="1.0"/>
+    <dep name="b" op="&gt;=" version="1.0"/>
   </provides>
   <conflicts>
-    <dep name="e" op="(any)" version="1.0"/>
+    <dep name="e" op="!=" version="1.0"/>
   </conflicts>
 </package>
 <package>
-  <name>C</name>
+  <name>Package4</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -100,11 +100,11 @@
     </update>
   </history>
   <provides>
-    <dep name="c" op="(any)" version="1.0"/>
+    <dep name="c" op="&lt;=" version="1.0"/>
   </provides>
 </package>
 <package>
-  <name>D</name>
+  <name>Package5</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -123,12 +123,12 @@
     </update>
   </history>
   <provides>
-    <dep name="d" op="(any)" version="1.0"/>
-    <dep name="c" op="(any)" version="1.0"/>
+    <dep name="d" op="==" version="1.0"/>
+    <dep name="c"/>
   </provides>
 </package>
 <package>
-  <name>E</name>
+  <name>Package6</name>
   <summary>A fake package</summary>
   <description>A fake package</description>
   <section>misc</section>
@@ -146,10 +146,5 @@
       <description>Yggdrasil Linux</description>
     </update>
   </history>
-  <provides>
-    <dep name="c" op="(any)" version="1.0"/>
-    <dep name="e" op="(any)" version="1.0"/>
-    <dep name="x" op="(any)" version="1.0"/>
-  </provides>
 </package>
 </subchannel></channel>
diff --git a/devel/devel.kkaempf/rcparse.cc b/devel/devel.kkaempf/rcparse.cc
index bd819dc..241eca3 100644
--- a/devel/devel.kkaempf/rcparse.cc
+++ b/devel/devel.kkaempf/rcparse.cc
@@ -41,7 +41,7 @@ int main( int argc, char * argv[] )
     Pathname p = argv[1];
 
     media::MediaAccess::Ptr media = new media::MediaAccess();
-    Source::Impl_Ptr impl = new solver::detail::HelixSourceImpl (media, p);
+    Source::Impl_Ptr impl = new HelixSourceImpl (media, p);
     SourceFactory _f;
     Source s = _f.createFrom( impl );
     ResStore store = s.resolvables();