--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings
+#
+#
+
+cmake_minimum_required(VERSION 2.8)
+
+ENABLE_TESTING()
+
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wall -fPIC -fno-strict-aliasing")
+
+#
+# where to look first for cmake modules, before ${CMAKE_ROOT}/Modules/ is checked
+#
+
+SET(CMAKE_MODULE_PATH ${CMAKE_SOURCE_DIR}/cmake/modules ${CMAKE_MODULE_PATH})
+SET(CMAKE_MODULE_PATH ${CMAKE_INSTALL_PREFIX}/share/cmake/Modules ${CMAKE_MODULE_PATH})
+
+INCLUDE(ZyppCommon)
+
+#
+# versioning, packaging
+#
+
+INCLUDE(${CMAKE_SOURCE_DIR}/VERSION.cmake)
+
+SET( PACKAGE "libzypp-bindings" )
+SET( VERSION "${VERSION_MAJOR}.${VERSION_MINOR}.${VERSION_PATCH}" )
+
+
+GENERATE_PACKAGING(${PACKAGE} ${VERSION})
+INCLUDE(CPack)
+
+
+MESSAGE(STATUS "Looking modules in ${CMAKE_MODULE_PATH}")
+
+#
+# Finding Swig
+#
+
+FIND_PACKAGE(SWIG REQUIRED)
+
+#
+# Finding Zypp
+#
+
+FIND_PACKAGE(Zypp REQUIRED)
+
+# determine zypp version
+FIND_PROGRAM(READ_LINK readlink)
+EXECUTE_PROCESS(COMMAND "${READ_LINK}" "-f" ${ZYPP_LIBRARY} OUTPUT_VARIABLE ZYPP_SOFILE)
+
+# match number at end, strip trailing \n by using a sub-match
+STRING(REGEX MATCH "([0-9]+)\\.[0-9]+\\.[0-9]+\n$" ZYPP_VERSION "${ZYPP_SOFILE}")
+SET( ZYPP_VERSION "${CMAKE_MATCH_1}" )
+MESSAGE(STATUS "Zypp so library version ${ZYPP_VERSION}")
+
+SET( SWIG_DEFINITIONS -DZYPP_DEPRECATED -DZYPP_VERSION=${ZYPP_VERSION} )
+
+#
+# Finding Boost
+#
+
+FIND_PATH( BOOST_SMARTPTR_INCLUDE_DIR boost/smart_ptr/shared_ptr.hpp
+ /usr/include
+ /usr/local/include
+)
+IF( BOOST_SMARTPTR_INCLUDE_DIR )
+ SET( SWIG_DEFINITIONS ${SWIG_DEFINITIONS} -DBOOST_SMARTPTR_INCLUDE_DIR )
+ENDIF( BOOST_SMARTPTR_INCLUDE_DIR )
+
+# Now into SWIG
+
+ADD_SUBDIRECTORY(swig)
+
--- /dev/null
+
+Attempt to create generated bindings for
+libzypp. Not restricted to one language.
+
+Authors: kkaempf@suse.de
+ dmacvicar@suse.de
+ aschnell@suse.de
+
+Ruby Notes
+==========
+
+* API tries to follow ruby standards:
+* Containers do not implement iterators but:
+ * each
+ * to_a
+ * etc
+* lower case methods, ie: ZYppFactory::instance.get_zypp
+ instead of ZYppFactory::instance()->getZYpp()
+ z.initialize_target("/") for z.initializeTarget("/")
+
--- /dev/null
+SET(VERSION_MAJOR "0")
+SET(VERSION_MINOR "5")
+SET(VERSION_PATCH "10")
--- /dev/null
+use zypp;
+
+$z = zyppc::ZYppFactory_instance();
+$zypp = $z->getZYpp;
+
+$t = $zypp->initializeTarget(zypp::Pathname->new("/"));
+
+$repo = $zypp->target;
+$store = $repo->resolvables;
+
+$it_b = $store->cBegin;
+
+while ($store->iterator_equal($it_b, $store->cEnd) ne 1){
+ $pkg = $store->iterator_value($it_b);
+ print $pkg->kindToS, " ", $pkg->name, " ", $pkg->edition->asString;
+ print $pkg->arch->asString, "\n";
+ print " Summary: ", $pkg->summary, "\n";
+ print " Size: ", $pkg->size, "\n";
+ print " Vendor: ", $pkg->vendor, "\n";
+ print " BuildTime: ", $pkg->buildtime->asString, "\n";
+ $it_b = $store->iterator_incr($it_b);
+
+ $deps = $pkg->dep($zyppc::Dep_PROVIDES);
+
+ $it_b2 = $deps->cBegin;
+
+ while($deps->iterator_equal($it_b2, $deps->cEnd) ne 1){
+ $dep = $deps->iterator_value($it_b2);
+ print "Provides: ", $dep->asString, "\n";
+ $it_b2 = $deps->iterator_incr($it_b2);
+ }
+ print "\n";
+
+}
--- /dev/null
+use zypp;
+use rpdbtozypp;
+
+$z = zyppc::ZYppFactory_instance();
+$zypp = $z->getZYpp;
+$pdb = rpdbtozypp::PdbToZypp->new;
+print "Package to install: ";
+$ipkg = <STDIN>;
+chomp($ipkg);
+print "Importing packages from pdb!\n\n";
+print "This may take a while, please be patient!\n";
+if($pdb->readOut ne 1){
+ exit;
+}
+$store = $pdb->getStore;
+$zypp->addResolvables($store);
+
+$pool = $zypp->pool;
+$it_b = $pool->cBegin;
+$it_e = $pool->cEnd;
+
+$checker = 0;
+
+print "Looking for package...!\n";
+while ($pool->iterator_equal($it_b, $pool->cEnd) ne 1){
+ $pkg = $pool->iterator_value($it_b);
+ $test = $pkg->resolvable;
+ $it_b = $pool->iterator_incr($it_b);
+ if($test->name eq $ipkg){
+ print "Package found!\n";
+ $tmp = $pkg->status;
+ $tmp->setToBeInstalledUser;
+ $checker = 1;
+ $it_b = $it_e;
+ }
+}
+if($checker eq 0){
+ print "Package not in pdb!\n";
+ print "Check spelling!\n";
+ exit;
+}
+
+$resolver = zypp::Resolver->new($pool);
+
+$it_b = $pool->cBegin;
+if($resolver->resolvePool ne 1){
+ print "Unable to solve the pool!!!\n";
+ print "Problem Description: ";
+ $problems = $resolver->problemDescription;
+ foreach $problem (@$problems){
+ print $problem, "\n";
+ }
+}else{
+ print "These packages has to be installed: \n";
+# while ($it_b ne $pool->end){
+ while ($pool->iterator_equal($it_b, $pool->cEnd) ne 1){
+ $pkg = $pool->iterator_value($it_b);
+ $it_b = $pool->iterator_incr($it_b);
+ $test = $pkg->resolvable;
+ if($pkg->status->isToBeInstalled eq 1){
+ print $test->name, "\n";
+ }
+ }
+}
--- /dev/null
+#!/usr/bin/python
+
+from zypp import ByteCount
+
+print ByteCount(ByteCount.G)
+print ByteCount(ByteCount.GB)
+
+x = ByteCount(ByteCount.K)
+print int(x)
+
--- /dev/null
+#!/usr/bin/python
+
+from zypp import Date
+
+print Date()
+
+d = Date.now()
+print d
+print d.form("%F %T")
+
--- /dev/null
+#!/usr/bin/python
+
+from zypp import TmpDir, RepoManagerOptions, RepoManager, RepoInfo, Url
+
+tmp_root=TmpDir()
+repo_manager = RepoManager(RepoManagerOptions(tmp_root.path()))
+
+repo_info = RepoInfo()
+
+repo_info.setAlias("factorytest")
+repo_info.setName("Test Repo for Factory.")
+repo_info.setEnabled(True)
+repo_info.setAutorefresh(False)
+repo_info.addBaseUrl(Url("file:///tmp/does-not-exist"))
+
+try:
+ repo_manager.addRepository(repo_info)
+ repo_manager.refreshMetadata(repo_info)
+ repo_manager.buildCache(repo_info)
+except RuntimeError, strerror:
+ print "RuntimeError"
+ print strerror
+else:
+ print "Oh, no exception"
+
--- /dev/null
+#! /usr/bin/python
+
+import os, sys, types, string, re
+
+try:
+ import zypp
+except ImportError:
+ print 'Dummy Import Error: Unable to import zypp bindings'
+
+print 'Reading repositories...'
+Z = zypp.ZYppFactory_instance().getZYpp()
+Z.initializeTarget( zypp.Pathname("/") )
+Z.target().load();
+
+repoManager = zypp.RepoManager()
+repos = repoManager.knownRepositories()
+
+for repo in repos:
+ if not repo.enabled():
+ continue
+ if not repoManager.isCached( repo ):
+ repoManager.buildCache( repo )
+ repoManager.loadFromCache( repo );
+print "Items: %d" % ( Z.pool().size() )
+
+#
+# Does not to check and apply updates for the update stack first.
+#
+Z.resolver().resolvePool()
+
+for item in Z.pool():
+ if not zypp.isKindPatch( item ):
+ continue
+ if item.isBroken():
+ if not item.status().setTransact( True, zypp.ResStatus.USER ):
+ raise "Error set transact: %s" % item
+ resolvable = zypp.asKindPatch( item )
+ print '%s | %s-%s | %s | %s' % (resolvable.repoInfo().alias(), resolvable.name(), resolvable.edition(), resolvable.category(), item.status() )
+
+if not Z.resolver().resolvePool():
+ raise "Solver Error"
+
+for item in Z.pool():
+ if item.status().transacts():
+ print '%s | %s-%s | %s' % (item.repoInfo().alias(), item.name(), item.edition(), item.status() )
+
+
+#
+#
+#
+print '===================================================='
+todo = zypp.GetResolvablesToInsDel( Z.pool() )
+for item in todo._toDelete:
+ print '-- %s | %s-%s | %s' % (item.repoInfo().alias(), item.name(), item.edition(), item.status() )
+
+for item in todo._toInstall:
+ print '++ %s | %s-%s | %s' % (item.repoInfo().alias(), item.name(), item.edition(), item.status() )
+
+#
+# dryRun!
+#
+
+policy = zypp.ZYppCommitPolicy()
+policy.dryRun( True )
+policy.syncPoolAfterCommit( False )
+
+result = Z.commit( policy )
+print result
--- /dev/null
+#!/usr/bin/python
+
+# test loading of pywsman
+import sys
+
+# cmake build dir
+sys.path.insert(0, '../../build/swig/python')
+
+from zypp import ZYppFactory, Pathname, KeyRing, PublicKey
+
+
+keyring = ZYppFactory.instance().getZYpp().keyRing()
+
+path = Pathname("/suse/aschnell/tmp/repodata/repomd.xml.key")
+print path
+
+publickey = PublicKey(path)
+print publickey
+
+id = publickey.id()
+
+print "is key known/trusted %s %s" % (keyring.isKeyKnown(id), keyring.isKeyTrusted(id))
+
+keyring.importKey(publickey, True)
+
+print "is key known/trusted %s %s" % (keyring.isKeyKnown(id), keyring.isKeyTrusted(id))
+
+print "list of known keys:"
+for key in keyring.publicKeys():
+ print key
+
+print "list of trusted keys:"
+for key in keyring.trustedPublicKeys():
+ print key
+
--- /dev/null
+#! /usr/bin/python
+import zypp
+
+Z = zypp.ZYppFactory_instance().getZYpp()
+Z.initializeTarget( zypp.Pathname("/") )
+Z.target().load();
+
+repoManager = zypp.RepoManager()
+repos = repoManager.knownRepositories()
+
+for repo in repos:
+ if not repo.enabled():
+ continue
+ if not repoManager.isCached( repo ):
+ repoManager.buildCache( repo )
+ repoManager.loadFromCache( repo );
+
+print "Items: %d" % ( Z.pool().size() )
+
+for item in Z.pool():
+ if item.status().isInstalled():
+ t = "i"
+ else:
+ t = "*"
+
+ print "%s %s:%s-%s.%s\t(%s)" % ( t,
+ item.kind(),
+ item.name(),
+ item.edition(),
+ item.arch(),
+ item.repoInfo().alias() )
+ if zypp.isKindPackage( item ):
+ print " Group: %s" %(zypp.asKindPackage( item ).group( ) )
--- /dev/null
+# test loading of pywsman
+import sys
+
+# cmake build dir
+sys.path.insert(0, '../../build/swig/python')
+
+import zypp
--- /dev/null
+#!/usr/bin/python
+
+from zypp import Url
+
+a = Url("http://www.suse.de/download")
+print "a = %s" % a
+print " %s %s %s" % (a.getScheme(), a.getHost(), a.getPathData())
+
+b = Url(a)
+b.setHost("download.novell.com")
+print "b = %s" % b
+
+c = a # oops
+c.setPathData("/repository")
+print "c = %s" % c
+
+print
+print "a = %s" % a # oops
+print "b = %s" % b
+print "c = %s" % c
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+puts ByteCount.new(ByteCount.G)
+puts ByteCount.new(ByteCount.GB)
+
+x = ByteCount.new(ByteCount.K)
+puts x.to_i
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+tmp_cache_path = TmpDir.new()
+tmp_raw_cache_path = TmpDir.new()
+tmp_known_repos_path = TmpDir.new()
+
+opts = RepoManagerOptions.new()
+opts.repoCachePath = tmp_cache_path.path()
+opts.repoRawCachePath = tmp_raw_cache_path.path()
+opts.knownReposPath = tmp_known_repos_path.path()
+
+repo_manager = RepoManager.new(opts)
+
+repo_info = RepoInfo.new()
+
+repo_info.set_alias("factorytest")
+repo_info.set_name("Test Repo for Factory.")
+repo_info.set_enabled(true)
+repo_info.set_autorefresh(false)
+repo_info.add_base_url(Url.new("file:///tmp/does-not-exist"))
+
+begin
+ repo_manager.add_repository(repo_info)
+ repo_manager.refresh_metadata(repo_info)
+ repo_manager.build_cache(repo_info)
+rescue ZYppException => e
+ puts "ZYppException caught"
+ puts e
+else
+ puts "Oh, no exception"
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+
+keyring = ZYppFactory::instance.get_zypp.key_ring
+
+path = Pathname.new("/suse/aschnell/tmp/repodata/repomd.xml.key")
+puts path
+
+publickey = PublicKey.new(path)
+puts publickey
+
+id = publickey.id()
+
+puts "is key known/trusted #{keyring.is_key_known(id)} #{keyring.is_key_trusted(id)}"
+
+keyring.import_key(publickey, true)
+
+puts "is key known/trusted #{keyring.is_key_known(id)} #{keyring.is_key_trusted(id)}"
+
+puts "list of known keys:"
+keyring.public_keys.each do |key|
+ puts key
+end
+
+puts "list of trusted keys:"
+keyring.trusted_public_keys.each do |key|
+ puts key
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+z = ZYppFactory::instance.get_zypp
+# puts z.class
+
+t = z.initialize_target(Pathname.new("/"))
+# puts t.class
+
+r = z.target.resolvables
+# puts r.class
+
+r.each do | p |
+
+ # puts p.class
+ puts "#{p.kind} #{p.name} #{p.edition.to_s} #{p.arch.to_s}"
+ puts " Summary: #{p.summary}"
+ puts " Size: #{p.size}"
+ puts " Vendor: #{p.vendor}"
+ puts " Buildtime: #{p.buildtime}"
+
+ d = p.dep(Dep.PROVIDES)
+ # puts d.class
+ d.each do | x |
+ # puts x.class
+ puts " Provides: #{x.to_s}"
+ end
+
+ puts
+
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+a = MediaSetAccess.new("http://dist.suse.de/install/stable-x86", "/")
+p = a.provide_file("/content", 1)
+puts p.class
+File.open(p, 'r') do | f |
+ f.each_line do |l|
+ puts l
+ end
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+tmp_cache_path = TmpDir.new()
+tmp_raw_cache_path = TmpDir.new()
+tmp_known_repos_path = TmpDir.new()
+
+opts = RepoManagerOptions.new()
+opts.repoCachePath = tmp_cache_path.path()
+opts.repoRawCachePath = tmp_raw_cache_path.path()
+opts.knownReposPath = tmp_known_repos_path.path()
+
+repo_manager = RepoManager.new(opts)
+
+repo_info = RepoInfo.new()
+
+repo_info.set_alias("factorytest")
+repo_info.set_name("Test Repo for Factory.")
+repo_info.set_enabled(true)
+repo_info.set_autorefresh(false)
+# repo_info.add_base_url("ftp://dist.suse.de/install/stable-x86/")
+# repo_info.add_base_url("http://software.opensuse.org/download/home:/Arvin42/openSUSE_Factory/")
+repo_info.add_base_url("file:///suse/aschnell/tmp")
+
+repo_manager.add_repository(repo_info)
+
+z = ZYppFactory::instance.get_zypp
+pool = z.pool()
+
+repos = repo_manager.known_repositories()
+repos.each do | repo |
+ repo_manager.refresh_metadata(repo)
+ repo_manager.build_cache(repo)
+ rep = repo_manager.create_from_cache(repo)
+ store = rep.resolvables()
+ z.add_resolvables(store)
+end
+
+# puts pool.class
+
+pool.each do | p |
+
+ # puts p.class
+ r = p.resolvable
+ # puts r.class
+ puts "#{r.kind} #{r.name} #{r.edition.to_s} #{r.arch.to_s}"
+ puts " Summary: #{r.summary}"
+ puts " Size: #{r.size}"
+ puts " Vendor: #{r.vendor}"
+ puts " Buildtime: #{r.buildtime}"
+
+ d = r.dep(Dep.PROVIDES)
+ # puts d.class
+ d.each do | x |
+ # puts y.class
+ puts " Provides: #{x.to_s}"
+ end
+
+ puts
+
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+tmp_cache_path = TmpDir.new()
+tmp_raw_cache_path = TmpDir.new()
+tmp_known_repos_path = TmpDir.new()
+
+opts = RepoManagerOptions.new()
+opts.repoCachePath = tmp_cache_path.path()
+opts.repoRawCachePath = tmp_raw_cache_path.path()
+opts.knownReposPath = tmp_known_repos_path.path()
+
+repo_manager = RepoManager.new(opts)
+
+repo_info = RepoInfo.new()
+
+repo_info.set_alias("factorytest")
+repo_info.set_name("Test Repo for Factory.")
+repo_info.set_enabled(true)
+repo_info.set_autorefresh(false)
+# repo_info.add_base_url("ftp://dist.suse.de/install/stable-x86/")
+# repo_info.add_base_url("http://software.opensuse.org/download/home:/Arvin42/openSUSE_Factory/")
+repo_info.add_base_url("file:///suse/aschnell/tmp")
+
+repo_manager.add_repository(repo_info)
+
+res_pool_manager = ResPoolManager.new()
+
+repos = repo_manager.known_repositories()
+repos.each do | repo |
+ repo_manager.refresh_metadata(repo)
+ repo_manager.build_cache(repo)
+ rep = repo_manager.create_from_cache(repo)
+ store = rep.resolvables()
+ res_pool_manager.insert(store)
+end
+
+pool = res_pool_manager.accessor()
+# puts pool.class
+
+pool.each do | p |
+
+ # puts p.class
+ r = p.resolvable
+ # puts r.class
+ puts "#{r.kind} #{r.name} #{r.edition.to_s} #{r.arch.to_s}"
+ puts " Summary: #{r.summary}"
+ puts " Size: #{r.size}"
+ puts " Vendor: #{r.vendor}"
+ puts " Buildtime: #{r.buildtime}"
+
+ d = r.dep(Dep.PROVIDES)
+ # puts d.class
+ d.each do | x |
+ # puts y.class
+ puts " Provides: #{x.to_s}"
+ end
+
+ puts
+
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+z = ZYppFactory::instance.get_zypp
+
+t = z.initialize_target("/")
+r = z.target.resolvables
+puts r.class
+
+p = z.pool
+puts p.class
+
+z.add_resolvables r
+p.each do | pi |
+ puts "a poolitem: #{pi} status: #{pi.status} res: #{pi.resolvable}"
+ puts pi.methods
+ exit
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+a = Arch.new("i386")
+puts a.to_s
+#exit
+
+z = ZYppFactory::instance.get_zypp
+
+manager = RepoManager.new
+
+manager.known_repositories.each do | repo |
+ repo.base_urls.each do | url |
+ puts url.to_s
+ end
+end
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+a = Arch.new("i386")
+puts a.inspect
+#exit
+
+z = ZYppFactory::instance.get_zypp
+
+puts z.inspect
+puts z.architecture.to_s
+
+puts z.home_path
+puts z.home_path.class
+
+t = z.initialize_target("/")
+r = z.target.resolvables
+puts r.class
+r.each do | p |
+ puts "#{p.name} #{p.edition}"
+end
+
+#puts z.methods
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+require 'pathname'
+include Zypp
+
+z = ZYppFactory::instance.get_zypp
+
+#puts z.homePath.class
+#z.setHomePath("/home")
+
+z.initialize_target("/")
+t = z.target
+puts z.target.class
+#r = z.target.resolvables
+puts t.class
+#puts t.methods
+
--- /dev/null
+#!/usr/bin/ruby
+
+require 'zypp'
+include Zypp
+
+a = Url.new("http://www.suse.de/download")
+puts "a = #{a}"
+puts " #{a.get_scheme} #{a.get_host} #{a.get_path_data}"
+
+b = Url.new(a)
+b.set_host("download.novell.com")
+puts "b = #{b}"
+
+c = a # oops
+c.set_path_data("/repository")
+puts "c = #{c}"
+
+puts
+puts "a = #{a}" # oops
+puts "b = #{b}"
+puts "c = #{c}"
+
--- /dev/null
+#! /bin/bash
+
+echo "====Ruby========="
+ruby <<EOF
+ require 'zypp'
+ include Zypp
+ zypp = ZYppFactory::instance.get_zypp
+EOF
+
+echo "====Python======="
+python <<EOF
+import zypp
+zypp = zypp.ZYppFactory.instance().getZYpp()
+EOF
+
+echo "====Perl========="
+perl - <<"EOF"
+ use zypp;
+ $zfactory = zyppc::ZYppFactory_instance();
+ $zypp = $zfactory->getZYpp;
+EOF
\ No newline at end of file
--- /dev/null
+#
+# spec file for package libzypp-bindings
+#
+# Copyright (c) 2011 SUSE LINUX Products GmbH, Nuernberg, Germany.
+ #
+# All modifications and additions to the file contributed by third parties
+# remain the property of their copyright owners, unless otherwise agreed
+# upon. The license for this file, and modifications and additions to the
+# file, is the same license as for the pristine package itself (unless the
+# license for the pristine package is not an Open Source License, in which
+# case the license is the MIT License). An "Open Source License" is a
+# license that conforms to the Open Source Definition (Version 1.9)
+# published by the Open Source Initiative.
+
+# Please submit bugfixes or comments via http://bugs.opensuse.org/
+#
+
+# nodebuginfo
+
+Name: @PACKAGE@
+Version: @VERSION@
+Release: 0
+License: GPLv2+
+Summary: Bindings for libzypp
+Group: Development/Sources
+BuildRoot: %{_tmppath}/%{name}-%{version}-build
+BuildRequires: cmake python-devel ruby-devel
+BuildRequires: gcc-c++ >= 4.5
+BuildRequires: swig >= 1.3.40
+BuildRequires: libzypp-devel >= 10.2.0
+Source: %{name}-%{version}.tar.bz2
+
+%description
+This package provides bindings for libzypp, the library for package management.
+
+%prep
+%setup -q
+
+%build
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=%{prefix} \
+ -DPYTHON_SITEDIR=%{py_sitedir} \
+ -DLIB=%{_lib} \
+ -DCMAKE_VERBOSE_MAKEFILE=TRUE \
+ -DCMAKE_C_FLAGS_RELEASE:STRING="%{optflags}" \
+ -DCMAKE_CXX_FLAGS_RELEASE:STRING="%{optflags}" \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_SKIP_RPATH=1 \
+ ..
+# the swig compile jobs take a lot of memory, so don't use jobs here
+make -j1
+
+%check
+cd build
+make test
+
+%install
+cd build
+make install DESTDIR=$RPM_BUILD_ROOT
+
+%clean
+%{__rm} -rf %{buildroot}
+
+%package -n ruby-zypp
+License: GPLv2+
+Summary: Ruby bindings for libzypp
+Group: Development/Languages/Ruby
+
+%description -n ruby-zypp
+-
+
+%files -n ruby-zypp
+%defattr(-,root,root,-)
+%if 0%{?suse_version}
+%{_libdir}/ruby/vendor_ruby/%{rb_ver}/%{rb_arch}/zypp.so
+%endif
+%if 0%{?mandriva_version}
+%{ruby_sitearchdir}/zypp.so
+%endif
+
+%package -n python-zypp
+License: GPLv2+
+Summary: Python bindings for libzypp
+Group: Development/Languages/Python
+%description -n python-zypp
+-
+
+%files -n python-zypp
+%defattr(-,root,root,-)
+%{py_sitedir}/_zypp.so
+%{py_sitedir}/zypp.py
+
+%package -n perl-zypp
+License: GPLv2+
+Requires: perl = %{perl_version}
+Summary: Perl bindings for libzypp
+Group: Development/Languages/Perl
+
+%description -n perl-zypp
+-
+
+%files -n perl-zypp
+%defattr(-,root,root,-)
+%{perl_vendorlib}/zypp.pm
+%{perl_vendorarch}/zypp.so
+
+%changelog
--- /dev/null
+* Tue Dec 20 2011 Zhang Qiang <qiang.z.zhang@intel.com> - 0.5.9.1
+- depend special version of libzypp for opensuse 11.4 and 11.3
+
+* Mon Oct 24 2011 Zhang Qiang <qiang.z.zhang@intel.com> - 0.5.9
+- Add loadSolvFile API to load solv file
+
+* Sun Sep 18 2011 Zhang Qiang <qiang.z.zhang@intel.com> - 0.5.9
+- Add CapNames to return provides info
+- Add a patch to provide PoolQuery interface.
+
+* Fri Sep 02 2011 Gui Chen <gui.chen@intel.com> - 0.5.9
+- Update to 0.5.9
+
+* Mon Aug 01 2011 Gui Chen <gui.chen@intel.com> - 0.5.8
+- Added armv7tnhl and armv7thl support
+
+* Fri Jan 21 2011 Marko Saukko <marko.saukko@cybercom.com> - 0.5.8
+- Added armv7hl and armv7nhl architectures (BMC#12713)
+
+* Tue Jan 04 2011 Yi Yang <yi.y.yang@intel.com> - 0.5.8
+- Support builtin arm architectures
+
+* Fri Dec 17 2010 Yi Yang <yi.y.yang@intel.com> - 0.5.8
+- Update to 0.5.8
+
+* Thu Nov 25 2010 Yi Yang <yi.y.yang@intel.com> - 0.5.7
+- Update to 0.5.7
+
+* Thu Apr 8 2010 ma@suse.de
+- Adapt to swig 1.3.40
+- version 0.5.4
+* Wed Mar 24 2010 ma@suse.de
+- Work around swig not understanding nested class.
+* Mon Dec 7 2009 ma@suse.de
+- Pass python_sitelib macro from .spec file to cmake.
+- version 0.5.3
+* Tue Nov 24 2009 ma@suse.de
+- Fix to build on sle11-sp1
+* Tue Sep 22 2009 ma@suse.de
+- Remove reference to dead zypp::ScanDBReport.
+- version 0.5.2
+* Sun Aug 9 2009 coolo@novell.com
+- use new python macros
+* Mon Aug 3 2009 ma@suse.de
+- Adappt to boost-1.39
+- version 0.5.1
+* Tue Jul 14 2009 ma@suse.de
+- Fix specfile data.
+* Wed Jun 3 2009 ma@suse.de
+- Bump factory version
+- version 0.5.0
+* Wed Dec 17 2008 ma@suse.de
+- Compile with -fPIC
+- revision 11945
+* Tue Nov 11 2008 ma@suse.de
+- Ignore Pathname operator<.
+- revision 11649
+* Mon Oct 13 2008 ma@suse.de
+- Fix makefile to build.
+- revision 11318
+* Fri Sep 19 2008 ma@suse.de
+- Add KeyRing::DefautAccept
+* Tue Sep 16 2008 dmacvicar@suse.de
+- add ZConfig
+* Fri Sep 5 2008 ma@suse.de
+- Fix basic resolvabe attributes as needed by list_resolvables.py
+ example.
+- revision 10952
+* Thu Sep 4 2008 ma@suse.de
+- Added lost RepoInfo and ServiceInfo.
+- revision 10928
+* Fri Aug 8 2008 ma@suse.de
+- Remove ProductInfo. We don't replace Product.
+- revision 10799
+* Fri Aug 1 2008 ma@suse.de
+- Remove obsolete TranslatedText
+- Add ProductInfo which is going to replace Product
+- revision 10716
+* Thu Jul 31 2008 ma@suse.de
+- Work around undefined symbols in libzypp. (bnc #391831)
+- Adapt to zypp::Service being renamed to ServiceInfo
+- revision 10707
+- version 0.4.7
+* Fri Jul 25 2008 ma@suse.de
+- Removed almost all local copies of zypp header files. This also
+ removed some old classes no longer present in libzypp.
+- Re-enabled building of python and perl bindings. (bnc #391831)
+- revision 10666
+- version 0.4.6
+* Mon Jul 14 2008 ma@suse.de
+- Remove obsolete references to Script/Message/Atom.
+- Remove obsolete references to Dependencies.
+* Tue May 6 2008 coolo@suse.de
+- compile ruby
+* Fri Apr 25 2008 coolo@suse.de
+- remove obsolete ResPool methods
+* Fri Apr 11 2008 coolo@suse.de
+- adapt to libzypp 4.10
+* Thu Apr 3 2008 coolo@suse.de
+- adapt to libzypp 4.7
+* Wed Mar 19 2008 coolo@suse.de
+- adapt to libzypp 4.5
+* Mon Mar 3 2008 schubi@suse.de
+- sat/repo moved to repository
+- Revision 8981
+- version 0.4.5
+* Thu Feb 28 2008 coolo@suse.de
+- fix build
+* Thu Dec 6 2007 aschnell@suse.de
+- readded cmp for ResObject
+* Mon Dec 3 2007 ma@suse.de
+- Add Pool iterator for python.
+* Sat Oct 13 2007 aschnell@suse.de
+- fixed build in beta
+* Thu Oct 4 2007 aschnell@suse.de
+- don't generate a debuginfo package (bug #297711)
+* Mon Sep 17 2007 aschnell@suse.de
+- generate Perl bindings
+- use ZYpp Url class
+* Mon Sep 3 2007 schwab@suse.de
+- Fix broken compiler flags.
+* Thu Aug 30 2007 aschnell@suse.de
+- some work on python bindings
+* Tue Aug 28 2007 aschnell@suse.de
+- added KeyRing and PublicKey classes
+* Thu Aug 23 2007 aschnell@suse.de
+- added to_a functions
+* Thu Aug 23 2007 aschnell@suse.de
+- added some comparison functions
+* Wed Aug 22 2007 aschnell@suse.de
+- renamed ruby module to zypp
+* Fri Aug 17 2007 aschnell@suse.de
+- moved ruby files to vendor_ruby (bug #301127)
+* Mon Aug 13 2007 aschnell@suse.de
+- added exceptions
+* Tue Jul 31 2007 aschnell@suse.de
+- improved bindings for various classes
+- adoptions to libzypp changes
+* Tue Jul 24 2007 aschnell@suse.de
+- added Python bindings
+* Thu Jul 19 2007 aschnell@suse.de
+- New package with swig generated bindings for libzypp
--- /dev/null
+#
+# spec file for package libzypp-bindings
+#
+# Copyright (c) 2007 SUSE LINUX Products GmbH, Nuernberg, Germany.
+# This file and all modifications and additions to the pristine
+# package are under the same license as the package itself.
+#
+# Please submit bugfixes or comments via http://bugs.opensuse.org/
+#
+# nodebuginfo
+%{!?python_sitearch: %define python_sitearch %(%{__python} -c "from distutils.sysconfig import get_python_lib; print get_python_lib(1)")}
+
+Name: libzypp-bindings
+Version: 0.5.10
+Release: 1.3
+License: GPL v2 or later
+Summary: Bindings for libzypp
+Group: Development/Sources
+%if 0%{?suse_version}
+Vendor: openSUSE
+%endif
+Source: %{name}-%{version}.tar.gz
+Patch1: remove-perl-binding.patch
+Patch2: support-armv7-architectures.patch
+Patch3: meego-add-more-class.patch
+
+BuildRequires: cmake gcc-c++ python-devel
+BuildRequires: swig == 1.3.40
+
+BuildRequires: libzypp-devel
+
+BuildRoot: %{_tmppath}/%{name}-%{version}-build
+
+%description
+This package provides bindings for libzypp, the library for package management.
+
+%prep
+%setup -q
+%patch1 -p1
+%patch2 -p1
+%patch3 -p1
+
+%build
+mkdir build
+cd build
+cmake -DCMAKE_INSTALL_PREFIX=%{prefix} \
+ -DPYTHON_SITEDIR=%{python_sitearch} \
+ -DLIB=%{_lib} \
+ -DCMAKE_VERBOSE_MAKEFILE=TRUE \
+ -DCMAKE_C_FLAGS_RELEASE:STRING="%{optflags}" \
+ -DCMAKE_CXX_FLAGS_RELEASE:STRING="%{optflags}" \
+ -DCMAKE_BUILD_TYPE=Release \
+ -DCMAKE_SKIP_RPATH=1 \
+ ..
+make -j1
+
+%install
+cd build
+make install DESTDIR=$RPM_BUILD_ROOT
+
+%clean
+
+%package -n python-zypp
+Summary: Python bindings for libzypp
+Group: Development/Languages/Python
+
+Requires: libzypp
+
+%description -n python-zypp
+Python bindings of libzypp
+
+%files -n python-zypp
+%defattr(-,root,root,-)
+%{python_sitearch}/_zypp.so
+%{python_sitearch}/zypp.py*
--- /dev/null
+diff -uNr libzypp-bindings-0.5.9/swig/PoolQuery.i libzypp-bindings-0.5.9.new/swig/PoolQuery.i
+--- libzypp-bindings-0.5.9/swig/PoolQuery.i 1970-01-01 08:00:00.000000000 +0800
++++ libzypp-bindings-0.5.9.new/swig/PoolQuery.i 2011-10-24 10:42:35.275366767 +0800
+@@ -0,0 +1,39 @@
++%ignore zypp::PoolQuery::operator<<;
++%ignore zypp::detail::operator<<;
++%ignore zypp::dumpOn;
++%ignore zypp::detail::dumpOn;
++%ignore operator<<;
++%include <zypp/PoolQuery.h>
++%include "std_vector.i"
++namespace std {
++ %template(PoolItemVector) vector<zypp::PoolItem>;
++}
++namespace zypp
++{
++ namespace detail
++ {
++ %ignore operator<<;
++ }
++}
++%{
++#include <vector>
++using std::vector;
++%}
++
++#ifdef SWIGPYTHON
++%extend zypp::PoolQuery {
++std::vector<zypp::PoolItem> queryResults (zypp::ResPool pool)
++{
++#define for_(IT,BEG,END) for ( typeof(BEG) IT = BEG; IT != END; ++IT )
++ std::vector<zypp::PoolItem> items;
++ for_(it, self->begin(), self->end())
++ {
++ PoolItem pi(*it);
++ items.push_back(pi);
++ }
++
++ return items;
++}
++}
++#endif
++
+diff -uNr libzypp-bindings-0.5.9/swig/RepoManager.i libzypp-bindings-0.5.9.new/swig/RepoManager.i
+--- libzypp-bindings-0.5.9/swig/RepoManager.i 2011-03-01 20:32:06.000000000 +0800
++++ libzypp-bindings-0.5.9.new/swig/RepoManager.i 2011-10-24 11:24:25.288491255 +0800
+@@ -1 +1,18 @@
+ %include <zypp/RepoManager.h>
++
++#ifdef SWIGPYTHON
++%extend zypp::RepoManager{
++ std::string loadSolvFile(std::string _solv, std::string _alias)
++ {
++ RepoInfo tmpRepo;
++ tmpRepo.setAlias(_alias);
++ try {
++ sat::Pool::instance().addRepoSolv(_solv, tmpRepo);
++ } catch ( const Exception & e ){
++ return e.msg();
++ }
++
++ return std::string();
++ }
++}
++#endif
+diff -uNr libzypp-bindings-0.5.9/swig/RepoType.i libzypp-bindings-0.5.9.new/swig/RepoType.i
+--- libzypp-bindings-0.5.9/swig/RepoType.i 2011-10-24 10:42:10.490366408 +0800
++++ libzypp-bindings-0.5.9.new/swig/RepoType.i 2011-10-24 10:42:35.277366168 +0800
+@@ -1 +1,2 @@
+-%include <zypp/repo/RepoType.h>
+\ No newline at end of file
++%ignore zypp::operator<<;
++%include <zypp/repo/RepoType.h>
+diff -uNr libzypp-bindings-0.5.9/swig/SolvAttr.i libzypp-bindings-0.5.9.new/swig/SolvAttr.i
+--- libzypp-bindings-0.5.9/swig/SolvAttr.i 1970-01-01 08:00:00.000000000 +0800
++++ libzypp-bindings-0.5.9.new/swig/SolvAttr.i 2011-10-24 10:42:35.277366168 +0800
+@@ -0,0 +1,2 @@
++%ignore zypp::sat::SolvAttr::repositoryRevision;
++%include <zypp/sat/SolvAttr.h>
+diff -uNr libzypp-bindings-0.5.9/swig/zypp.i libzypp-bindings-0.5.9.new/swig/zypp.i
+--- libzypp-bindings-0.5.9/swig/zypp.i 2011-10-24 10:42:10.490366408 +0800
++++ libzypp-bindings-0.5.9.new/swig/zypp.i 2011-10-24 10:42:35.277366168 +0800
+@@ -90,6 +90,8 @@
+ #include "zypp/Resolver.h"
+ #include "zypp/pool/GetResolvablesToInsDel.h"
+
++#include "zypp/sat/SolvAttr.h"
++#include "zypp/PoolQuery.h"
+ #include "zypp/Product.h"
+
+ using namespace boost;
+@@ -175,6 +177,7 @@
+ %include "OnMediaLocation.i"
+ %include "Resolvable.i"
+ %include "RepoType.i"
++%include "TmpPath.i"
+ %include "RepoInfo.i"
+ %include "ServiceInfo.i"
+ %include "ResTraits.i"
+@@ -196,9 +199,10 @@
+ %include "ResPool.i"
+ %include "ZYppCommitPolicy.i"
+ %include "ZYppCommitResult.i"
+-%include "TmpPath.i"
+ %include "Resolver.i"
+ %include "ZConfig.i"
++%include "SolvAttr.i"
++%include "PoolQuery.i"
+
+ %ignore zypp::ZYpp::setTextLocale;
+ %ignore zypp::ZYpp::getTextLocale;
--- /dev/null
+diff --git a/swig/CMakeLists.txt b/swig/CMakeLists.txt
+index efa48c4..8b3bc62 100644
+--- a/swig/CMakeLists.txt
++++ b/swig/CMakeLists.txt
+@@ -11,19 +11,8 @@ SET( SWIG_INPUT "${CMAKE_CURRENT_SOURCE_DIR}/zypp.i" )
+ # Let's see which target languages are available
+ #
+
+-FIND_PACKAGE(Ruby)
+ FIND_PACKAGE(PythonLibs)
+-FIND_PACKAGE(Perl)
+
+-
+-IF (RUBY_LIBRARY AND RUBY_INCLUDE_PATH)
+- ADD_SUBDIRECTORY(ruby)
+-ENDIF(RUBY_LIBRARY AND RUBY_INCLUDE_PATH)
+-
+ IF (PYTHON_LIBRARY)
+ ADD_SUBDIRECTORY(python)
+ ENDIF(PYTHON_LIBRARY)
+-
+-IF (PERL_EXECUTABLE)
+- ADD_SUBDIRECTORY(perl5)
+-ENDIF (PERL_EXECUTABLE)
+diff --git a/swig/perl5/CMakeLists.txt b/swig/perl5/CMakeLists.txt
+deleted file mode 100644
+index df226a4..0000000
+--- a/swig/perl5/CMakeLists.txt
++++ /dev/null
+@@ -1,57 +0,0 @@
+-#
+-# CMakeLists.txt for libzypp-bindings/swig/perl5
+-#
+-# !!Attn!!: This creates two files
+-# 1. zypp.so
+-# 2. zypp.pm
+-# and the .pm file gets loaded.
+-#
+-
+-ENABLE_TESTING()
+-ADD_SUBDIRECTORY(tests)
+-
+-# SWIG_OUPUT is per-target
+-SET( SWIG_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libzypp_perl.cc" )
+-
+-EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{cppflags}" OUTPUT_VARIABLE PERL_CXXFLAGS)
+-EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{archlib}.\"/CORE\"" OUTPUT_VARIABLE PERL_CORE_DIR)
+-EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{installvendorarch}" OUTPUT_VARIABLE PERL_VENDOR_ARCH)
+-EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{installvendorlib}" OUTPUT_VARIABLE PERL_VENDOR_LIB)
+-EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{ccdlflags}" OUTPUT_VARIABLE PERL_LINK_FLAGS)
+-
+-MESSAGE(STATUS "Perl executable: ${PERL_EXECUTABLE}")
+-MESSAGE(STATUS "Perl core dir: ${PERL_CORE_DIR}")
+-MESSAGE(STATUS "Perl vendor arch dir: ${PERL_VENDORDIR}")
+-
+-ADD_DEFINITIONS( ${PERL_CXXFLAGS} -Wno-unused -Wno-error )
+-SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${PERL_CXXFLAGS}")
+-
+-LINK_DIRECTORIES( ${PERL_CORE_DIR} )
+-
+-if(COMMAND cmake_policy)
+- cmake_policy(SET CMP0003 NEW)
+-endif(COMMAND cmake_policy)
+-
+-ADD_CUSTOM_COMMAND (
+- OUTPUT ${SWIG_OUTPUT}
+- COMMAND ${CMAKE_COMMAND} -E echo_append "Creating wrapper code for perl..."
+- COMMAND ${SWIG_EXECUTABLE} ${SWIG_DEFINITIONS} -c++ -perl5 -o ${SWIG_OUTPUT} -I${ZYPP_INCLUDE_DIR} ${SWIG_INPUT}
+- COMMAND ${CMAKE_COMMAND} -E echo "Done."
+- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+- DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../*.i ${CMAKE_CURRENT_SOURCE_DIR}/../*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.i
+-)
+-
+-ADD_LIBRARY( zypp_perl SHARED ${SWIG_OUTPUT} )
+-SET_TARGET_PROPERTIES( zypp_perl
+- PROPERTIES
+- PREFIX ""
+- OUTPUT_NAME zypp
+-)
+-
+-INCLUDE_DIRECTORIES( ${PERL_CORE_DIR} )
+-INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/swig )
+-INCLUDE_DIRECTORIES( ${ZYPP_INCLUDE_DIR} )
+-TARGET_LINK_LIBRARIES( zypp_perl ${ZYPP_LIBRARY} )
+-
+-INSTALL(TARGETS zypp_perl LIBRARY DESTINATION ${PERL_VENDOR_ARCH})
+-INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/zypp.pm DESTINATION ${PERL_VENDOR_LIB})
+diff --git a/swig/perl5/perl.i b/swig/perl5/perl.i
+deleted file mode 100644
+index 8c60f30..0000000
+--- a/swig/perl5/perl.i
++++ /dev/null
+@@ -1,91 +0,0 @@
+-
+-%ignore zypp::Arch_empty;
+-
+-namespace zypp
+-{
+- // These operators must be ignored otherwise the wrapper does
+- // not compile (using swig 1.3.29).
+- %ignore operator<<;
+- %ignore operator==;
+- %ignore operator!=;
+-
+- namespace filesystem
+- {
+- // Same as above.
+- %ignore operator==;
+- %ignore operator!=;
+- %ignore operator<<;
+- }
+-}
+-
+-%define iter(cls, storetype)
+-%extend cls {
+- cls::const_iterator iterator_incr(cls::const_iterator *it){
+- (*it)++;
+- return *it;
+- }
+- cls::const_iterator iterator_decr(cls::const_iterator *it){
+- (*it)--;
+- return *it;
+- }
+- bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+- return (it1 == it2);
+- }
+- storetype iterator_value(cls::const_iterator it) {
+- return (&**it);
+- }
+- cls::const_iterator cBegin() {
+- return self->begin();
+- }
+- cls::const_iterator cEnd() {
+- return self->end();
+- }
+-};
+-%enddef
+-
+-%define iter2(cls, storetype)
+-%extend cls {
+- cls::const_iterator iterator_incr(cls::const_iterator *it){
+- ++(*it);
+- return *it;
+- }
+- cls::const_iterator iterator_decr(cls::const_iterator *it){
+- --(*it);
+- return *it;
+- }
+- bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+- return (it1 == it2);
+- }
+- storetype iterator_value(cls::const_iterator it) {
+- return (*it);
+- }
+- cls::const_iterator cBegin() {
+- return self->begin();
+- }
+- cls::const_iterator cEnd() {
+- return self->end();
+- }
+-};
+-%enddef
+-
+-// no operator--
+-%define forwarditer(cls, storetype)
+-%extend cls {
+- cls::const_iterator iterator_incr(cls::const_iterator *it){
+- ++(*it);
+- return *it;
+- }
+- bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+- return (it1 == it2);
+- }
+- storetype iterator_value(cls::const_iterator it) {
+- return (*it);
+- }
+- cls::const_iterator cBegin() {
+- return self->begin();
+- }
+- cls::const_iterator cEnd() {
+- return self->end();
+- }
+-};
+-%enddef
+diff --git a/swig/perl5/tests/CMakeLists.txt b/swig/perl5/tests/CMakeLists.txt
+deleted file mode 100644
+index af6e7a7..0000000
+--- a/swig/perl5/tests/CMakeLists.txt
++++ /dev/null
+@@ -1,8 +0,0 @@
+-#
+-# CMakeLists.txt for libzypp-bindings/swig/perl5/tests
+-#
+-
+-ENABLE_TESTING()
+-
+-ADD_TEST(bindings_perl_loading perl ${CMAKE_CURRENT_SOURCE_DIR}/loading.pl)
+-ADD_TEST(bindings_perl_starting perl ${CMAKE_CURRENT_SOURCE_DIR}/starting.pl)
+diff --git a/swig/perl5/tests/loading.pl b/swig/perl5/tests/loading.pl
+deleted file mode 100644
+index 0f45c2d..0000000
+--- a/swig/perl5/tests/loading.pl
++++ /dev/null
+@@ -1,7 +0,0 @@
+-#!/usr/bin/perl
+-
+-use FindBin qw($Bin);
+-use lib "$Bin/../../../build/swig/perl5";
+-
+-use zypp;
+-
+diff --git a/swig/perl5/tests/starting.pl b/swig/perl5/tests/starting.pl
+deleted file mode 100644
+index 09d3954..0000000
+--- a/swig/perl5/tests/starting.pl
++++ /dev/null
+@@ -1,9 +0,0 @@
+-#!/usr/bin/perl
+-
+-use FindBin qw($Bin);
+-use lib "$Bin/../../../build/swig/perl5";
+-
+-use zypp;
+-
+-$zfactory = zyppc::ZYppFactory_instance();
+-$zypp = $zfactory->getZYpp;
+diff --git a/swig/ruby/CMakeLists.txt b/swig/ruby/CMakeLists.txt
+deleted file mode 100644
+index 08d6329..0000000
+--- a/swig/ruby/CMakeLists.txt
++++ /dev/null
+@@ -1,62 +0,0 @@
+-#
+-# CMakeLists.txt for libzypp-bindings/swig/ruby
+-#
+-
+-ENABLE_TESTING()
+-ADD_SUBDIRECTORY(tests)
+-
+-# SWIG_OUPUT is per-target
+-
+-SET( SWIG_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libzypp_ruby.cc" )
+-
+-MESSAGE(STATUS "Ruby executable: ${RUBY_EXECUTABLE}")
+-MESSAGE(STATUS "Ruby vendor arch dir: ${RUBY_VENDORARCH_DIR}")
+-MESSAGE(STATUS "Ruby include path: ${RUBY_INCLUDE_PATH}")
+-
+-ADD_CUSTOM_COMMAND (
+- OUTPUT "${SWIG_OUTPUT}"
+- COMMAND ${CMAKE_COMMAND} -E echo_append "Creating wrapper code for Ruby..."
+- COMMAND ${SWIG_EXECUTABLE} ${SWIG_DEFINITIONS} -c++ -ruby -o ${SWIG_OUTPUT} -I${ZYPP_INCLUDE_DIR} ${SWIG_INPUT}
+- COMMAND ${CMAKE_COMMAND} -E echo "Done."
+- WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+- DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../*.i ${CMAKE_CURRENT_SOURCE_DIR}/../*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.i
+-)
+-
+-ADD_LIBRARY( zypp_ruby SHARED ${SWIG_OUTPUT} )
+-
+-# name it 'zypp.so'
+-# and don't prefix with 'lib'
+-SET_TARGET_PROPERTIES( zypp_ruby PROPERTIES OUTPUT_NAME "zypp" PREFIX "" )
+-
+-INCLUDE_DIRECTORIES( ${RUBY_INCLUDE_PATH} )
+-INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/swig )
+-INCLUDE_DIRECTORIES( ${ZYPP_INCLUDE_DIR} )
+-
+-TARGET_LINK_LIBRARIES( zypp_ruby ${RUBY_LIBRARY} )
+-TARGET_LINK_LIBRARIES( zypp_ruby ${ZYPP_LIBRARY} )
+-
+-INSTALL(TARGETS zypp_ruby LIBRARY DESTINATION ${RUBY_VENDORARCH_DIR})
+-
+-#
+-# Generate HTML documentation with rdoc
+-#
+-# This requires rdoc-swig from https://github.com/kkaempf/rdoc-swig
+-#
+-
+-IF(EXISTS ${CMAKE_SOURCE_DIR}/swig/ruby/rdoc)
+-SET(rdoc_dir "${CMAKE_CURRENT_BINARY_DIR}/html")
+-ADD_CUSTOM_COMMAND (
+- OUTPUT ${rdoc_dir}
+- COMMAND ${CMAKE_COMMAND} -E echo_append "Creating rdoc documentation ..."
+- COMMAND rm -rf ${rdoc_dir}
+- COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/rdoc -o ${rdoc_dir} zypp.i *.i ruby/*.i
+- COMMAND ${CMAKE_COMMAND} -E echo "Done."
+- WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/swig
+- DEPENDS ${CMAKE_SOURCE_DIR}/swig/*.i ${CMAKE_SOURCE_DIR}/swig/ruby/*.rb ${CMAKE_SOURCE_DIR}/swig/ruby/*.i
+-)
+-ADD_CUSTOM_TARGET(ruby_rdoc ALL DEPENDS "${rdoc_dir}")
+-ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/swig/ruby/rdoc)
+-
+-#
+-# Leave this to %doc in the .spec file
+-#INSTALL(DIRECTORY "${rdoc_dir}" DESTINATION ${DOC_INSTALL_DIR})
+diff --git a/swig/ruby/ruby.i b/swig/ruby/ruby.i
+deleted file mode 100644
+index d2d3025..0000000
+--- a/swig/ruby/ruby.i
++++ /dev/null
+@@ -1,125 +0,0 @@
+-
+-%rename *::asString "to_s";
+-
+-namespace zypp
+-{
+- // Not ignoring gives a very strange error in the "pokus" testsuite: SWIG
+- // defines a Ruby module-function "==" which (when included into the main
+- // namespace) is apparently used where is should not.
+- %ignore operator==;
+-
+- // Just to avoid warnings.
+- %ignore operator!=;
+- %ignore operator<<;
+-
+- namespace filesystem
+- {
+- // Same as above.
+- %ignore operator==;
+- %ignore operator!=;
+- %ignore operator<<;
+- }
+-
+-}
+-
+-/*
+- * Extend cls with an ruby-like each iterator and a to_a method. Yields
+- * objects of type storetype. Parameter storetype must be a pointer type.
+- */
+-#define iter2(cls, storetype) \
+-%mixin cls "Enumerable"; \
+-%extend cls \
+-{ \
+- void each() { \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const storetype tmp = &**i; \
+- rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+- i++; \
+- } \
+- } \
+-\
+- VALUE to_a() { \
+- VALUE ary = rb_ary_new(); \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const storetype tmp = &**i; \
+- rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+- i++; \
+- } \
+- return ary; \
+- } \
+-}
+-
+-
+-/*
+- * Like iter2, but does only one dereferencing from the iterator.
+- */
+-#define iter3(cls, storetype) \
+-%mixin cls "Enumerable"; \
+-%extend cls \
+-{ \
+- void each() { \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const storetype tmp = &*i; \
+- rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+- i++; \
+- } \
+- } \
+-\
+- VALUE to_a() { \
+- VALUE ary = rb_ary_new(); \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const storetype tmp = &*i; \
+- rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+- i++; \
+- } \
+- return ary; \
+- } \
+-}
+-
+-/*
+- * This is for an iterator whichs operator* returns by value (i.e. a temporary).
+- * Like e.g. the Capabilities::const_iterator does. If the compiler warns you are
+- * taking the address of a temporary when using iter3, you most probaly need this one.
+- *
+- */
+-#define by_value_iterator(cls) \
+-%mixin cls "Enumerable"; \
+-%extend cls \
+-{ \
+- void each() { \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const cls::value_type* tmp = new cls::value_type( *i ); \
+- rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(cls::value_type*), 1)); \
+- i++; \
+- } \
+- } \
+-\
+- VALUE to_a() { \
+- VALUE ary = rb_ary_new(); \
+- cls::const_iterator i = self->begin(); \
+- while (i != self->end()) { \
+- const cls::value_type* tmp = new cls::value_type( *i ); \
+- rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(cls::value_type*), 1)); \
+- i++; \
+- } \
+- return ary; \
+- } \
+-}
+-
+-%exception
+-{
+- try {
+- $action
+- }
+- catch (const Exception& e) {
+- static VALUE zyppexception = rb_define_class("ZYppException", rb_eStandardError);
+- std::string tmp = e.historyAsString() + e.asUserString();
+- rb_raise(zyppexception, tmp.c_str());
+- }
+-}
+-
+diff --git a/swig/ruby/std_list.i b/swig/ruby/std_list.i
+deleted file mode 100644
+index f6d36e6..0000000
+--- a/swig/ruby/std_list.i
++++ /dev/null
+@@ -1,533 +0,0 @@
+-/* -----------------------------------------------------------------------------
+- * See the LICENSE file for information on copyright, usage and redistribution
+- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+- *
+- * std_list.i
+- *
+- * SWIG typemaps for std::list
+- * ----------------------------------------------------------------------------- */
+-
+-%include <std_common.i>
+-
+-// ------------------------------------------------------------------------
+-// std::list
+-//
+-// The aim of all that follows would be to integrate std::list with
+-// Ruby as much as possible, namely, to allow the user to pass and
+-// be returned Ruby arrays
+-// const declarations are used to guess the intent of the function being
+-// exported; therefore, the following rationale is applied:
+-//
+-// -- f(std::list<T>), f(const std::list<T>&), f(const std::list<T>*):
+-// the parameter being read-only, either a Ruby array or a
+-// previously wrapped std::list<T> can be passed.
+-// -- f(std::list<T>&), f(std::list<T>*):
+-// the parameter must be modified; therefore, only a wrapped std::list
+-// can be passed.
+-// -- std::list<T> f():
+-// the list is returned by copy; therefore, a Ruby array of T:s
+-// is returned which is most easily used in other Ruby functions
+-// -- std::list<T>& f(), std::list<T>* f(), const std::list<T>& f(),
+-// const std::list<T>* f():
+-// the list is returned by reference; therefore, a wrapped std::list
+-// is returned
+-// ------------------------------------------------------------------------
+-
+-%{
+-#include <list>
+-#include <algorithm>
+-#include <stdexcept>
+-%}
+-
+-// exported class
+-
+-namespace std {
+-
+- %mixin list "Enumerable";
+-
+- template<class T> class list {
+- %typemap(in) list<T> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- $1.push_back(*x);
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const list<T>& (std::list<T> temp),
+- const list<T>* (std::list<T> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- temp.push_back(*x);
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+-
+- void each() {
+- for ( std::list<T>::const_iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+-
+-
+- %typemap(out) list<T> {
+- $result = rb_ary_new2($1.size());
+- unsigned int i = 0;
+- for ( std::list<T>::iterator it = $1.begin();
+- it != $1.end();
+- ++it )
+- {
+- T* x = new T((*it));
+- rb_ary_store($result,i,
+- SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 1));
+- ++i;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) list<T> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const list<T>&,
+- const list<T>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- list();
+- list(unsigned int size);
+- list(unsigned int size, const T& value);
+- list(const list<T> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) push_back;
+- void push_back(const T& x);
+- %extend {
+- /*
+- T pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty list");
+- T x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T& __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- void __setitem__(int i, const T& x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- */
+- void each() {
+- for ( std::list<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+-
+- // Partial specialization for lists of pointers. [ beazley ]
+-
+- %mixin list<T*> "Enumerable";
+- template<class T> class list<T*> {
+- %typemap(in) list<T*> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = std::list<T* >(size);
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- (($1_type &)$1)[i] = x;
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const list<T*>& (std::list<T*> temp),
+- const list<T*>* (std::list<T*> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- temp = std::list<T* >(size);
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- temp[i] = x;
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+- %typemap(out) list<T*> {
+- $result = rb_ary_new2($1.size());
+- for (unsigned int i=0; i<$1.size(); i++) {
+- T* x = (($1_type &)$1)[i];
+- rb_ary_store($result,i,
+- SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) list<T*> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T* >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const list<T*>&,
+- const list<T*>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T* >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- list();
+- list(unsigned int size);
+- list(unsigned int size, T * &value);
+- list(const list<T*> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) push_back;
+- void push_back(T* x);
+- %extend {
+- /*
+- T* pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty list");
+- T* x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T* __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- void __setitem__(int i, T* x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- */
+- void each() {
+- for ( std::list<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+-
+-
+- // specializations for built-ins
+-
+- %define specialize_std_list(T,CHECK,CONVERT_FROM,CONVERT_TO)
+- %mixin list<T> "Enumerable";
+- template<> class list<T> {
+- %typemap(in) list<T> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = std::list<T >(size);
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- if (CHECK(o))
+- (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+- else
+- rb_raise(rb_eTypeError,
+- "wrong argument type"
+- " (expected list<" #T ">)");
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const list<T>& (std::list<T> temp),
+- const list<T>* (std::list<T> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- temp = std::list<T >(size);
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- if (CHECK(o))
+- temp[i] = (T)(CONVERT_FROM(o));
+- else
+- rb_raise(rb_eTypeError,
+- "wrong argument type"
+- " (expected list<" #T ">)");
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+- %typemap(out) list<T> {
+- $result = rb_ary_new2($1.size());
+- for (unsigned int i=0; i<$1.size(); i++)
+- rb_ary_store($result,i,CONVERT_TO((($1_type &)$1)[i]));
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) list<T> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- VALUE o = RARRAY($input)->ptr[0];
+- if (CHECK(o))
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const list<T>&,
+- const list<T>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- VALUE o = RARRAY($input)->ptr[0];
+- if (CHECK(o))
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped list? */
+- std::list<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- list();
+- list(unsigned int size);
+- list(unsigned int size, const T& value);
+- list(const list<T> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) push_back;
+- void push_back(T x);
+- %extend {
+- /*
+- T pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty list");
+- T x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- void __setitem__(int i, T x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("list index out of range");
+- }
+- */
+- void each() {
+- for ( std::list<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+- %enddef
+-
+- specialize_std_list(bool,SWIG_BOOL_P,SWIG_RB2BOOL,SWIG_BOOL2RB);
+- specialize_std_list(char,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(int,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(short,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(long,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(unsigned char,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(unsigned int,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(unsigned short,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(unsigned long,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_list(double,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+- specialize_std_list(float,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+- specialize_std_list(std::string,SWIG_STRING_P,SWIG_RB2STR,SWIG_STR2RB);
+-
+-}
+-
+diff --git a/swig/ruby/std_set.i b/swig/ruby/std_set.i
+deleted file mode 100644
+index af2a146..0000000
+--- a/swig/ruby/std_set.i
++++ /dev/null
+@@ -1,527 +0,0 @@
+-/* -----------------------------------------------------------------------------
+- * See the LICENSE file for information on copyright, usage and redistribution
+- * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+- *
+- * std_set.i
+- *
+- * SWIG typemaps for std::set
+- * ----------------------------------------------------------------------------- */
+-
+-%include <std_common.i>
+-
+-// ------------------------------------------------------------------------
+-// std::set
+-//
+-// The aim of all that follows would be to integrate std::set with
+-// Ruby as much as possible, namely, to allow the user to pass and
+-// be returned Ruby arrays
+-// const declarations are used to guess the intent of the function being
+-// exported; therefore, the following rationale is applied:
+-//
+-// -- f(std::set<T>), f(const std::set<T>&), f(const std::set<T>*):
+-// the parameter being read-only, either a Ruby array or a
+-// previously wrapped std::set<T> can be passed.
+-// -- f(std::set<T>&), f(std::set<T>*):
+-// the parameter must be modified; therefore, only a wrapped std::set
+-// can be passed.
+-// -- std::set<T> f():
+-// the set is returned by copy; therefore, a Ruby array of T:s
+-// is returned which is most easily used in other Ruby functions
+-// -- std::set<T>& f(), std::set<T>* f(), const std::set<T>& f(),
+-// const std::set<T>* f():
+-// the set is returned by reference; therefore, a wrapped std::set
+-// is returned
+-// ------------------------------------------------------------------------
+-
+-%{
+-#include <set>
+-#include <algorithm>
+-#include <stdexcept>
+-%}
+-
+-// exported class
+-
+-namespace std {
+-
+- %mixin set "Enumerable";
+-
+- template<class T> class set {
+- %typemap(in) set<T> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- $1.insert(*x);
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const set<T>& (std::set<T> temp),
+- const set<T>* (std::set<T> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- temp.insert(*x);
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+-
+- void each() {
+- for ( std::set<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = (T *) &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+-
+-
+- %typemap(out) set<T> {
+- $result = rb_ary_new2($1.size());
+- unsigned int i = 0;
+- for ( std::set<T>::iterator it = $1.begin();
+- it != $1.end();
+- ++it )
+- {
+- T* x = new T((*it));
+- rb_ary_store($result,i,
+- SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 1));
+- ++i;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) set<T> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const set<T>&,
+- const set<T>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- set();
+- set(const set<T> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) insert;
+- void insert(const T& x);
+- %extend {
+- /*
+- T pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty set");
+- T x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T& __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- void __setitem__(int i, const T& x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- */
+- void each() {
+- for ( std::set<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = (T *)&(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+-
+- // Partial specialization for sets of pointers. [ beazley ]
+-
+- %mixin set<T*> "Enumerable";
+- template<class T> class set<T*> {
+- %typemap(in) set<T*> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = std::set<T* >(size);
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- (($1_type &)$1)[i] = x;
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const set<T*>& (std::set<T*> temp),
+- const set<T*>* (std::set<T*> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- temp = std::set<T* >(size);
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- T* x;
+- SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+- temp[i] = x;
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+- %typemap(out) set<T*> {
+- $result = rb_ary_new2($1.size());
+- for (unsigned int i=0; i<$1.size(); i++) {
+- T* x = (($1_type &)$1)[i];
+- rb_ary_store($result,i,
+- SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) set<T*> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T* >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const set<T*>&,
+- const set<T*>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- T* x;
+- VALUE o = RARRAY($input)->ptr[0];
+- if ((SWIG_ConvertPtr(o,(void **) &x,
+- $descriptor(T *),0)) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T* >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- set();
+- set(const set<T*> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) insert;
+- void insert(T* x);
+- %extend {
+- /*
+- T* pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty set");
+- T* x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T* __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- void __setitem__(int i, T* x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- */
+- void each() {
+- for ( std::set<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = (T*) &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+-
+-
+- // specializations for built-ins
+-
+- %define specialize_std_set(T,CHECK,CONVERT_FROM,CONVERT_TO)
+- %mixin set<T> "Enumerable";
+- template<> class set<T> {
+- %typemap(in) set<T> {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- $1 = std::set<T >(size);
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- if (CHECK(o))
+- (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+- else
+- rb_raise(rb_eTypeError,
+- "wrong argument type"
+- " (expected set<" #T ">)");
+- }
+- } else {
+- void *ptr;
+- SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+- $1 = *(($&1_type) ptr);
+- }
+- }
+- %typemap(in) const set<T>& (std::set<T> temp),
+- const set<T>* (std::set<T> temp) {
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- temp = std::set<T >(size);
+- $1 = &temp;
+- for (unsigned int i=0; i<size; i++) {
+- VALUE o = RARRAY($input)->ptr[i];
+- if (CHECK(o))
+- temp[i] = (T)(CONVERT_FROM(o));
+- else
+- rb_raise(rb_eTypeError,
+- "wrong argument type"
+- " (expected set<" #T ">)");
+- }
+- } else {
+- SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+- }
+- }
+- %typemap(out) set<T> {
+- $result = rb_ary_new2($1.size());
+- for (unsigned int i=0; i<$1.size(); i++)
+- rb_ary_store($result,i,CONVERT_TO((($1_type &)$1)[i]));
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) set<T> {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- VALUE o = RARRAY($input)->ptr[0];
+- if (CHECK(o))
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $&1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- %typecheck(SWIG_TYPECHECK_VECTOR) const set<T>&,
+- const set<T>* {
+- /* native sequence? */
+- if (rb_obj_is_kind_of($input,rb_cArray)) {
+- unsigned int size = RARRAY($input)->len;
+- if (size == 0) {
+- /* an empty sequence can be of any type */
+- $1 = 1;
+- } else {
+- /* check the first element only */
+- VALUE o = RARRAY($input)->ptr[0];
+- if (CHECK(o))
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- } else {
+- /* wrapped set? */
+- std::set<T >* v;
+- if (SWIG_ConvertPtr($input,(void **) &v,
+- $1_descriptor,0) != -1)
+- $1 = 1;
+- else
+- $1 = 0;
+- }
+- }
+- public:
+- set();
+- set(const set<T> &);
+-
+- %rename(__len__) size;
+- unsigned int size() const;
+- %rename("empty?") empty;
+- bool empty() const;
+- void clear();
+- %rename(push) insert;
+- void insert(T x);
+- %extend {
+- /*
+- T pop() throw (std::out_of_range) {
+- if (self->size() == 0)
+- throw std::out_of_range("pop from empty set");
+- T x = self->back();
+- self->pop_back();
+- return x;
+- }
+- T __getitem__(int i) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i += size;
+- if (i>=0 && i<size)
+- return (*self)[i];
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- void __setitem__(int i, T x) throw (std::out_of_range) {
+- int size = int(self->size());
+- if (i<0) i+= size;
+- if (i>=0 && i<size)
+- (*self)[i] = x;
+- else
+- throw std::out_of_range("set index out of range");
+- }
+- */
+- void each() {
+- for ( std::set<T>::iterator it = self->begin();
+- it != self->end();
+- ++it )
+- {
+- T* x = &(*it);
+- rb_yield(SWIG_NewPointerObj((void *) x,
+- $descriptor(T *), 0));
+- }
+- }
+- }
+- };
+- %enddef
+-
+- specialize_std_set(bool,SWIG_BOOL_P,SWIG_RB2BOOL,SWIG_BOOL2RB);
+- specialize_std_set(char,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(int,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(short,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(long,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(unsigned char,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(unsigned int,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(unsigned short,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(unsigned long,FIXNUM_P,FIX2INT,INT2NUM);
+- specialize_std_set(double,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+- specialize_std_set(float,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+- specialize_std_set(std::string,SWIG_STRING_P,SWIG_RB2STR,SWIG_STR2RB);
+-
+-}
+-
+diff --git a/swig/ruby/tests/CMakeLists.txt b/swig/ruby/tests/CMakeLists.txt
+deleted file mode 100644
+index 3b084df..0000000
+--- a/swig/ruby/tests/CMakeLists.txt
++++ /dev/null
+@@ -1,11 +0,0 @@
+-#
+-# CMakeLists.txt for libzypp-bindings/swig/ruby/tests
+-#
+-
+-ENABLE_TESTING()
+-
+-ADD_TEST(bindings_ruby_loading ruby -C ${CMAKE_CURRENT_SOURCE_DIR} loading.rb)
+-ADD_TEST(bindings_ruby_arch.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} arch.rb)
+-ADD_TEST(bindings_ruby_bytecount.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} bytecount.rb)
+-ADD_TEST(bindings_ruby_starting.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} starting.rb)
+-ADD_TEST(bindings_ruby_target.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} target.rb)
+diff --git a/swig/ruby/tests/arch.rb b/swig/ruby/tests/arch.rb
+deleted file mode 100644
+index 3e2f508..0000000
+--- a/swig/ruby/tests/arch.rb
++++ /dev/null
+@@ -1,55 +0,0 @@
+-#
+-# Arch
+-#
+-
+-$:.unshift File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","build","swig","ruby"))
+-
+-require 'test/unit'
+-require 'zypp'
+-
+-class Zypp::Arch
+- include Comparable
+-end
+-
+-class ArchTest < Test::Unit::TestCase
+- include Zypp
+- def test_arch
+- # define i386, a builtin
+-
+- a = Arch.new("i386")
+- assert a
+- assert_equal "i386", a.to_s
+- assert_equal true, a.is_builtin
+-
+- # i486 is 'bigger' than i386
+-
+- b = Arch.new("i486")
+- assert b
+- assert_equal "i486", b.to_s
+- assert b.is_builtin
+- if VERSION > 800
+- assert_equal a, b.base_arch
+- end
+- assert a < b
+- assert a.compatible_with?(b)
+-
+- # A new, adventurous architecture
+- z = Arch.new("xyzzy")
+- assert z
+- assert_equal "xyzzy", z.to_s
+- assert_equal false, z.is_builtin
+-
+- # predefined archs
+- assert_equal Arch.new("noarch"), Arch.noarch
+- assert_equal a, Arch.i386
+- assert_equal b, Arch.i486
+- assert_equal Arch.new("i586"), Arch.i586
+- assert_equal Arch.new("i686"), Arch.i686
+- assert_equal Arch.new("x86_64"), Arch.x86_64
+- assert_equal Arch.new("ia64"), Arch.ia64
+- assert_equal Arch.new("ppc"), Arch.ppc
+- assert_equal Arch.new("ppc64"), Arch.ppc64
+- assert_equal Arch.new("s390"), Arch.s390
+- assert_equal Arch.new("s390x"), Arch.s390x
+- end
+-end
+diff --git a/swig/ruby/tests/bytecount.rb b/swig/ruby/tests/bytecount.rb
+deleted file mode 100644
+index 5b46e14..0000000
+--- a/swig/ruby/tests/bytecount.rb
++++ /dev/null
+@@ -1,25 +0,0 @@
+-#
+-# Test Bytecount
+-#
+-
+-$:.unshift "../../../build/swig/ruby"
+-
+-
+-# test loading of extension
+-require 'test/unit'
+-
+-class LoadTest < Test::Unit::TestCase
+- require 'zypp'
+- include Zypp
+-
+- def test_bytecount
+- g = ByteCount.new(ByteCount.G)
+- assert g
+- gb = ByteCount.new(ByteCount.GB)
+- assert gb
+- k = ByteCount.new(ByteCount.K)
+- assert k.to_i == 1024
+- mb = ByteCount.new(ByteCount.MB)
+- assert mb.to_i == 1000*1000
+- end
+-end
+diff --git a/swig/ruby/tests/commit_callbacks.rb b/swig/ruby/tests/commit_callbacks.rb
+deleted file mode 100644
+index 74767ce..0000000
+--- a/swig/ruby/tests/commit_callbacks.rb
++++ /dev/null
+@@ -1,46 +0,0 @@
+-#
+-# Test commit callbacks
+-#
+-
+-$:.unshift "../../../build/swig/ruby"
+-
+-
+-require 'test/unit'
+-require 'zypp'
+-
+-class CommitReceiver
+- # Define class function, we pass the class (not an instance of the class)
+- # to the CommitCallbacks
+- def self.removal_start resolvable
+- $stderr.puts "Starting to remove #{resolvable}"
+- end
+-end
+-
+-class CommitCallbacksTest < Test::Unit::TestCase
+- def test_removal_callback
+- commit_callbacks = Zypp::CommitCallbacks.new
+- assert_equal nil, commit_callbacks.receiver
+- # In Ruby the class is also an object, so we connect to the class
+- commit_callbacks.connect CommitReceiver
+- assert_equal CommitReceiver, commit_callbacks.receiver
+-
+- z = Zypp::ZYppFactory::instance.getZYpp
+-
+- z.initializeTarget(Zypp::Pathname.new("/"))
+- t = z.target
+- t.load
+- t.buildCache
+-
+- emitter = Zypp::CommitCallbacksEmitter.new
+- p = z.pool
+- p.each do |item|
+- puts "Emitting removal of ", item
+- puts item.methods.inspect
+- emitter.remove_start(item)
+- break
+- end
+-
+- commit_callbacks.disconnect
+- assert_equal nil, commit_callbacks.receiver
+- end
+-end
+diff --git a/swig/ruby/tests/loading.rb b/swig/ruby/tests/loading.rb
+deleted file mode 100644
+index 01ae25a..0000000
+--- a/swig/ruby/tests/loading.rb
++++ /dev/null
+@@ -1,16 +0,0 @@
+-#
+-# Test loading of the bindings
+-#
+-
+-$:.unshift "../../../build/swig/ruby"
+-
+-
+-# test loading of extension
+-require 'test/unit'
+-
+-class LoadTest < Test::Unit::TestCase
+- def test_loading
+- require 'zypp'
+- assert true
+- end
+-end
+diff --git a/swig/ruby/tests/starting.rb b/swig/ruby/tests/starting.rb
+deleted file mode 100644
+index 5f3afb2..0000000
+--- a/swig/ruby/tests/starting.rb
++++ /dev/null
+@@ -1,22 +0,0 @@
+-#
+-# Test starting of zypp
+-#
+-
+-$:.unshift "../../../build/swig/ruby"
+-
+-
+-# test loading of extension
+-require 'test/unit'
+-
+-class LoadTest < Test::Unit::TestCase
+- def test_loading
+- require 'zypp'
+- zypp = Zypp::ZYppFactory::instance.getZYpp
+- assert zypp
+- zconfig = Zypp::ZConfig::instance
+- assert zconfig
+- puts zconfig.systemArchitecture
+- zconfig.setSystemArchitecture(Zypp::Arch.new("i686"))
+- puts zconfig.systemArchitecture
+- end
+-end
+diff --git a/swig/ruby/tests/target.rb b/swig/ruby/tests/target.rb
+deleted file mode 100644
+index cfecfff..0000000
+--- a/swig/ruby/tests/target.rb
++++ /dev/null
+@@ -1,44 +0,0 @@
+-#
+-# Example for target
+-#
+-
+-$:.unshift "../../../build/swig/ruby"
+-
+-
+-# test loading of extension
+-require 'test/unit'
+-
+-class LoadTest < Test::Unit::TestCase
+- require 'zypp'
+- include Zypp
+- def test_target
+- z = ZYppFactory::instance.getZYpp
+-
+- assert z.homePath
+- assert z.tmpPath
+-
+- z.initializeTarget(Zypp::Pathname.new("/"))
+- t = z.target
+- assert t
+- t.load
+- t.buildCache
+-
+- p = z.pool
+- assert p
+- assert p.size > 0
+-
+- # Iterate over pool, gives PoolItems
+- i = 0
+- puts "#{p.size} PoolItems:"
+- p.each do | pi |
+- i = i + 1
+- break if i > 10
+- puts pi
+- # PoolItems have status and a resolvable
+-# r = pi.resolvable
+-# puts "#{r.name}-#{r.edition}"
+- end
+-
+- assert true
+- end
+-end
+diff --git a/swig/zypp.i b/swig/zypp.i
+index 08d573b..c270d6c 100644
+--- a/swig/zypp.i
++++ b/swig/zypp.i
+@@ -5,25 +5,8 @@
+ */
+ #define PRODUCTION 1
+
+-#ifdef SWIGPERL5
+-%{
+- #undef NORMAL
+- #undef readdir
+- #undef Fflush
+- #undef Mkdir
+- #undef strerror
+-%}
+-#endif
+-
+ %{
+ /* Includes the header in the wrapper code */
+-#ifdef SWIGRUBY
+-#define REG_EXTENDED 1
+-#define REG_ICASE (REG_EXTENDED << 1)
+-#define REG_NEWLINE (REG_ICASE << 1)
+-#define REG_NOSUB (REG_NEWLINE << 1)
+-#endif
+-
+ /*
+ * type definitions to keep the C code generic
+ */
+@@ -52,62 +35,6 @@
+ #define TARGET_THREAD_END_ALLOW SWIG_PYTHON_THREAD_END_ALLOW
+ #endif
+
+-#if defined(SWIGRUBY)
+-#define Target_Null_p(x) NIL_P(x)
+-#define Target_INCREF(x)
+-#define Target_DECREF(x)
+-#define Target_True Qtrue
+-#define Target_False Qfalse
+-#define Target_Null Qnil
+-#define Target_Type VALUE
+-#define Target_Bool(x) ((x)?Qtrue:Qfalse)
+-#define Target_WChar(x) INT2FIX(x)
+-#define Target_Int(x) INT2FIX(x)
+-#define Target_String(x) rb_str_new2(x)
+-#define Target_Real(x) rb_float_new(x)
+-#define Target_Array() rb_ary_new()
+-#define Target_SizedArray(len) rb_ary_new2(len)
+-#define Target_Append(x,y) rb_ary_push(x,y)
+-#define Target_DateTime(x) Qnil
+-#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+-#define TARGET_THREAD_END_BLOCK do {} while(0)
+-#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+-#define TARGET_THREAD_END_ALLOW do {} while(0)
+-#include <ruby.h>
+-#include <rubyio.h>
+-#endif
+-
+-#if defined(SWIGPERL)
+-#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+-#define TARGET_THREAD_END_BLOCK do {} while(0)
+-#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+-#define TARGET_THREAD_END_ALLOW do {} while(0)
+-
+-SWIGINTERNINLINE SV *SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value);
+-SWIGINTERNINLINE SV *SWIG_FromCharPtr(const char *cptr);
+-SWIGINTERNINLINE SV *SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value);
+-
+-#define Target_Null_p(x) (x == NULL)
+-#define Target_INCREF(x)
+-#define Target_DECREF(x)
+-#define Target_True (&PL_sv_yes)
+-#define Target_False (&PL_sv_no)
+-#define Target_Null NULL
+-#define Target_Type SV *
+-#define Target_Bool(x) (x)?Target_True:Target_False
+-#define Target_WChar(x) NULL
+-#define Target_Int(x) SWIG_From_long(x)
+-#define Target_String(x) SWIG_FromCharPtr(x)
+-#define Target_Real(x) SWIG_From_double(x)
+-#define Target_Array() (SV *)newAV()
+-#define Target_SizedArray(len) (SV *)newAV()
+-#define Target_Append(x,y) av_push(((AV *)(x)), y)
+-#define Target_DateTime(x) NULL
+-#include <perl.h>
+-#include <EXTERN.h>
+-#endif
+-
+-
+ #include <sstream>
+ #include "zypp/base/PtrTypes.h"
+ #include "zypp/base/ReferenceCounted.h"
+@@ -144,33 +71,15 @@ typedef std::list<std::string> StringList;
+ %}
+
+ /* prevent swig from creating a type called 'Target_Type' */
+-#if defined(SWIGRUBY)
+-#define Target_Type VALUE
+-#endif
+ #if defined(SWIGPYTHON)
+ #define Target_Type PyObject*
+ #endif
+-#if defined(SWIGPERL)
+-#define Target_Type SV *
+-#endif
+-
+-#ifdef SWIGRUBY
+-%include "ruby/std_list.i"
+-%include "ruby/std_set.i"
+-%include "ruby/ruby.i"
+-#endif
+-
+ #ifdef SWIGPYTHON
+ %include "std_list.i"
+ %include "std_set.i"
+ %include "python/python.i"
+ #endif
+
+-#ifdef SWIGPERL5
+-%include "std_list.i"
+-%include "perl5/perl.i"
+-#endif
+-
+ #define VERSION ZYPP_VERSION
+
+ /* These include files are pending to be cleaned up from C++ cruft */
--- /dev/null
+diff -uNr libzypp-bindings-0.5.50/swig/Arch.i libzypp-bindings-0.5.50.new/swig/Arch.i
+--- libzypp-bindings-0.5.50/swig/Arch.i 2011-10-19 00:35:54.000000000 +0800
++++ libzypp-bindings-0.5.50.new/swig/Arch.i 2012-01-29 16:11:03.839382406 +0800
+@@ -84,6 +84,22 @@
+ * builtin: s390s (zSeries 64 bit)
+ */
+ static Arch s390x() { return zypp::Arch_s390x; }
++ /*
++ * builtin: armv7tnhl
++ */
++ static Arch armv7tnhl() { return zypp::Arch_armv7tnhl; }
++ /*
++ * builtin: armv7thl
++ */
++ static Arch armv7thl() { return zypp::Arch_armv7thl; }
++ /*
++ * builtin: armv7nhl
++ */
++ static Arch armv7nhl() { return zypp::Arch_armv7nhl; }
++ /*
++ * builtin: armv7hl
++ */
++ static Arch armv7hl() { return zypp::Arch_armv7hl; }
+ /*
+ * builtin: armv7tnhl
+ */
--- /dev/null
+/*
+ * Arch.i
+ *
+ * Architecture definitions
+ *
+ * Document-class: Arch
+ * Instances of Arch represent architecture and compatibility.
+ * The system has an architecture (i.e. x86_64) and so does every
+ * Resolvable.
+ *
+ * +Arch#compatible_with?+ is used to detect compatible architectures.
+ * 'noarch' is compatible with any system architecture.
+ *
+ * There is no limit to architecture specifiers, any string can be
+ * passed to the Arch constructor.
+ * However, there is a set of architectures built into libzypp.
+ * +Arch#builtin?+ returns true for an architecture from the builtin set.
+ *
+ * === Usage
+ * arch = Arch.new("i686")
+ * # equivalent:
+ * # arch = Arch.i686
+ *
+ * arch.builtin? -> true
+ *
+ */
+
+%nodefault zypp::Arch;
+namespace zypp {
+class Arch {
+};
+};
+
+%extend zypp::Arch
+{
+ Arch(const char *s) {
+ return new zypp::Arch(s);
+ }
+ ~Arch() {
+ delete $self;
+ }
+
+ /*
+ * builtin: noarch
+ */
+ static Arch noarch() { return zypp::Arch_noarch; }
+ /*
+ * builtin: i386
+ */
+ static Arch i386() { return zypp::Arch_i386; }
+ /*
+ * builtin: i486
+ */
+ static Arch i486() { return zypp::Arch_i486; }
+ /*
+ * builtin: i586
+ */
+ static Arch i586() { return zypp::Arch_i586; }
+ /*
+ * builtin: i686
+ */
+ static Arch i686() { return zypp::Arch_i686; }
+ /*
+ * builtin: i86_64 (AMD 64)
+ */
+ static Arch x86_64() { return zypp::Arch_x86_64; }
+ /*
+ * builtin: ia64 (Itanium)
+ */
+ static Arch ia64() { return zypp::Arch_ia64; }
+ /*
+ * builtin: ppc (Power PC 32 bit)
+ */
+ static Arch ppc() { return zypp::Arch_ppc; }
+ /*
+ * builtin: ppc64 (Power PC 64 bit)
+ */
+ static Arch ppc64() { return zypp::Arch_ppc64; }
+ /*
+ * builtin: s390 (zSeries 32 bit)
+ */
+ static Arch s390() { return zypp::Arch_s390; }
+ /*
+ * builtin: s390s (zSeries 64 bit)
+ */
+ static Arch s390x() { return zypp::Arch_s390x; }
+ /*
+ * builtin: armv7tnhl
+ */
+ static Arch armv7tnhl() { return zypp::Arch_armv7tnhl; }
+ /*
+ * builtin: armv7thl
+ */
+ static Arch armv7thl() { return zypp::Arch_armv7thl; }
+ /*
+ * builtin: armv7nhl
+ */
+ static Arch armv7nhl() { return zypp::Arch_armv7nhl; }
+ /*
+ * builtin: armv7hl
+ */
+ static Arch armv7hl() { return zypp::Arch_armv7hl; }
+
+ /*
+ * builtin: armv7l
+ */
+ static Arch armv7l() { return zypp::Arch_armv7l; }
+ /*
+ * builtin: armv6l
+ */
+ static Arch armv6l() { return zypp::Arch_armv6l; }
+ /*
+ * builtin: armv5tejl
+ */
+ static Arch armv5tejl() { return zypp::Arch_armv5tejl; }
+ /*
+ * builtin: armv5tel
+ */
+ static Arch armv5tel() { return zypp::Arch_armv5tel; }
+ /*
+ * builtin: armv5l
+ */
+ static Arch armv5l() { return zypp::Arch_armv5l; }
+ /*
+ * builtin: armv4tl
+ */
+ static Arch armv4tl() { return zypp::Arch_armv4tl; }
+ /*
+ * builtin: armv4l
+ */
+ static Arch armv4l() { return zypp::Arch_armv4l; }
+ /*
+ * builtin: armv3l
+ */
+ static Arch armv3l() { return zypp::Arch_armv3l; }
+
+#if 0 /* defined(SWIGRUBY) */
+%typemap(out) int is_builtin
+ "$result = $1 ? Qtrue : Qfalse;";
+%rename("builtin?") builtin;
+#endif
+ /*
+ * Whether this is a builtin (or known) architecture.
+ *
+ */
+ bool is_builtin() {
+ return ($self->isBuiltIn() ? 1 : 0);
+ }
+#if defined(SWIGRUBY)
+%typemap(out) int compatible_with
+ "$result = $1 ? Qtrue : Qfalse;";
+%rename("compatible_with?") compatible_with;
+#endif
+ /*
+ * Check if this architecture is compatible with another one
+ *
+ * e.g. 'noarch' is compatible with any arch
+ *
+ */
+ int compatible_with(const zypp::Arch & arch) {
+ return ($self->compatibleWith(arch) ? 1 : 0);
+ }
+
+#if ZYPP_VERSION > 800
+ /*
+ * return the arch before noarch if it's not a multilib arch
+ * (e.g. x86_64,sparc64v,sparc64,ppc64,s390x).
+ *
+ */
+ zypp::Arch base_arch()
+ {
+ return $self->baseArch();
+ }
+#endif
+
+#if defined(SWIGRUBY)
+%alias compare "<=>";
+#endif
+#if defined(SWIGPYTHON)
+ /*
+ * :nodoc:
+ */
+ int __cmp__( const zypp::Arch & arch )
+#else
+ /*
+ * Comparison operator
+ *
+ * returning <0 (smaller), 0 (equal) or >0 (greater)
+ *
+ */
+ int compare( const zypp::Arch & arch )
+#endif
+ { return $self->compare( arch ); }
+
+#if defined(SWIGPERL)
+ /*
+ * :nodoc:
+ */
+ int __eq__( const zypp::Arch & arch )
+#endif
+#if defined(SWIGRUBY)
+%typemap(out) int equal
+ "$result = $1 ? Qtrue : Qfalse;";
+%rename("==") equal;
+ /*
+ * Equality operator
+ *
+ */
+ int equal( const zypp::Arch & arch )
+#endif
+
+#if defined(SWIGPYTHON)
+ /*
+ * :nodoc:
+ * Python treats 'eq' and 'ne' distinct.
+ */
+ int __ne__( const zypp::Arch & arch )
+ { return $self->compare(arch) != 0; }
+ int __eq__( const zypp::Arch & arch )
+#endif
+ { return $self->compare(arch) == 0; }
+
+
+#ifdef SWIGPYTHON
+%rename ("__str__") string();
+#endif
+#ifdef SWIGRUBY
+%rename ("to_s") string();
+#endif
+ /*
+ * String representation
+ *
+ */
+ const char *string()
+ {
+ return $self->c_str();
+ }
+}
--- /dev/null
+
+
+#ifdef SWIGRUBY
+
+namespace zypp
+{
+ // how to do that?
+ // %rename "ByteCount::operator SizeType()" to_i;
+}
+
+#endif
+
+
+// TODO: tell make about dependencies
+%include <zypp/ByteCount.h>
+
+
+#ifdef SWIGRUBY
+
+namespace zypp
+{
+ %extend ByteCount
+ {
+ long long int to_i()
+ {
+ ByteCount::SizeType tmp = *self;
+ return tmp;
+ }
+ }
+}
+
+#endif
+
+#ifdef SWIGPYTHON
+
+namespace zypp
+{
+ %extend ByteCount
+ {
+ long long int __int__()
+ {
+ ByteCount::SizeType tmp = *self;
+ return tmp;
+ }
+ }
+}
+
+#endif
+
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig
+#
+#
+
+ENABLE_TESTING()
+
+SET( SWIG_INPUT "${CMAKE_CURRENT_SOURCE_DIR}/zypp.i" )
+
+#
+# Let's see which target languages are available
+#
+
+FIND_PACKAGE(Ruby)
+FIND_PACKAGE(PythonLibs)
+FIND_PACKAGE(Perl)
+
+
+IF (RUBY_LIBRARY AND RUBY_INCLUDE_PATH)
+ ADD_SUBDIRECTORY(ruby)
+ENDIF(RUBY_LIBRARY AND RUBY_INCLUDE_PATH)
+
+IF (PYTHON_LIBRARY)
+ ADD_SUBDIRECTORY(python)
+ENDIF(PYTHON_LIBRARY)
+
+IF (PERL_EXECUTABLE)
+ ADD_SUBDIRECTORY(perl5)
+ENDIF (PERL_EXECUTABLE)
--- /dev/null
+/*
+ * Callbacks.i
+ *
+ * Callback glue code
+ *
+ * Author: Klaus Kaempf <kkaempf@suse.de>
+ *
+ */
+
+
+/*
+ * Commit callbacks
+ *
+ */
+
+%{
+#include <cstdarg>
+#include <zypp/ZYppCallbacks.h>
+/*
+ * Helpers
+ *
+ */
+
+/*
+ * Action
+ * Symbol representation of :abort, :retry, and :ignore
+ *
+ */
+
+static Target_Type action_abort()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("abort"));
+ return value;
+#endif
+ return 0; // fallback
+ }
+
+static Target_Type action_retry()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("retry"));
+ return value;
+#endif
+ return 0; // fallback
+ }
+
+static Target_Type action_ignore()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("ignore"));
+ return value;
+#endif
+ return 0; // fallback
+ }
+
+/*
+ * Error
+ * Symbol representation of :no_error, :not_found, :io, :invalid
+ *
+ */
+
+static Target_Type error_no_error()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("no_error"));
+ return value;
+#endif
+#if defined(SWIGPYTHON)
+ return Target_String("no_error");
+#endif
+ return 0; // fallback
+ }
+
+static Target_Type error_not_found()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("not_found"));
+ return value;
+#endif
+#if defined(SWIGPYTHON)
+ return Target_String("not_found");
+#endif
+ return 0; // fallback
+ }
+
+static Target_Type error_io()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("io"));
+ return value;
+#endif
+#if defined(SWIGPYTHON)
+ return Target_String("io");
+#endif
+ return 0; // fallback
+ }
+
+static Target_Type error_invalid()
+ {
+#if defined(SWIGRUBY)
+ static VALUE value = Qnil;
+ if (value == Qnil)
+ value = ID2SYM(rb_intern("invalid"));
+ return value;
+#endif
+#if defined(SWIGPYTHON)
+ return Target_String("invalid");
+#endif
+ return 0; // fallback
+ }
+
+/*
+ * This is what makes people hate the ZYPP API. Why can't there
+ * be _one_ Error type ?!
+ */
+static Target_Type
+remove_error2target(target::rpm::RemoveResolvableReport::Error error)
+{
+ Target_Type e;
+ switch(error) {
+ case target::rpm::RemoveResolvableReport::NO_ERROR: e = error_no_error(); break;
+ case target::rpm::RemoveResolvableReport::NOT_FOUND: e = error_not_found(); break;
+ case target::rpm::RemoveResolvableReport::IO: e = error_io(); break;
+ case target::rpm::RemoveResolvableReport::INVALID: e = error_invalid(); break;
+ }
+ return e;
+}
+
+
+/*
+ * This is what makes people hate the ZYPP API. Why can't there
+ * be _one_ Error type ?!
+ */
+static Target_Type
+install_error2target(target::rpm::InstallResolvableReport::Error error)
+{
+ Target_Type e;
+ switch(error) {
+ case target::rpm::InstallResolvableReport::NO_ERROR: e = error_no_error(); break;
+ case target::rpm::InstallResolvableReport::NOT_FOUND: e = error_not_found(); break;
+ case target::rpm::InstallResolvableReport::IO: e = error_io(); break;
+ case target::rpm::InstallResolvableReport::INVALID: e = error_invalid(); break;
+ }
+ return e;
+}
+
+
+/*
+ * This is what makes people hate the ZYPP API. Why can't there
+ * be _one_ Action type ?!
+ */
+static target::PatchScriptReport::Action
+target2patch_script_action(Target_Type a)
+{
+#if defined(SWIGPYTHON)
+ const char *s;
+ if (!PyString_Check(a)) {
+ SWIG_exception_fail(SWIG_TypeError, "Expected string type");
+ }
+ s = PyString_AsString(a);
+ if (!strcmp(s, "abort"))
+ return zypp::target::PatchScriptReport::ABORT;
+ else if (!strcmp(s, "retry"))
+ return zypp::target::PatchScriptReport::RETRY;
+ else if (!strcmp(s, "ignore"))
+ return zypp::target::PatchScriptReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected \"abort\", \"retry\" or \"ignore\"");
+#endif
+#if defined(SWIGRUBY)
+ if (a == action_abort())
+ return zypp::target::PatchScriptReport::ABORT;
+ else if (a == action_retry())
+ return zypp::target::PatchScriptReport::RETRY;
+ else if (a == action_ignore())
+ return zypp::target::PatchScriptReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected :abort, :retry or :ignore");
+#endif
+fail:
+ return zypp::target::PatchScriptReport::ABORT;
+}
+
+
+static target::rpm::RemoveResolvableReport::Action
+target2removal_action(Target_Type a)
+{
+#if defined(SWIGPYTHON)
+ const char *s;
+ if (!PyString_Check(a)) {
+ SWIG_exception_fail(SWIG_TypeError, "Expected string type");
+ }
+ s = PyString_AsString(a);
+ if (!strcmp(s, "abort"))
+ return zypp::target::rpm::RemoveResolvableReport::ABORT;
+ else if (!strcmp(s, "retry"))
+ return zypp::target::rpm::RemoveResolvableReport::RETRY;
+ else if (!strcmp(s, "ignore"))
+ return zypp::target::rpm::RemoveResolvableReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected \"abort\", \"retry\" or \"ignore\"");
+#endif
+#if defined(SWIGRUBY)
+ if (a == action_abort())
+ return zypp::target::rpm::RemoveResolvableReport::ABORT;
+ else if (a == action_retry())
+ return zypp::target::rpm::RemoveResolvableReport::RETRY;
+ else if (a == action_ignore())
+ return zypp::target::rpm::RemoveResolvableReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected :abort, :retry or :ignore");
+#endif
+fail:
+ return zypp::target::rpm::RemoveResolvableReport::ABORT;
+}
+
+
+static target::rpm::InstallResolvableReport::Action
+target2install_action(Target_Type a)
+{
+#if defined(SWIGPYTHON)
+ const char *s;
+ if (!PyString_Check(a)) {
+ SWIG_exception_fail(SWIG_TypeError, "Expected string type");
+ }
+ s = PyString_AsString(a);
+ if (!strcmp(s, "abort"))
+ return zypp::target::rpm::InstallResolvableReport::ABORT;
+ else if (!strcmp(s, "retry"))
+ return zypp::target::rpm::InstallResolvableReport::RETRY;
+ else if (!strcmp(s, "ignore"))
+ return zypp::target::rpm::InstallResolvableReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected \"abort\", \"retry\" or \"ignore\"");
+#endif
+#if defined(SWIGRUBY)
+ if (a == action_abort())
+ return zypp::target::rpm::InstallResolvableReport::ABORT;
+ else if (a == action_retry())
+ return zypp::target::rpm::InstallResolvableReport::RETRY;
+ else if (a == action_ignore())
+ return zypp::target::rpm::InstallResolvableReport::IGNORE;
+ SWIG_exception_fail(SWIG_ArgError(SWIG_ValueError), "Expected :abort, :retry or :ignore");
+#endif
+fail:
+ return zypp::target::rpm::InstallResolvableReport::ABORT;
+}
+
+
+/*
+ * target_call
+ *
+ * Generic helper to call a function of the target language
+ *
+ */
+static Target_Type
+target_call(Target_Type instance, const char *name, int argc, ... )
+{
+ va_list ap;
+ va_start(ap, argc);
+#if defined(SWIGPYTHON)
+ /*
+ * Python call with multiple args is like Array
+ */
+ Target_Type argv = PyTuple_New(argc);
+ int i;
+ for (i = 0; i < argc; ++i)
+ {
+ PyObject* arg = va_arg(ap, PyObject*);
+ if (arg == NULL)
+ {
+ arg = Py_None;
+ Py_IncRef(arg);
+ }
+ PyTuple_SET_ITEM(argv, i, arg);
+ }
+
+ PyObject *pyfunc = PyObject_GetAttrString(instance, name);
+ PyObject *result = NULL;
+
+ if (pyfunc == NULL)
+ {
+ PyErr_Print();
+ PyErr_Clear();
+ goto cleanup;
+ }
+ if (! PyCallable_Check(pyfunc))
+ {
+ fprintf(stderr,"%s not callable\n", name);
+ goto cleanup;
+ }
+
+ result = PyObject_CallObject(pyfunc, argv);
+ if (PyErr_Occurred())
+ {
+ fprintf(stderr,"%s returned error\n", name);
+ PyErr_Print();
+ PyErr_Clear();
+ goto cleanup;
+ }
+
+cleanup:
+ if (pyfunc) Py_DecRef(pyfunc);
+ if (argv) Py_DecRef(argv);
+#endif
+#if defined(SWIGRUBY)
+ /*
+ * Ruby call with multiple args is like argc/argv
+ */
+ Target_Type *argv = (Target_Type *)alloca(argc * sizeof(Target_Type));
+ Target_Type *argvp = argv;
+ int i = argc;
+ while(i-- > 0) {
+ *argvp++ = va_arg(ap, Target_Type);
+ }
+ VALUE result = rb_funcall3( instance, rb_intern(name), argc, argv );
+#endif
+#if defined(SWIGPERL)
+ Target_Type result = Target_Null;
+#endif
+ va_end(ap);
+ return result;
+}
+
+
+/*
+ * Patch message
+ *
+ * calls 'show_message(zypp::Patch)'
+ */
+
+struct PatchMessageReportReceiver : public zypp::callback::ReceiveReport<zypp::target::PatchMessageReport>
+{
+
+ Target_Type instance;
+
+ /** Display \c patch->message().
+ * Return \c true to continue, \c false to abort commit.
+ */
+ virtual bool show( zypp::Patch::constPtr & patch )
+ {
+ int result;
+ Target_Type r = SWIG_NewPointerObj((void *)&patch, SWIGTYPE_p_zypp__Patch, 0);
+ Target_Type res = target_call(instance, "patch_message", 1, r );
+#if defined(SWIGPYTHON)
+ result = PyObject_IsTrue(res) ? true : false;
+ if (res) Py_DecRef(res);
+#endif
+#if defined(SWIGRUBY)
+ result = RTEST(res) ? true : false;
+#endif
+ return result;
+ }
+};
+
+
+/*
+ * Patch script
+ *
+ */
+
+struct PatchScriptReportReceiver : public zypp::callback::ReceiveReport<zypp::target::PatchScriptReport>
+{
+
+ Target_Type instance;
+
+ virtual void start( const zypp::Package::constPtr & package,
+ const zypp::Pathname & path_r ) // script path
+ {
+ Target_Type pac = SWIG_NewPointerObj((void *)&(*package), SWIGTYPE_p_zypp__Package, 0);
+ Target_Type path = SWIG_NewPointerObj((void *)&path_r, SWIGTYPE_p_zypp__filesystem__Pathname, 0);
+ Target_Type result = target_call(instance, "patch_script_start", 2, pac, path );
+#if defined(SWIGPYTHON)
+ if (result) Py_DecRef(result);
+ Py_DecRef(path);
+ Py_DecRef(pac);
+#endif
+ return;
+ }
+
+ /**
+ * Progress provides the script output (Notify=OUTPUT). If the script is quiet,
+ * from time to time still-alive pings are sent to the ui. (Notify=PING)
+ * Returning \c FALSE aborts script execution.
+ */
+ virtual bool progress( Notify kind, const std::string &output )
+ {
+ int result;
+ Target_Type str = Target_String(output.c_str());
+ Target_Type k;
+ switch(kind) {
+ case OUTPUT:
+#if defined(SWIGPYTHON)
+ k = Target_String("OUTPUT");
+#endif
+#if defined(SWIGRUBY)
+ k = ID2SYM(rb_intern("OUTPUT"));
+#endif
+ break;
+ case PING:
+#if defined(SWIGPYTHON)
+ k = Target_String("PING");
+#endif
+#if defined(SWIGRUBY)
+ k = ID2SYM(rb_intern("PING"));
+#endif
+ break;
+ }
+ Target_Type res = target_call(instance, "patch_script_progress", 2, k, str );
+#if defined(SWIGPYTHON)
+ result = PyObject_IsTrue(res) ? true : false;
+ if (res) Py_DecRef(res);
+ Py_DecRef(k);
+ Py_DecRef(str);
+#endif
+#if defined(SWIGRUBY)
+ result = RTEST(res) ? true : false;
+#endif
+ return result;
+ }
+
+ /** Report patch script error.
+ */
+ virtual Action problem( const std::string & description )
+ {
+ Action result;
+ Target_Type str = Target_String(description.c_str());
+ Target_Type res = target_call(instance, "patch_script_problem", 1, str );
+ result = target2patch_script_action(res);
+#if defined(SWIGPYTHON)
+ Py_DecRef(str);
+ if (res) Py_DecRef(res);
+#endif
+ return result;
+ }
+
+ /** Patch script finish. */
+ virtual void finish()
+ {
+ Target_Type res = target_call(instance, "patch_script_finish", 0 );
+#if defined(SWIGPYTHON)
+ if (res) Py_DecRef(res);
+#endif
+ return;
+ }
+};
+
+
+/*
+ * Remove
+ *
+ */
+
+struct RemoveResolvableReportReceiver : public zypp::callback::ReceiveReport<zypp::target::rpm::RemoveResolvableReport>
+{
+
+ Target_Type instance;
+
+ virtual void start( Resolvable::constPtr resolvable )
+ {
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type result = target_call(instance, "removal_start", 1, r );
+#if defined(SWIGPYTHON)
+ Py_DecRef(r);
+ if (result) Py_DecRef(result);
+#endif
+ return;
+ }
+
+ /**
+ * Return \c true to continue, \c false to abort commit.
+ */
+ virtual bool progress(int value, zypp::Resolvable::constPtr resolvable)
+ {
+ bool result;
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type v = Target_Int(value);
+ Target_Type res = target_call(instance, "removal_progress", 2, r, v );
+#if defined(SWIGPYTHON)
+ result = PyObject_IsTrue(res) ? true : false;
+ Py_DecRef(v);
+ Py_DecRef(r);
+ if (res) Py_DecRef(res);
+#endif
+#if defined(SWIGRUBY)
+ result = RTEST(res) ? true : false;
+#endif
+ return result;
+ }
+
+ virtual Action problem( zypp::Resolvable::constPtr resolvable, target::rpm::RemoveResolvableReport::Error error, const std::string & description )
+ {
+ Action result;
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type e = remove_error2target(error);
+ Target_Type d = Target_String(description.c_str());
+ Target_Type res = target_call(instance, "removal_problem", 3, r, e, d );
+ result = target2removal_action(res);
+#if defined(SWIGPYTHON)
+ if (res) Py_DecRef(res);
+ Py_DecRef(d);
+ Py_DecRef(e);
+ Py_DecRef(r);
+#endif
+ return result;
+ }
+
+ virtual void finish( zypp::Resolvable::constPtr resolvable, Error error, const std::string & reason )
+ {
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type e = remove_error2target(error);
+ Target_Type d = Target_String(reason.c_str());
+ Target_Type res = target_call(instance, "removal_finish", 3, r, e, d );
+#if defined(SWIGPYTHON)
+ if (res) Py_DecRef(res);
+ Py_DecRef(d);
+ Py_DecRef(e);
+ Py_DecRef(r);
+#endif
+ return;
+ }
+};
+
+
+/*
+ * Install
+ *
+ */
+
+struct InstallResolvableReportReceiver : public zypp::callback::ReceiveReport<zypp::target::rpm::InstallResolvableReport>
+{
+
+ Target_Type instance;
+
+ virtual void start( zypp::Resolvable::constPtr resolvable )
+ {
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type result = target_call(instance, "install_start", 1, r );
+#if defined(SWIGPYTHON)
+ Py_DecRef(r);
+ if (result) Py_DecRef(result);
+#endif
+ return;
+ }
+
+ /**
+ * Return \c true to continue, \c false to abort commit.
+ */
+ virtual bool progress(int value, zypp::Resolvable::constPtr resolvable)
+ {
+ bool result;
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type v = Target_Int(value);
+ Target_Type res = target_call(instance, "install_progress", 2, r, v );
+#if defined(SWIGPYTHON)
+ result = PyObject_IsTrue(res) ? true : false;
+ Py_DecRef(v);
+ Py_DecRef(r);
+ if (res) Py_DecRef(res);
+#endif
+#if defined(SWIGRUBY)
+ result = RTEST(res) ? true : false;
+#endif
+ return result;
+ }
+
+ virtual Action problem( zypp::Resolvable::constPtr resolvable, Error error, const std::string & description, RpmLevel level )
+ {
+ Action result;
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type e = install_error2target(error);
+ Target_Type d = Target_String(description.c_str());
+ Target_Type res = target_call(instance, "install_problem", 3, r, e, d );
+ result = target2install_action(res);
+#if defined(SWIGPYTHON)
+ if (res) Py_DecRef(res);
+ Py_DecRef(d);
+ Py_DecRef(e);
+ Py_DecRef(r);
+#endif
+ return result;
+ }
+
+ virtual void finish( zypp::Resolvable::constPtr resolvable, Error error, const std::string & reason, RpmLevel level )
+ {
+ Target_Type r = SWIG_NewPointerObj((void *)&(*resolvable), SWIGTYPE_p_zypp__Resolvable, 0);
+ Target_Type e = install_error2target(error);
+ Target_Type d = Target_String(reason.c_str());
+ Target_Type res = target_call(instance, "install_finish", 3, r, e, d );
+#if defined(SWIGPYTHON)
+ if (res) Py_DecRef(res);
+ Py_DecRef(d);
+ Py_DecRef(e);
+ Py_DecRef(r);
+#endif
+ return;
+ }
+};
+
+#include "CommitCallbacks.h"
+
+%}
+
+%include "CommitCallbacks.h"
+
--- /dev/null
+%include <zypp/CapMatch.h>
--- /dev/null
+
+%include <zypp/Capabilities.h>
+
+#ifdef SWIGRUBY
+by_value_iterator(zypp::Capabilities);
+#endif
+
+#ifdef SWIGPERL5
+forwarditer(zypp::Capabilities, zypp::Capability);
+#endif
--- /dev/null
+// Ignore member functions shadowed by static versions
+%ignore zypp::Capability::matches(Capability const &) const;
+%ignore zypp::Capability::matches(IdString const &) const;
+%ignore zypp::Capability::matches(std::string const &) const;
+%ignore zypp::Capability::matches(char const *) const;
+
+%include <zypp/Capability.h>
+
+%extend zypp::Capability
+{
+ int __cmp__(const Capability& other)
+ {
+ // TODO: use CapOrder::operator()?
+ if(self->asString() < other.asString())
+ return -1;
+ if(self->asString() > other.asString())
+ return +1;
+ return 0;
+ }
+}
+
+
--- /dev/null
+%include <zypp/CheckSum.h>
+
--- /dev/null
+class CommitCallbacks {
+
+ private:
+ PatchMessageReportReceiver _messageReceiver;
+ PatchScriptReportReceiver _scriptReceiver;
+ RemoveResolvableReportReceiver _removeReceiver;
+ InstallResolvableReportReceiver _installReceiver;
+ Target_Type _instance;
+
+ public:
+ CommitCallbacks()
+ : _instance(Target_Null)
+ {
+ _messageReceiver.connect();
+ _scriptReceiver.connect();
+ _installReceiver.connect();
+ _removeReceiver.connect();
+// printf("CommitCallbacks @ %p\n", this);
+ }
+
+ ~CommitCallbacks()
+ {
+// printf("~CommitCallbacks @ %p\n", this);
+ _removeReceiver.disconnect();
+ _installReceiver.disconnect();
+ _scriptReceiver.disconnect();
+ _messageReceiver.disconnect();
+ disconnect();
+ }
+ /*
+ * Connect callback to receiver instance
+ * Pass NULL receiver to disconnect
+ *
+ */
+ void connect(Target_Type instance) {
+// fprintf(stderr, "connect(%p)\n", instance);
+ disconnect();
+ if (instance) {
+ _instance = instance;
+ Target_INCREF(_instance);
+ _messageReceiver.instance = _instance;
+ _scriptReceiver.instance = _instance;
+ _installReceiver.instance = _instance;
+ _removeReceiver.instance = _instance;
+ }
+ }
+ /*
+ * Disconnect receiver instance
+ *
+ */
+ void disconnect() {
+// fprintf(stderr, "disconnect(%p)\n", _instance);
+ if (_instance != Target_Null) {
+ _messageReceiver.instance = Target_Null;
+ _scriptReceiver.instance = Target_Null;
+ _installReceiver.instance = Target_Null;
+ _removeReceiver.instance = Target_Null;
+ Target_DECREF(_instance);
+ _instance = Target_Null;
+ }
+ }
+ /*
+ * Get current receiver instance
+ *
+ */
+ Target_Type receiver() {
+// fprintf(stderr, "receiver(%p)\n", _instance);
+ return _instance;
+ }
+};
+
+
+/*
+ * A (dummy) commit callback emitter used for testing only
+ *
+ */
+
+class CommitCallbacksEmitter {
+ private:
+ callback::SendReport<target::rpm::InstallResolvableReport> _install_resolvable;
+ callback::SendReport<target::rpm::RemoveResolvableReport> _remove_resolvable;
+ callback::SendReport<target::PatchMessageReport> _patch_message;
+ callback::SendReport<target::PatchScriptReport> _patch_script;
+ public:
+ /*
+ * InstallResolvableReport
+ *
+ */
+ void install_start(zypp::ResObject::constPtr resobj)
+ {
+ _install_resolvable->start( resobj );
+ }
+
+ bool install_progress(zypp::ResObject::constPtr resobj, int value)
+ {
+ return _install_resolvable->progress( value, resobj ); /* arguments reversed :-/ */
+ }
+
+ target::rpm::InstallResolvableReport::Action install_problem(
+ zypp::ResObject::constPtr resobj,
+ target::rpm::InstallResolvableReport::Error error,
+ const std::string & description,
+ target::rpm::InstallResolvableReport::RpmLevel level)
+ {
+ return _install_resolvable->problem( resobj, error, description, level );
+ }
+
+ void install_finish(
+ zypp::ResObject::constPtr resobj,
+ target::rpm::InstallResolvableReport::Error error,
+ const std::string & reason,
+ target::rpm::InstallResolvableReport::RpmLevel level)
+ {
+ return _install_resolvable->finish( resobj, error, reason, level );
+ }
+
+ /*
+ * RemoveResolvableReport
+ *
+ */
+ void remove_start(zypp::ResObject::constPtr resobj)
+ {
+ _remove_resolvable->start( resobj );
+ }
+
+ bool remove_progress(zypp::ResObject::constPtr resobj, int value)
+ {
+ return _remove_resolvable->progress( value, resobj ); /* arguments reversed :-/ */
+ }
+
+ target::rpm::RemoveResolvableReport::Action remove_problem(
+ zypp::ResObject::constPtr resobj,
+ target::rpm::RemoveResolvableReport::Error error,
+ const std::string & description)
+ {
+ return _remove_resolvable->problem( resobj, error, description );
+ }
+
+ void remove_finish(
+ zypp::ResObject::constPtr resobj,
+ target::rpm::RemoveResolvableReport::Error error,
+ const std::string & reason)
+ {
+ return _remove_resolvable->finish( resobj, error, reason );
+ }
+
+ /*
+ * PatchMessageReport
+ *
+ */
+
+ bool patch_message(zypp::Patch::constPtr & patch)
+ {
+ return _patch_message->show(patch);
+ }
+
+ /*
+ * PatchScriptReport
+ *
+ */
+
+ void script_start( const zypp::Package::constPtr & package,
+ const zypp::Pathname & path_r ) // script path
+ {
+ _patch_script->start(package, path_r);
+ }
+
+ /**
+ * Progress provides the script output. If the script is quiet,
+ * from time to time still-alive pings are sent to the ui. (Notify=PING)
+ * Returning \c FALSE aborts script execution.
+ */
+ bool script_progress( target::PatchScriptReport::Notify kind, const std::string &output )
+ {
+ return _patch_script->progress(kind, output);
+ }
+
+ /** Report error. */
+ target::PatchScriptReport::Action script_problem( const std::string & description )
+ {
+ return _patch_script->problem(description);
+ }
+
+ /** Report success. */
+ void finish()
+ {
+ _patch_script->finish();
+ }
+
+};
+
+#define REMOVE_NO_ERROR target::rpm::RemoveResolvableReport::NO_ERROR
+#define INSTALL_NO_ERROR target::rpm::InstallResolvableReport::NO_ERROR
--- /dev/null
+
+// TODO: tell make about dependencies
+%include <zypp/Date.h>
--- /dev/null
+
+%nodefault Dep;
+%include "zypp/Dep.h"
--- /dev/null
+// Ignore member functions shadowed by static versions
+// ma@: maybe one should ignore the statics and keep the members?
+%ignore zypp::Edition::match(Edition const &) const;
+%ignore zypp::Edition::match(IdString const &) const;
+%ignore zypp::Edition::match(std::string const &) const;
+%ignore zypp::Edition::match(char const *) const;
+
+// ma@: Why do we need this?
+//namespace zypp
+//{
+// %rename Edition::compare(const Edition& lhs, const Edition& rhs) compare2;
+// %rename Edition::match(const Edition& lhs, const Edition& rhs) match2;
+//}
+
+//%ignore zypp::Edition::compare(const Edition &, const Edition &);
+
+%template(IdStringEdition) zypp::IdStringType<zypp::Edition>;
+%include <zypp/Edition.h>
--- /dev/null
+%include <zypp/IdString.h>
+%include <zypp/IdStringType.h>
--- /dev/null
+
+%ignore zypp::KeyRingReport;
+%ignore zypp::KeyRingSignals;
+
+%rename(dontuse_setDefaultAccept) zypp::KeyRing::setDefaultAccept;
+%rename(setDefaultAccept) zypp::KeyRing::setDefaultAcceptBits;
+
+%rename(dontuse_defaultAccept) zypp::KeyRing::defaultAccept;
+%rename(defaultAccept) zypp::KeyRing::defaultAcceptBits;
+
+%include <zypp/KeyRing.h>
+%extend zypp::KeyRing
+{
+ static void setDefaultAcceptBits( unsigned i ) {
+ zypp::KeyRing::setDefaultAccept( zypp::KeyRing::DefaultAccept(i) );
+ }
+ static unsigned defaultAcceptBits() {
+ return zypp::KeyRing::defaultAccept();
+ }
+}
+namespace zypp
+{
+ typedef intrusive_ptr<KeyRing> KeyRing_Ptr;
+ %template(KeyRing_Ptr) intrusive_ptr<KeyRing>;
+}
+
+%template(List_PublicKey) std::list<zypp::PublicKey>;
--- /dev/null
+
+%ignore zypp::ResKind::satIdent( const std::string & name_r ) const;
+
+%template(IdStringResKind) zypp::IdStringType<zypp::ResKind>;
+%include <zypp/ResKind.h>
--- /dev/null
+
+%include <zypp/MediaSetAccess.h>
+
--- /dev/null
+
+typedef std::string Label;
+
+typedef std::string Text;
+
+typedef std::string Vendor;
+
--- /dev/null
+
+%include <zypp/OnMediaLocation.h>
\ No newline at end of file
--- /dev/null
+//%ignore zypp::Package::checksum();
+
+%include <zypp/Package.h>
+
--- /dev/null
+%ignore zypp::Patch::reboot_needed;
+%ignore zypp::Patch::affects_pkg_manager;
+%ignore zypp::Patch::id;
+
+%include <zypp/Patch.h>
\ No newline at end of file
--- /dev/null
+// Ignore static versions shadowed by member functions
+%ignore zypp::filesystem::Pathname::dirname(Pathname const &);
+%ignore zypp::filesystem::Pathname::basename(Pathname const &);
+%ignore zypp::filesystem::Pathname::extension(Pathname const &);
+%ignore zypp::filesystem::Pathname::absolutename(Pathname const &);
+%ignore zypp::filesystem::Pathname::relativename(Pathname const &);
+%ignore zypp::filesystem::Pathname::cat(Pathname const &,Pathname const &);
+%ignore zypp::filesystem::Pathname::extend(Pathname const &,std::string const &);
+
+%ignore zypp::filesystem::operator<( const Pathname & l, const Pathname & r );
+
+%include <zypp/Pathname.h>
--- /dev/null
+%include <zypp/Pattern.h>
\ No newline at end of file
--- /dev/null
+%include <zypp/PoolItem.h>
+
+#ifdef SWIGPERL5
+#else
+%template(PoolItemSet) std::set<zypp::PoolItem>;
+#endif
+
+%extend zypp::PoolItem
+{
+#ifdef SWIGPYTHON
+%rename ("__str__") string();
+#endif
+#ifdef SWIGRUBY
+%rename ("to_s") string();
+#endif
+
+ std::string string() const
+ {
+ std::ostringstream str;
+ str << *self;
+ return str.str();
+ }
+}
--- /dev/null
+%ignore zypp::Product::type;
+%include <zypp/Product.h>
--- /dev/null
+%include <zypp/PublicKey.h>
\ No newline at end of file
--- /dev/null
+#ifdef SWIGPERL5
+#else
+%template(UrlSet) std::set<zypp::Url>;
+#endif
+
+namespace zypp
+{
+ namespace repo
+ {
+ %ignore operator==;
+ %ignore operator!=;
+ %ignore operator<<;
+ %ignore operator<;
+ }
+ typedef std::list<Url> UrlSet;
+}
+
+%ignore zypp::repo::RepoInfoBase::dumpOn(std::ostream &) const;
+%ignore zypp::repo::RepoInfoBase::dumpAsIniOn(std::ostream &) const;
+%ignore zypp::repo::RepoInfoBase::dumpAsXMLOn(std::ostream &) const;
+%include <zypp/repo/RepoInfoBase.h>
+
+// This is due to a typo in libzypp < 5.4.0
+%ignore zypp::RepoInfo::defaultPrioity();
+
+%ignore zypp::RepoInfo::dumpOn(std::ostream &) const;
+%ignore zypp::RepoInfo::dumpAsIniOn(std::ostream &) const;
+%ignore zypp::RepoInfo::dumpAsXMLOn(std::ostream &) const;
+
+%include <zypp/RepoInfo.h>
+typedef std::list<zypp::RepoInfo> RepoInfoList;
+%template(RepoInfoList) std::list<zypp::RepoInfo>;
+
+%extend zypp::RepoInfo
+{
+ std::string dump(void) const
+ {
+ std::ostringstream str;
+ self->dumpOn(str);
+ return str.str();
+ }
+
+ std::string dumpAsIni(void) const
+ {
+ std::ostringstream str;
+ self->dumpAsIniOn(str);
+ return str.str();
+ }
+
+ std::string dumpAsXML(void) const
+ {
+ std::ostringstream str;
+ self->dumpAsXMLOn(str);
+ return str.str();
+ }
+}
--- /dev/null
+%include <zypp/RepoManager.h>
--- /dev/null
+%include <zypp/RepoStatus.h>
\ No newline at end of file
--- /dev/null
+%include <zypp/repo/RepoType.h>
\ No newline at end of file
--- /dev/null
+%ignore zypp::Repository::name;
+
+%include <zypp/Repository.h>
--- /dev/null
+%ignore zypp::make_res_object;
+%ignore zypp::ResObject::installsize;
+%ignore zypp::ResObject::size;
+
+%include <zypp/ResObject.h>
+
+%extend intrusive_ptr<const ResObject>
+{
+ int __cmp__(intrusive_ptr<const ResObject>& other)
+ {
+ return *self == other;
+ }
+}
--- /dev/null
+// missing resfilter:: to call these
+%ignore zypp::ResPool::byKindBegin;
+%ignore zypp::ResPool::byKindEnd;
+%ignore zypp::ResPool::byNameBegin;
+%ignore zypp::ResPool::byNameEnd;
+%apply unsigned { zypp::ResPool::size_type };
+%include <zypp/ResPool.h>
+
+%ignore zypp::pool::operator<<;
+%include <zypp/pool/GetResolvablesToInsDel.h>
+namespace zypp
+{
+ typedef ::std::list<zyppPoolItem> PoolItemList;
+ %template(PoolItemList) ::std::list<PoolItem>;
+}
+
+namespace zypp
+{
+
+#ifdef SWIGPERL5
+
+iter2(ResPool, PoolItem);
+
+#endif
+
+#ifdef SWIGRUBY
+
+iter3(ResPool, PoolItem*);
+
+// %extend ResPool {
+// void each()
+// {
+// ResPool::const_iterator i = self->begin();
+// while ( i != self->end() ) {
+// rb_yield( SWIG_NewPointerObj( (void *) &*i, SWIGTYPE_p_PoolItem, 0));
+// ++i;
+// }
+// }
+// }
+
+%extend ResPool {
+ void each_by_kind( const ResObject::Kind & kind_r )
+ {
+ ResPool::byKind_iterator i = self->byKindBegin( kind_r );
+ while ( i != self->byKindEnd( kind_r ) ) {
+ rb_yield( SWIG_NewPointerObj( (void *) &*i, SWIGTYPE_p_PoolItem, 0));
+ ++i;
+ }
+ }
+}
+
+%extend ResPool {
+ void each_by_name( const std::string &name )
+ {
+ ResPool::byName_iterator i = self->byNameBegin( name );
+ while ( i != self->byNameEnd( name ) ) {
+ rb_yield( SWIG_NewPointerObj( (void *) &*i, $descriptor(PoolItem), 0));
+ ++i;
+ }
+ }
+}
+
+#endif
+
+#ifdef SWIGPYTHON
+%newobject ResPool::const_iterator(PyObject **PYTHON_SELF);
+%extend ResPool {
+ swig::SwigPyIterator* iterator(PyObject **PYTHON_SELF)
+ {
+ return swig::make_output_iterator(self->begin(), self->begin(),
+ self->end(), *PYTHON_SELF);
+ }
+ swig::SwigPyIterator* kinditerator(PyObject **PYTHON_SELF, const ResObject::Kind & kind_r)
+ {
+ return swig::make_output_iterator(self->byKindBegin( kind_r ), self->byKindBegin( kind_r ),
+ self->byKindEnd( kind_r ), *PYTHON_SELF);
+ }
+ swig::SwigPyIterator* nameiterator(PyObject **PYTHON_SELF, const std::string &name)
+ {
+ return swig::make_output_iterator(self->byNameBegin( name ), self->byNameBegin( name ),
+ self->byNameEnd( name ), *PYTHON_SELF);
+ }
+%pythoncode {
+ def __iter__(self): return self.iterator()
+ def byKindIterator(self, kind): return self.kinditerator(kind)
+ def byNameIterator(self, name): return self.nameiterator(name)
+}
+}
+
+#endif
+
+}
--- /dev/null
+
+%include <zypp/ResStatus.h>
+
+#ifdef SWIGPERL5
+
+ %extend ResStatus {
+
+ bool setToBeInstalledUser()
+ {
+ return self->setToBeInstalled(ResStatus::USER);
+ }
+
+ bool resetTransactUser()
+ {
+ return self->resetTransact(ResStatus::USER);
+ }
+ };
+#endif
+
+%extend zypp::ResStatus
+{
+ std::string asString() const
+ {
+ std::ostringstream str;
+ str << *self;
+ return str.str();
+ }
+}
--- /dev/null
+
+/** Base of ResTraits. Defines the Resolvable::Kind type. */
+/*struct ResolvableTraits
+{
+ typedef KindOf<Resolvable> KindType;
+};*/
+
+namespace zypp
+{
+ /** ResTraits. Defines common types and the Kind value. */
+ template<typename _Res>
+ struct ResTraits
+ {
+ typedef zypp::intrusive_ptr<_Res> PtrType;
+ typedef zypp::intrusive_ptr<const _Res> constPtrType;
+ };
+
+ typedef intrusive_ptr<const ResObject> ResObject_constPtr;
+ typedef intrusive_ptr<ResObject> ResObject_Ptr;
+ %template(ResObject_constPtr) intrusive_ptr<const zypp::ResObject>;
+ %template(ResObject_Ptr) intrusive_ptr<zypp::ResObject>;
+
+}
+
+%template(ResTraitsResolvable) zypp::ResTraits<zypp::Resolvable>;
+%template(ResTraitsResObject) zypp::ResTraits<zypp::ResObject>;
+
+// Common definitions for all Resolvable types
+// - *_Ptr and *_constPtr
+// - isKind* to test whether a ResObject/PoolItem is
+// of a specific kind.
+// - asKind* to convert a ResObject/PoolItem into a
+// specific *_constPtr.
+%define %STUFF(X)
+namespace zypp
+{
+ typedef intrusive_ptr<const X> X##_constPtr;
+ typedef intrusive_ptr<X> X##_Ptr;
+ %template(X##_constPtr) intrusive_ptr<const X>;
+ %template(X##_Ptr) intrusive_ptr<X>;
+
+ bool isKind##X( const zypp::Resolvable::constPtr & p );
+ bool isKind##X( const zypp::PoolItem & p );
+
+ X##_constPtr asKind##X( const zypp::Resolvable::constPtr & p );
+ X##_constPtr asKind##X( const zypp::PoolItem & p );
+}
+
+%header
+{
+ namespace zypp
+ {
+ inline bool isKind##X( const zypp::Resolvable::constPtr & p )
+ { return isKind<X>( p ); }
+ inline bool isKind##X( const zypp::PoolItem & p )
+ { return isKind<X>( p.resolvable() ); }
+ inline X::constPtr asKind##X( const zypp::Resolvable::constPtr & p )
+ { return asKind<X>( p ); }
+ inline X::constPtr asKind##X( const zypp::PoolItem & p )
+ { return asKind<X>( p.resolvable() ); }
+ }
+}
+
+#if defined(SWIGPYTHON)
+%pythoncode
+{
+ def KindOf##X():
+ return KindOfResolvable( #X )
+}
+#endif
+%enddef
+
+%STUFF(Package)
+%STUFF(Patch)
+%STUFF(SrcPackage)
+%STUFF(Pattern)
+%STUFF(Product)
--- /dev/null
+%ignore zypp::make;
+%import <zypp/sat/Solvable.h>
+%include <zypp/Resolvable.h>
+
--- /dev/null
+#ifdef SWIGPERL5
+ %template(StringList) std::list<std::string>;
+#endif
+
+%include <zypp/ProblemTypes.h>
+%include <zypp/ResolverProblem.h>
+%include <zypp/ProblemSolution.h>
+%include <zypp/Resolver.h>
+
+namespace zypp
+{
+ typedef intrusive_ptr< Resolver > Resolver_Ptr;
+ %template(Resolver_Ptr) intrusive_ptr<Resolver>;
+
+#ifndef SWIGRUBY
+ /* swig generates wrong code (>> instead of > > for template type)
+ * in Ruby
+ */
+
+ typedef ::boost::intrusive_ptr< ResolverProblem > ResolverProblem_Ptr;
+ %template(ResolverProblem_Ptr) ::boost::intrusive_ptr< ResolverProblem >;
+ typedef std::list< ResolverProblem_Ptr > ResolverProblemList;
+ %template(ResolverProblemList) ::std::list< ResolverProblem_Ptr >;
+
+#endif
+}
+
--- /dev/null
+%include <zypp/ServiceInfo.h>
--- /dev/null
+%include <zypp/SrcPackage.h>;
--- /dev/null
+%ignore zypp::Target::reset;
+#if ZYPP_VERSION > 631
+namespace zypp
+{
+ // Redefine nested class in global scope for SWIG
+ struct DistributionLabel {};
+}
+#endif
+%include <zypp/Target.h>
+namespace zypp
+{
+typedef intrusive_ptr<Target> Target_Ptr;
+%template(Target_Ptr) intrusive_ptr<Target>;
+}
+#if ZYPP_VERSION > 631
+%{
+ namespace zypp
+ {
+ // Tell c++ compiler about SWIGs global class
+ typedef Target::DistributionLabel DistributionLabel;
+ }
+%}
+#endif
\ No newline at end of file
--- /dev/null
+
+// TODO: tell make about dependencies
+%include <zypp/TmpPath.h>
+
--- /dev/null
+%include <zypp/Url.h>
--- /dev/null
+%include <zypp/ZConfig.h>
+
--- /dev/null
+#if ZYPP_VERSION > 615
+#ifdef SWIGRUBY
+%rename("dryRun=") ZYppCommitPolicy::dryRun(bool);
+%rename("rpmNoSignature=") ZYppCommitPolicy::rpmNoSignature(bool);
+%rename("syncPoolAfterCommit=") ZYppCommitPolicy::syncPoolAfterCommit(bool);
+#endif
+
+%include <zypp/DownloadMode.h>
+%include <zypp/ZYppCommitPolicy.h>
+#endif
\ No newline at end of file
--- /dev/null
+%include <zypp/ZYppCommitResult.h>
+
+%extend zypp::ZYppCommitResult
+{
+ std::string asString() const
+ {
+ std::ostringstream str;
+ str << *self;
+ return str.str();
+ }
+}
--- /dev/null
+
+%include <zypp/ZYppFactory.h>
+
+namespace zypp
+{
+typedef intrusive_ptr<ZYpp> ZYpp_Ptr;
+%template(ZYpp_Ptr) intrusive_ptr<ZYpp>;
+}
+
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig/perl5
+#
+# !!Attn!!: This creates two files
+# 1. zypp.so
+# 2. zypp.pm
+# and the .pm file gets loaded.
+#
+
+ENABLE_TESTING()
+ADD_SUBDIRECTORY(tests)
+
+# SWIG_OUPUT is per-target
+SET( SWIG_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libzypp_perl.cc" )
+
+EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{cppflags}" OUTPUT_VARIABLE PERL_CXXFLAGS)
+EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{archlib}.\"/CORE\"" OUTPUT_VARIABLE PERL_CORE_DIR)
+EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{installvendorarch}" OUTPUT_VARIABLE PERL_VENDOR_ARCH)
+EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{installvendorlib}" OUTPUT_VARIABLE PERL_VENDOR_LIB)
+EXECUTE_PROCESS(COMMAND ${PERL_EXECUTABLE} -e "use Config; print \$Config{ccdlflags}" OUTPUT_VARIABLE PERL_LINK_FLAGS)
+
+MESSAGE(STATUS "Perl executable: ${PERL_EXECUTABLE}")
+MESSAGE(STATUS "Perl core dir: ${PERL_CORE_DIR}")
+MESSAGE(STATUS "Perl vendor arch dir: ${PERL_VENDORDIR}")
+
+ADD_DEFINITIONS( ${PERL_CXXFLAGS} -Wno-unused -Wno-error )
+SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${PERL_CXXFLAGS}")
+
+LINK_DIRECTORIES( ${PERL_CORE_DIR} )
+
+if(COMMAND cmake_policy)
+ cmake_policy(SET CMP0003 NEW)
+endif(COMMAND cmake_policy)
+
+ADD_CUSTOM_COMMAND (
+ OUTPUT ${SWIG_OUTPUT}
+ COMMAND ${CMAKE_COMMAND} -E echo_append "Creating wrapper code for perl..."
+ COMMAND ${SWIG_EXECUTABLE} ${SWIG_DEFINITIONS} -c++ -perl5 -o ${SWIG_OUTPUT} -I${ZYPP_INCLUDE_DIR} ${SWIG_INPUT}
+ COMMAND ${CMAKE_COMMAND} -E echo "Done."
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../*.i ${CMAKE_CURRENT_SOURCE_DIR}/../*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.i
+)
+
+ADD_LIBRARY( zypp_perl SHARED ${SWIG_OUTPUT} )
+SET_TARGET_PROPERTIES( zypp_perl
+ PROPERTIES
+ PREFIX ""
+ OUTPUT_NAME zypp
+)
+
+INCLUDE_DIRECTORIES( ${PERL_CORE_DIR} )
+INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/swig )
+INCLUDE_DIRECTORIES( ${ZYPP_INCLUDE_DIR} )
+TARGET_LINK_LIBRARIES( zypp_perl ${ZYPP_LIBRARY} )
+
+INSTALL(TARGETS zypp_perl LIBRARY DESTINATION ${PERL_VENDOR_ARCH})
+INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/zypp.pm DESTINATION ${PERL_VENDOR_LIB})
--- /dev/null
+
+%ignore zypp::Arch_empty;
+
+namespace zypp
+{
+ // These operators must be ignored otherwise the wrapper does
+ // not compile (using swig 1.3.29).
+ %ignore operator<<;
+ %ignore operator==;
+ %ignore operator!=;
+
+ namespace filesystem
+ {
+ // Same as above.
+ %ignore operator==;
+ %ignore operator!=;
+ %ignore operator<<;
+ }
+}
+
+%define iter(cls, storetype)
+%extend cls {
+ cls::const_iterator iterator_incr(cls::const_iterator *it){
+ (*it)++;
+ return *it;
+ }
+ cls::const_iterator iterator_decr(cls::const_iterator *it){
+ (*it)--;
+ return *it;
+ }
+ bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+ return (it1 == it2);
+ }
+ storetype iterator_value(cls::const_iterator it) {
+ return (&**it);
+ }
+ cls::const_iterator cBegin() {
+ return self->begin();
+ }
+ cls::const_iterator cEnd() {
+ return self->end();
+ }
+};
+%enddef
+
+%define iter2(cls, storetype)
+%extend cls {
+ cls::const_iterator iterator_incr(cls::const_iterator *it){
+ ++(*it);
+ return *it;
+ }
+ cls::const_iterator iterator_decr(cls::const_iterator *it){
+ --(*it);
+ return *it;
+ }
+ bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+ return (it1 == it2);
+ }
+ storetype iterator_value(cls::const_iterator it) {
+ return (*it);
+ }
+ cls::const_iterator cBegin() {
+ return self->begin();
+ }
+ cls::const_iterator cEnd() {
+ return self->end();
+ }
+};
+%enddef
+
+// no operator--
+%define forwarditer(cls, storetype)
+%extend cls {
+ cls::const_iterator iterator_incr(cls::const_iterator *it){
+ ++(*it);
+ return *it;
+ }
+ bool iterator_equal(cls::const_iterator it1, cls::const_iterator it2) {
+ return (it1 == it2);
+ }
+ storetype iterator_value(cls::const_iterator it) {
+ return (*it);
+ }
+ cls::const_iterator cBegin() {
+ return self->begin();
+ }
+ cls::const_iterator cEnd() {
+ return self->end();
+ }
+};
+%enddef
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig/perl5/tests
+#
+
+ENABLE_TESTING()
+
+ADD_TEST(bindings_perl_loading perl ${CMAKE_CURRENT_SOURCE_DIR}/loading.pl)
+ADD_TEST(bindings_perl_starting perl ${CMAKE_CURRENT_SOURCE_DIR}/starting.pl)
--- /dev/null
+#!/usr/bin/perl
+
+use FindBin qw($Bin);
+use lib "$Bin/../../../build/swig/perl5";
+
+use zypp;
+
--- /dev/null
+#!/usr/bin/perl
+
+use FindBin qw($Bin);
+use lib "$Bin/../../../build/swig/perl5";
+
+use zypp;
+
+$zfactory = zyppc::ZYppFactory_instance();
+$zypp = $zfactory->getZYpp;
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig/python
+#
+# !!Attn!!: This creates two files
+# 1. zypp.so
+# 2. zypp.py
+# and the .py file gets imported.
+#
+
+ENABLE_TESTING()
+ADD_SUBDIRECTORY(tests)
+
+# SWIG_OUPUT is per-target
+
+SET( SWIG_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libzypp_python.cc" )
+
+FIND_PACKAGE(PythonInterp REQUIRED)
+IF (NOT PYTHON_SITEDIR)
+ EXECUTE_PROCESS(COMMAND ${PYTHON_EXECUTABLE} -c "from sys import stdout; from distutils import sysconfig; stdout.write(sysconfig.get_python_lib(1))" OUTPUT_VARIABLE PYTHON_SITEDIR)
+ENDIF (NOT PYTHON_SITEDIR)
+
+MESSAGE(STATUS "Python executable: ${PYTHON_EXECUTABLE}")
+MESSAGE(STATUS "Python include path: ${PYTHON_INCLUDE_PATH}")
+MESSAGE(STATUS "Python site dir: ${PYTHON_SITEDIR}")
+
+ADD_CUSTOM_COMMAND (
+ OUTPUT ${SWIG_OUTPUT}
+ COMMAND ${CMAKE_COMMAND} -E echo_append "Creating wrapper code for python..."
+ COMMAND ${SWIG_EXECUTABLE} -v ${SWIG_DEFINITIONS} -c++ -python -o ${SWIG_OUTPUT} -I${ZYPP_INCLUDE_DIR} ${SWIG_INPUT}
+ COMMAND ${CMAKE_COMMAND} -E echo "Done."
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../*.i ${CMAKE_CURRENT_SOURCE_DIR}/../*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.i
+)
+
+ADD_LIBRARY( zypp_python SHARED ${SWIG_OUTPUT} )
+SET_TARGET_PROPERTIES( zypp_python
+ PROPERTIES
+ PREFIX ""
+ OUTPUT_NAME _zypp
+)
+
+INCLUDE_DIRECTORIES( ${PYTHON_INCLUDE_PATH} )
+INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/swig )
+INCLUDE_DIRECTORIES( ${ZYPP_INCLUDE_DIR} )
+TARGET_LINK_LIBRARIES( zypp_python ${ZYPP_LIBRARY} )
+
+INSTALL(TARGETS zypp_python LIBRARY DESTINATION ${PYTHON_SITEDIR})
+INSTALL( FILES ${CMAKE_CURRENT_BINARY_DIR}/zypp.py DESTINATION ${PYTHON_SITEDIR})
--- /dev/null
+
+
+%rename *::asString "__str__";
+
+%ignore zypp::Arch_empty;
+
+namespace zypp
+{
+ // These operators must be ignored otherwise the wrapper does
+ // not compile (using swig 1.3.29).
+ %ignore operator==;
+ %ignore operator!=;
+
+ // Just to avoid warnings.
+ %ignore operator<<;
+ namespace repo
+ {
+ // These operators must be ignored otherwise the wrapper does
+ // not compile (using swig 1.3.29).
+ %ignore operator==;
+ %ignore operator!=;
+
+ // Just to avoid warnings.
+ %ignore operator<<;
+ }
+
+}
+
+
+
+%define iter( cls )
+%extend cls {
+ %pythoncode %{
+ def __iter__(self):
+ r = self.range()
+ while not r.empty():
+ yield r.head()
+ r.removeFirst()
+ %}
+};
+%enddef
+
+
+%exception
+{
+ try {
+ $action
+ }
+ catch (const Exception& e) {
+ std::string tmp = e.historyAsString() + e.asUserString();
+ PyErr_SetString(PyExc_RuntimeError, const_cast<char*>(tmp.c_str()));
+ return NULL;
+ }
+}
+
--- /dev/null
+##
+# CMakeLists.txt for libzypp-bindings/swig/python/tests
+#
+
+ENABLE_TESTING()
+
+ADD_TEST(bindings_python_loading python ${CMAKE_CURRENT_SOURCE_DIR}/loading.py)
+ADD_TEST(bindings_python_repoinfo python ${CMAKE_CURRENT_SOURCE_DIR}/repoinfo.py)
+ADD_TEST(bindings_python_commit_callbacks python ${CMAKE_CURRENT_SOURCE_DIR}/commit_callbacks.py)
+ADD_TEST(bindings_python_problems python ${CMAKE_CURRENT_SOURCE_DIR}/problems.py)
+# ADD_TEST(bindings_python_installed_path python ${CMAKE_CURRENT_SOURCE_DIR}/installed_path.py)
--- /dev/null
+#
+# Arch
+#
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+from zypp import Arch
+
+class TestSequenceFunctions(unittest.TestCase):
+
+ def testarch(self):
+ a = Arch("i386")
+ assert a
+ assert "i386" == a.__str__()
+ assert a.is_builtin()
+
+ b = Arch("i486")
+ assert b
+ assert "i486" == b.__str__()
+ assert b.is_builtin()
+ assert a == b.base_arch()
+ assert a < b
+ assert a.compatible_with(b)
+
+ z = Arch("xyzzy")
+ assert z
+ assert "xyzzy" == z.__str__()
+ assert not z.is_builtin()
+
+ assert Arch("noarch") == Arch.noarch()
+ assert a, Arch.i386()
+ assert b, Arch.i486()
+ assert Arch("i586") == Arch.i586()
+ assert Arch("i686") == Arch.i686()
+ assert Arch("x86_64") == Arch.x86_64()
+ assert Arch("ia64") == Arch.ia64()
+ assert Arch("ppc") == Arch.ppc()
+ assert Arch("ppc64") == Arch.ppc64()
+ assert Arch("s390") == Arch.s390()
+ assert Arch("s390x") == Arch.s390x()
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+#
+# Test commit callbacks
+#
+#
+# Callbacks are implemented by calling a specific object function
+#
+# You need
+# - define a (receiver) class which include the function(s) you're interested in.
+# - create an object instance of this class
+# - tell Zypp where to send the callbacks
+#
+# There can only be one receiver instance be active at any time.
+# So if you want to receive different callbacks, define the appropriate
+# functions in the one receiver class
+#
+#
+# See below for sample code
+#
+#
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+import zypp
+
+#
+# This is counting the number of times our callback was called
+# (its just for testing purposes to assert() that the callback was
+# actually run)
+#
+removals = 0
+installs = 0
+
+
+#
+# This is the receiver class.
+# The _class name_ does not matter, but the _function name_ does
+#
+# TODO: provide a complete list of function names and parameters
+#
+# I. Patch message
+# patch_message(zypp::Patch) - show patch message
+#
+# II. Patch script
+# patch_script_start(zypp::Package, String)
+# patch_script_progress(zypp::Notify, String)
+# patch_script_problem(String)
+# patch_script_finish()
+#
+# III. Removal
+# removal_start(zypp::Resolvable) - start of resolvable uninstall
+# removal_progress(zypp::Resolvable, Integer) - progress in percent
+# removal_problem(zypp::Resolvable, zypp::Error, String) - problem report
+# removal_finish(zypp::Resolvable, zypp::Error, String) - uninstall finish
+#
+# IV. Install
+# install_start(zypp::Resolvable) - start of resolvable uninstall
+# install_progress(zypp::Resolvable, Integer) - progress in percent
+# install_problem(zypp::Resolvable, zypp::Error, String) - problem report
+# install_finish(zypp::Resolvable, zypp::Error, String) - uninstall finish
+#
+
+class CommitReceiver:
+
+ ################################
+ # removal callbacks
+
+ #
+ # removal_start() will be called at the beginning of a resolvable (typically package) uninstall
+ # and be passed the resolvable to-be-removed
+ #
+ def removal_start(self, resolvable):
+ # testing: increment the number of removals and print the resolvable
+ global removals
+ removals += 1
+ print "Starting to remove ", resolvable
+
+ #
+ # removal_progress() is called during a resolvable (typically package) uninstall
+ # and be passed the resolvable to-be-removed and a percentage value
+ # Must return True (continue) or False (abort removal)
+ #
+ def removal_progress(self, resolvable, percentage):
+ assert percentage == 42
+ print "Remove of ", resolvable, " at ", percentage, "%"
+ return True
+
+ #
+ # removal_finish() is called after a resolvable (typically package) was uninstalled
+ # and be passed the resolvable just removed and a status (string) with detail (string)
+ # status is either
+ # - "no_error": typical 'good' status
+ # - "not_found": resolvable not found (i.e. not installed)
+ # - "io": (disk) I/O error
+ # - "invalid": any other error
+ #
+ def removal_finish(self, resolvable, status, detail):
+ print "Remove of ", resolvable.name(), " finished with problem ", status, ": ", detail
+
+ #
+ # report a problem during resolvable removal
+ # error is the same as 'status' of removal_finish()
+ #
+ # Must return "abort", "retry" or "ignore"
+ #
+ def removal_problem(self, resolvable, error, description):
+ print "Remove of ", resolvable.name(), " has problem ", error, ": ", description
+ return "ignore"
+
+ ################################
+ # install callbacks
+
+ #
+ # install_start() will be called at the beginning of a resolvable (typically package) install
+ # and be passed the resolvable to-be-installed
+ #
+ def install_start(self, resolvable):
+ # testing: increment the number of removals and print the resolvable
+ global installs
+ installs += 1
+ print "Starting to install ", resolvable
+
+ #
+ # install_progress() is called during a resolvable (typically package) install
+ # and be passed the resolvable to-be-removed and a percentage value
+ # Must return True (continue) or False (abort install)
+ #
+ def install_progress(self, resolvable, percentage):
+ assert percentage == 42
+ print "Install of ", resolvable, " at ", percentage, "%"
+ return True
+
+ #
+ # install_finish() is called after a resolvable (typically package) was installed
+ # and be passed the resolvable just installed and a status (string) with detail (string)
+ # status is either
+ # - "no_error": typical 'good' status
+ # - "not_found": resolvable not found
+ # - "io": (disk) I/O error
+ # - "invalid": any other error
+ #
+ def install_finish(self, resolvable, status, detail):
+ print "Install of ", resolvable.name(), " finished with problem ", status, ": ", detail
+
+ #
+ # report a problem during resolvable install
+ # error is the same as 'status' of install_finish()
+ #
+ # Must return "abort", "retry" or "ignore"
+ #
+ def install_problem(self, resolvable, error, description):
+ print "Install of ", resolvable.name(), " has problem ", error, ": ", description
+ return "ignore"
+
+#
+# Testcase for Callbacks
+#
+
+class CommitCallbacksTestCase(unittest.TestCase):
+ def setUp(self):
+ #
+ # Normal zypp startup
+ #
+ self.Z = zypp.ZYppFactory_instance().getZYpp()
+ self.Z.initializeTarget( zypp.Pathname("/") )
+ self.Z.target().load()
+
+ # The 'zypp.CommitCallbacksEmitter()' is a test/debug class
+ # which can be used to trigger various callbacks
+ # (This is callback test code - we cannot do an actual package uninstall here!)
+ self.commit_callbacks_emitter = zypp.CommitCallbacksEmitter()
+
+ #
+ # create an instance of our CommitReceiver class defined above
+ #
+ self.commit_receiver = CommitReceiver()
+
+ # zypp.CommitCallbacks is the callback 'handler' which must be informed
+ # about the receiver
+ self.commit_callbacks = zypp.CommitCallbacks()
+
+ #
+ # Ensure that no other receiver is registered
+ #
+ assert None == self.commit_callbacks.receiver()
+
+ #
+ # Connect the receiver instance with the callback handler
+ #
+ self.commit_callbacks.connect(self.commit_receiver)
+
+ #
+ # Ensure that its set correctly
+ #
+ assert self.commit_receiver == self.commit_callbacks.receiver()
+
+ def tearDown(self):
+ #
+ # Disconnect the receiver from the callback handler
+ #
+ self.commit_callbacks.disconnect()
+
+ #
+ # Ensure that the disconnect was successful
+ #
+ assert None == self.commit_callbacks.receiver()
+
+ # test patch message
+ def testPatchMessageCallback(self):
+ #
+ # Ugh, this would need a patch with a message :-/
+ #
+ # FIXME
+ assert True
+
+ # test patch script
+ def testPatchScriptCallback(self):
+ #
+ # Ugh, this would need a patch with a script :-/
+ #
+ # FIXME
+ assert True
+
+ # this will test the remove callback
+ def testRemoveCallback(self):
+
+ #
+ # Loop over pool - just to get real instances of Resolvable
+ #
+ for item in self.Z.pool():
+ print "Emitting removal of ", item.resolvable()
+ #
+ # Use the zypp.CommitCallbacksEmitter to fake an actual package removal
+ #
+ resolvable = item.resolvable()
+ self.commit_callbacks_emitter.remove_start(resolvable)
+ self.commit_callbacks_emitter.remove_progress(resolvable, 42)
+# self.commit_callbacks_emitter.remove_problem(resolvable, zypp.REMOVE_NO_ERROR, "All fine")
+# self.commit_callbacks_emitter.remove_finish(resolvable, zypp.REMOVE_NO_ERROR, "Done")
+ break # one is sufficient
+ #
+ # Did the actual callback got executed ?
+ #
+ assert removals == 1
+
+ # this will test the install callback
+ def testInstallCallback(self):
+
+ #
+ # Loop over pool - just to get real instances of Resolvable
+ #
+ for item in self.Z.pool():
+ print "Emitting install of ", item.resolvable()
+ #
+ # Use the zypp.CommitCallbacksEmitter to fake an actual package removal
+ #
+ resolvable = item.resolvable()
+ self.commit_callbacks_emitter.install_start(resolvable)
+ self.commit_callbacks_emitter.install_progress(resolvable, 42)
+# self.commit_callbacks_emitter.install_problem(resolvable, zypp.REMOVE_NO_ERROR, "All fine")
+# self.commit_callbacks_emitter.install_finish(resolvable, zypp.REMOVE_NO_ERROR, "Done")
+ break # one is sufficient
+ #
+ # Did the actual callback got executed ?
+ #
+ assert installs == 1
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+class TestSequenceFunctions(unittest.TestCase):
+
+ def testpath(self):
+ import zypp
+ Z = zypp.ZYppFactory.instance().getZYpp()
+ assert Z
+ Z.initializeTarget( zypp.Pathname("/") )
+ Z.target().load()
+ installed_pkgs = Z.pool()
+ for item in installed_pkgs:
+ if zypp.isKindPackage(item):
+ print "Repopath %s" % item.repoInfo().packagesPath()
+ item = zypp.asKindPackage(item)
+ print "Location filename %s" % item.location().filename()
+ print "%s.%s %s:%d" % (item.name(), item.arch(), item.edition(), item.installSize())
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+class TestSequenceFunctions(unittest.TestCase):
+
+ def testloading(self):
+ import zypp
+
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+class TestSequenceFunctions(unittest.TestCase):
+
+ def testproblems(self):
+ import zypp
+ Z = zypp.ZYppFactory.instance().getZYpp()
+ assert Z
+ if not Z.resolver().resolvePool():
+ for problem in Z.resolver().problems():
+ print "Problem %s" % problem.description()
+# raise "Solver Error"
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+#!/usr/bin/python
+#
+# Author: Jan Blunck <jblunck@suse.de>
+#
+
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+from zypp import RepoInfo, Url, UrlSet, RepoType
+
+repo_urls = [ "file:/mounts/mirror/SuSE/ftp.opensuse.org/srv/ftp/pub/opensuse/debug/update/11.1/",
+ "http://download.opensuse.org/debug/update/11.1/" ]
+
+class RepoInfoTestCase(unittest.TestCase):
+
+ def setUp(self):
+ self.info = RepoInfo()
+ self.info.addBaseUrl(Url(repo_urls[0]))
+ self.info.addBaseUrl(Url(repo_urls[1]))
+ self.info.setAlias("default")
+ self.info.setName("default")
+ self.info.setEnabled(True)
+ self.info.setType(RepoType.RPMMD)
+ self.info.setGpgCheck(False)
+
+ def testUrlSetIsUrlSet(self):
+ urls = UrlSet()
+ assert urls.__class__.__name__ == "UrlSet", 'Incorrect class (' + urls.__class__.__name__ + ')'
+
+ def testUrlSetAppend(self):
+ urls = UrlSet()
+ urls.append(Url(repo_urls[0]))
+ urls.append(Url(repo_urls[1]))
+ assert urls.size() == 2, 'Incorrect size ' + urls.size()
+
+ def testBaseUrlsReturnsTuple(self):
+ baseurls = self.info.baseUrls()
+ assert baseurls.__class__.__name__ == "tuple", 'Incorrect class (' + baseurls.__class__.__name__ + ')'
+
+ def testBaseUrlsIteratable(self):
+ baseurls = self.info.baseUrls()
+ for url in baseurls:
+ assert url.__str__() in repo_urls, 'Incorrect URL ' + url.__str__()
+
+ def testSetBaseUrl(self):
+ baseurls = self.info.baseUrls()
+ assert len(baseurls) == 2
+ self.info.setBaseUrl(Url(repo_urls[0]))
+ baseurls = self.info.baseUrls()
+ assert len(baseurls) == 1
+
+ def testDump(self):
+ out = self.info.dump()
+ assert len(out) == 396, 'Invalid output length %d' % len(out)
+
+ def testDumpIni(self):
+ out = self.info.dumpAsIni()
+ assert len(out) == 208, 'Invalid output length %d' % len(out)
+
+ def testDumpXML(self):
+ out = self.info.dumpAsXML()
+ assert len(out) == 253, 'Invalid output length %d' % len(out)
+
+if __name__ == "__main__":
+ unittest.main()
--- /dev/null
+import unittest
+
+import os
+cwd = os.path.abspath(os.path.dirname(__file__))
+
+import sys
+sys.path.insert(0, cwd + "/../../../build/swig/python")
+
+class TestSequenceFunctions(unittest.TestCase):
+
+ def teststarting(self):
+ import zypp
+ Z = zypp.ZYppFactory.instance().getZYpp()
+ assert Z
+ Z.initializeTarget( zypp.Pathname("/") )
+ Z.target().load();
+
+if __name__ == '__main__':
+ unittest.main()
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig/ruby
+#
+
+ENABLE_TESTING()
+ADD_SUBDIRECTORY(tests)
+
+# SWIG_OUPUT is per-target
+
+SET( SWIG_OUTPUT "${CMAKE_CURRENT_BINARY_DIR}/libzypp_ruby.cc" )
+
+MESSAGE(STATUS "Ruby executable: ${RUBY_EXECUTABLE}")
+MESSAGE(STATUS "Ruby vendor arch dir: ${RUBY_VENDORARCH_DIR}")
+MESSAGE(STATUS "Ruby include path: ${RUBY_INCLUDE_PATH}")
+
+ADD_CUSTOM_COMMAND (
+ OUTPUT "${SWIG_OUTPUT}"
+ COMMAND ${CMAKE_COMMAND} -E echo_append "Creating wrapper code for Ruby..."
+ COMMAND ${SWIG_EXECUTABLE} ${SWIG_DEFINITIONS} -c++ -ruby -o ${SWIG_OUTPUT} -I${ZYPP_INCLUDE_DIR} ${SWIG_INPUT}
+ COMMAND ${CMAKE_COMMAND} -E echo "Done."
+ WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+ DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/../*.i ${CMAKE_CURRENT_SOURCE_DIR}/../*.h ${CMAKE_CURRENT_SOURCE_DIR}/*.i
+)
+
+ADD_LIBRARY( zypp_ruby SHARED ${SWIG_OUTPUT} )
+
+# name it 'zypp.so'
+# and don't prefix with 'lib'
+SET_TARGET_PROPERTIES( zypp_ruby PROPERTIES OUTPUT_NAME "zypp" PREFIX "" )
+
+INCLUDE_DIRECTORIES( ${RUBY_INCLUDE_PATH} )
+INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/swig )
+INCLUDE_DIRECTORIES( ${ZYPP_INCLUDE_DIR} )
+
+TARGET_LINK_LIBRARIES( zypp_ruby ${RUBY_LIBRARY} )
+TARGET_LINK_LIBRARIES( zypp_ruby ${ZYPP_LIBRARY} )
+
+INSTALL(TARGETS zypp_ruby LIBRARY DESTINATION ${RUBY_VENDORARCH_DIR})
+
+#
+# Generate HTML documentation with rdoc
+#
+# This requires rdoc-swig from https://github.com/kkaempf/rdoc-swig
+#
+
+IF(EXISTS ${CMAKE_SOURCE_DIR}/swig/ruby/rdoc)
+SET(rdoc_dir "${CMAKE_CURRENT_BINARY_DIR}/html")
+ADD_CUSTOM_COMMAND (
+ OUTPUT ${rdoc_dir}
+ COMMAND ${CMAKE_COMMAND} -E echo_append "Creating rdoc documentation ..."
+ COMMAND rm -rf ${rdoc_dir}
+ COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/rdoc -o ${rdoc_dir} zypp.i *.i ruby/*.i
+ COMMAND ${CMAKE_COMMAND} -E echo "Done."
+ WORKING_DIRECTORY ${CMAKE_SOURCE_DIR}/swig
+ DEPENDS ${CMAKE_SOURCE_DIR}/swig/*.i ${CMAKE_SOURCE_DIR}/swig/ruby/*.rb ${CMAKE_SOURCE_DIR}/swig/ruby/*.i
+)
+ADD_CUSTOM_TARGET(ruby_rdoc ALL DEPENDS "${rdoc_dir}")
+ENDIF(EXISTS ${CMAKE_SOURCE_DIR}/swig/ruby/rdoc)
+
+#
+# Leave this to %doc in the .spec file
+#INSTALL(DIRECTORY "${rdoc_dir}" DESTINATION ${DOC_INSTALL_DIR})
--- /dev/null
+
+%rename *::asString "to_s";
+
+namespace zypp
+{
+ // Not ignoring gives a very strange error in the "pokus" testsuite: SWIG
+ // defines a Ruby module-function "==" which (when included into the main
+ // namespace) is apparently used where is should not.
+ %ignore operator==;
+
+ // Just to avoid warnings.
+ %ignore operator!=;
+ %ignore operator<<;
+
+ namespace filesystem
+ {
+ // Same as above.
+ %ignore operator==;
+ %ignore operator!=;
+ %ignore operator<<;
+ }
+
+}
+
+/*
+ * Extend cls with an ruby-like each iterator and a to_a method. Yields
+ * objects of type storetype. Parameter storetype must be a pointer type.
+ */
+#define iter2(cls, storetype) \
+%mixin cls "Enumerable"; \
+%extend cls \
+{ \
+ void each() { \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const storetype tmp = &**i; \
+ rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+ i++; \
+ } \
+ } \
+\
+ VALUE to_a() { \
+ VALUE ary = rb_ary_new(); \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const storetype tmp = &**i; \
+ rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+ i++; \
+ } \
+ return ary; \
+ } \
+}
+
+
+/*
+ * Like iter2, but does only one dereferencing from the iterator.
+ */
+#define iter3(cls, storetype) \
+%mixin cls "Enumerable"; \
+%extend cls \
+{ \
+ void each() { \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const storetype tmp = &*i; \
+ rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+ i++; \
+ } \
+ } \
+\
+ VALUE to_a() { \
+ VALUE ary = rb_ary_new(); \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const storetype tmp = &*i; \
+ rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(storetype), 0)); \
+ i++; \
+ } \
+ return ary; \
+ } \
+}
+
+/*
+ * This is for an iterator whichs operator* returns by value (i.e. a temporary).
+ * Like e.g. the Capabilities::const_iterator does. If the compiler warns you are
+ * taking the address of a temporary when using iter3, you most probaly need this one.
+ *
+ */
+#define by_value_iterator(cls) \
+%mixin cls "Enumerable"; \
+%extend cls \
+{ \
+ void each() { \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const cls::value_type* tmp = new cls::value_type( *i ); \
+ rb_yield(SWIG_NewPointerObj((void*) tmp, $descriptor(cls::value_type*), 1)); \
+ i++; \
+ } \
+ } \
+\
+ VALUE to_a() { \
+ VALUE ary = rb_ary_new(); \
+ cls::const_iterator i = self->begin(); \
+ while (i != self->end()) { \
+ const cls::value_type* tmp = new cls::value_type( *i ); \
+ rb_ary_push(ary, SWIG_NewPointerObj((void*) tmp, $descriptor(cls::value_type*), 1)); \
+ i++; \
+ } \
+ return ary; \
+ } \
+}
+
+%exception
+{
+ try {
+ $action
+ }
+ catch (const Exception& e) {
+ static VALUE zyppexception = rb_define_class("ZYppException", rb_eStandardError);
+ std::string tmp = e.historyAsString() + e.asUserString();
+ rb_raise(zyppexception, tmp.c_str());
+ }
+}
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * std_list.i
+ *
+ * SWIG typemaps for std::list
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::list
+//
+// The aim of all that follows would be to integrate std::list with
+// Ruby as much as possible, namely, to allow the user to pass and
+// be returned Ruby arrays
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+//
+// -- f(std::list<T>), f(const std::list<T>&), f(const std::list<T>*):
+// the parameter being read-only, either a Ruby array or a
+// previously wrapped std::list<T> can be passed.
+// -- f(std::list<T>&), f(std::list<T>*):
+// the parameter must be modified; therefore, only a wrapped std::list
+// can be passed.
+// -- std::list<T> f():
+// the list is returned by copy; therefore, a Ruby array of T:s
+// is returned which is most easily used in other Ruby functions
+// -- std::list<T>& f(), std::list<T>* f(), const std::list<T>& f(),
+// const std::list<T>* f():
+// the list is returned by reference; therefore, a wrapped std::list
+// is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <list>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+ %mixin list "Enumerable";
+
+ template<class T> class list {
+ %typemap(in) list<T> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ $1.push_back(*x);
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const list<T>& (std::list<T> temp),
+ const list<T>* (std::list<T> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ temp.push_back(*x);
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+
+ void each() {
+ for ( std::list<T>::const_iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+
+
+ %typemap(out) list<T> {
+ $result = rb_ary_new2($1.size());
+ unsigned int i = 0;
+ for ( std::list<T>::iterator it = $1.begin();
+ it != $1.end();
+ ++it )
+ {
+ T* x = new T((*it));
+ rb_ary_store($result,i,
+ SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 1));
+ ++i;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) list<T> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const list<T>&,
+ const list<T>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ list();
+ list(unsigned int size);
+ list(unsigned int size, const T& value);
+ list(const list<T> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(const T& x);
+ %extend {
+ /*
+ T pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty list");
+ T x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T& __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ void __setitem__(int i, const T& x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ */
+ void each() {
+ for ( std::list<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+
+ // Partial specialization for lists of pointers. [ beazley ]
+
+ %mixin list<T*> "Enumerable";
+ template<class T> class list<T*> {
+ %typemap(in) list<T*> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = std::list<T* >(size);
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ (($1_type &)$1)[i] = x;
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const list<T*>& (std::list<T*> temp),
+ const list<T*>* (std::list<T*> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ temp = std::list<T* >(size);
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ temp[i] = x;
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+ %typemap(out) list<T*> {
+ $result = rb_ary_new2($1.size());
+ for (unsigned int i=0; i<$1.size(); i++) {
+ T* x = (($1_type &)$1)[i];
+ rb_ary_store($result,i,
+ SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) list<T*> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T* >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const list<T*>&,
+ const list<T*>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T* >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ list();
+ list(unsigned int size);
+ list(unsigned int size, T * &value);
+ list(const list<T*> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(T* x);
+ %extend {
+ /*
+ T* pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty list");
+ T* x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T* __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ void __setitem__(int i, T* x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ */
+ void each() {
+ for ( std::list<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+
+
+ // specializations for built-ins
+
+ %define specialize_std_list(T,CHECK,CONVERT_FROM,CONVERT_TO)
+ %mixin list<T> "Enumerable";
+ template<> class list<T> {
+ %typemap(in) list<T> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = std::list<T >(size);
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ if (CHECK(o))
+ (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+ else
+ rb_raise(rb_eTypeError,
+ "wrong argument type"
+ " (expected list<" #T ">)");
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const list<T>& (std::list<T> temp),
+ const list<T>* (std::list<T> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ temp = std::list<T >(size);
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ if (CHECK(o))
+ temp[i] = (T)(CONVERT_FROM(o));
+ else
+ rb_raise(rb_eTypeError,
+ "wrong argument type"
+ " (expected list<" #T ">)");
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+ %typemap(out) list<T> {
+ $result = rb_ary_new2($1.size());
+ for (unsigned int i=0; i<$1.size(); i++)
+ rb_ary_store($result,i,CONVERT_TO((($1_type &)$1)[i]));
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) list<T> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ VALUE o = RARRAY($input)->ptr[0];
+ if (CHECK(o))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const list<T>&,
+ const list<T>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ VALUE o = RARRAY($input)->ptr[0];
+ if (CHECK(o))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped list? */
+ std::list<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ list();
+ list(unsigned int size);
+ list(unsigned int size, const T& value);
+ list(const list<T> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) push_back;
+ void push_back(T x);
+ %extend {
+ /*
+ T pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty list");
+ T x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ void __setitem__(int i, T x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("list index out of range");
+ }
+ */
+ void each() {
+ for ( std::list<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+ %enddef
+
+ specialize_std_list(bool,SWIG_BOOL_P,SWIG_RB2BOOL,SWIG_BOOL2RB);
+ specialize_std_list(char,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(int,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(short,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(long,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(unsigned char,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(unsigned int,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(unsigned short,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(unsigned long,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_list(double,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+ specialize_std_list(float,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+ specialize_std_list(std::string,SWIG_STRING_P,SWIG_RB2STR,SWIG_STR2RB);
+
+}
+
--- /dev/null
+/* -----------------------------------------------------------------------------
+ * See the LICENSE file for information on copyright, usage and redistribution
+ * of SWIG, and the README file for authors - http://www.swig.org/release.html.
+ *
+ * std_set.i
+ *
+ * SWIG typemaps for std::set
+ * ----------------------------------------------------------------------------- */
+
+%include <std_common.i>
+
+// ------------------------------------------------------------------------
+// std::set
+//
+// The aim of all that follows would be to integrate std::set with
+// Ruby as much as possible, namely, to allow the user to pass and
+// be returned Ruby arrays
+// const declarations are used to guess the intent of the function being
+// exported; therefore, the following rationale is applied:
+//
+// -- f(std::set<T>), f(const std::set<T>&), f(const std::set<T>*):
+// the parameter being read-only, either a Ruby array or a
+// previously wrapped std::set<T> can be passed.
+// -- f(std::set<T>&), f(std::set<T>*):
+// the parameter must be modified; therefore, only a wrapped std::set
+// can be passed.
+// -- std::set<T> f():
+// the set is returned by copy; therefore, a Ruby array of T:s
+// is returned which is most easily used in other Ruby functions
+// -- std::set<T>& f(), std::set<T>* f(), const std::set<T>& f(),
+// const std::set<T>* f():
+// the set is returned by reference; therefore, a wrapped std::set
+// is returned
+// ------------------------------------------------------------------------
+
+%{
+#include <set>
+#include <algorithm>
+#include <stdexcept>
+%}
+
+// exported class
+
+namespace std {
+
+ %mixin set "Enumerable";
+
+ template<class T> class set {
+ %typemap(in) set<T> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ $1.insert(*x);
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const set<T>& (std::set<T> temp),
+ const set<T>* (std::set<T> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ temp.insert(*x);
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+
+ void each() {
+ for ( std::set<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = (T *) &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+
+
+ %typemap(out) set<T> {
+ $result = rb_ary_new2($1.size());
+ unsigned int i = 0;
+ for ( std::set<T>::iterator it = $1.begin();
+ it != $1.end();
+ ++it )
+ {
+ T* x = new T((*it));
+ rb_ary_store($result,i,
+ SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 1));
+ ++i;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) set<T> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const set<T>&,
+ const set<T>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ set();
+ set(const set<T> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) insert;
+ void insert(const T& x);
+ %extend {
+ /*
+ T pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty set");
+ T x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T& __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ void __setitem__(int i, const T& x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ */
+ void each() {
+ for ( std::set<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = (T *)&(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+
+ // Partial specialization for sets of pointers. [ beazley ]
+
+ %mixin set<T*> "Enumerable";
+ template<class T> class set<T*> {
+ %typemap(in) set<T*> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = std::set<T* >(size);
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ (($1_type &)$1)[i] = x;
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const set<T*>& (std::set<T*> temp),
+ const set<T*>* (std::set<T*> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ temp = std::set<T* >(size);
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ T* x;
+ SWIG_ConvertPtr(o, (void **) &x, $descriptor(T *), 1);
+ temp[i] = x;
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+ %typemap(out) set<T*> {
+ $result = rb_ary_new2($1.size());
+ for (unsigned int i=0; i<$1.size(); i++) {
+ T* x = (($1_type &)$1)[i];
+ rb_ary_store($result,i,
+ SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) set<T*> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T* >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const set<T*>&,
+ const set<T*>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ T* x;
+ VALUE o = RARRAY($input)->ptr[0];
+ if ((SWIG_ConvertPtr(o,(void **) &x,
+ $descriptor(T *),0)) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T* >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ set();
+ set(const set<T*> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) insert;
+ void insert(T* x);
+ %extend {
+ /*
+ T* pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty set");
+ T* x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T* __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ void __setitem__(int i, T* x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ */
+ void each() {
+ for ( std::set<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = (T*) &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+
+
+ // specializations for built-ins
+
+ %define specialize_std_set(T,CHECK,CONVERT_FROM,CONVERT_TO)
+ %mixin set<T> "Enumerable";
+ template<> class set<T> {
+ %typemap(in) set<T> {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ $1 = std::set<T >(size);
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ if (CHECK(o))
+ (($1_type &)$1)[i] = (T)(CONVERT_FROM(o));
+ else
+ rb_raise(rb_eTypeError,
+ "wrong argument type"
+ " (expected set<" #T ">)");
+ }
+ } else {
+ void *ptr;
+ SWIG_ConvertPtr($input, &ptr, $&1_descriptor, 1);
+ $1 = *(($&1_type) ptr);
+ }
+ }
+ %typemap(in) const set<T>& (std::set<T> temp),
+ const set<T>* (std::set<T> temp) {
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ temp = std::set<T >(size);
+ $1 = &temp;
+ for (unsigned int i=0; i<size; i++) {
+ VALUE o = RARRAY($input)->ptr[i];
+ if (CHECK(o))
+ temp[i] = (T)(CONVERT_FROM(o));
+ else
+ rb_raise(rb_eTypeError,
+ "wrong argument type"
+ " (expected set<" #T ">)");
+ }
+ } else {
+ SWIG_ConvertPtr($input, (void **) &$1, $1_descriptor, 1);
+ }
+ }
+ %typemap(out) set<T> {
+ $result = rb_ary_new2($1.size());
+ for (unsigned int i=0; i<$1.size(); i++)
+ rb_ary_store($result,i,CONVERT_TO((($1_type &)$1)[i]));
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) set<T> {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ VALUE o = RARRAY($input)->ptr[0];
+ if (CHECK(o))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $&1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ %typecheck(SWIG_TYPECHECK_VECTOR) const set<T>&,
+ const set<T>* {
+ /* native sequence? */
+ if (rb_obj_is_kind_of($input,rb_cArray)) {
+ unsigned int size = RARRAY($input)->len;
+ if (size == 0) {
+ /* an empty sequence can be of any type */
+ $1 = 1;
+ } else {
+ /* check the first element only */
+ VALUE o = RARRAY($input)->ptr[0];
+ if (CHECK(o))
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ } else {
+ /* wrapped set? */
+ std::set<T >* v;
+ if (SWIG_ConvertPtr($input,(void **) &v,
+ $1_descriptor,0) != -1)
+ $1 = 1;
+ else
+ $1 = 0;
+ }
+ }
+ public:
+ set();
+ set(const set<T> &);
+
+ %rename(__len__) size;
+ unsigned int size() const;
+ %rename("empty?") empty;
+ bool empty() const;
+ void clear();
+ %rename(push) insert;
+ void insert(T x);
+ %extend {
+ /*
+ T pop() throw (std::out_of_range) {
+ if (self->size() == 0)
+ throw std::out_of_range("pop from empty set");
+ T x = self->back();
+ self->pop_back();
+ return x;
+ }
+ T __getitem__(int i) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i += size;
+ if (i>=0 && i<size)
+ return (*self)[i];
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ void __setitem__(int i, T x) throw (std::out_of_range) {
+ int size = int(self->size());
+ if (i<0) i+= size;
+ if (i>=0 && i<size)
+ (*self)[i] = x;
+ else
+ throw std::out_of_range("set index out of range");
+ }
+ */
+ void each() {
+ for ( std::set<T>::iterator it = self->begin();
+ it != self->end();
+ ++it )
+ {
+ T* x = &(*it);
+ rb_yield(SWIG_NewPointerObj((void *) x,
+ $descriptor(T *), 0));
+ }
+ }
+ }
+ };
+ %enddef
+
+ specialize_std_set(bool,SWIG_BOOL_P,SWIG_RB2BOOL,SWIG_BOOL2RB);
+ specialize_std_set(char,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(int,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(short,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(long,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(unsigned char,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(unsigned int,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(unsigned short,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(unsigned long,FIXNUM_P,FIX2INT,INT2NUM);
+ specialize_std_set(double,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+ specialize_std_set(float,SWIG_FLOAT_P,SWIG_NUM2DBL,rb_float_new);
+ specialize_std_set(std::string,SWIG_STRING_P,SWIG_RB2STR,SWIG_STR2RB);
+
+}
+
--- /dev/null
+#
+# CMakeLists.txt for libzypp-bindings/swig/ruby/tests
+#
+
+ENABLE_TESTING()
+
+ADD_TEST(bindings_ruby_loading ruby -C ${CMAKE_CURRENT_SOURCE_DIR} loading.rb)
+ADD_TEST(bindings_ruby_arch.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} arch.rb)
+ADD_TEST(bindings_ruby_bytecount.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} bytecount.rb)
+ADD_TEST(bindings_ruby_starting.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} starting.rb)
+ADD_TEST(bindings_ruby_target.rb ruby -C ${CMAKE_CURRENT_SOURCE_DIR} target.rb)
--- /dev/null
+#
+# Arch
+#
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__),"..","..","..","build","swig","ruby"))
+
+require 'test/unit'
+require 'zypp'
+
+class Zypp::Arch
+ include Comparable
+end
+
+class ArchTest < Test::Unit::TestCase
+ include Zypp
+ def test_arch
+ # define i386, a builtin
+
+ a = Arch.new("i386")
+ assert a
+ assert_equal "i386", a.to_s
+ assert_equal true, a.is_builtin
+
+ # i486 is 'bigger' than i386
+
+ b = Arch.new("i486")
+ assert b
+ assert_equal "i486", b.to_s
+ assert b.is_builtin
+ if VERSION > 800
+ assert_equal a, b.base_arch
+ end
+ assert a < b
+ assert a.compatible_with?(b)
+
+ # A new, adventurous architecture
+ z = Arch.new("xyzzy")
+ assert z
+ assert_equal "xyzzy", z.to_s
+ assert_equal false, z.is_builtin
+
+ # predefined archs
+ assert_equal Arch.new("noarch"), Arch.noarch
+ assert_equal a, Arch.i386
+ assert_equal b, Arch.i486
+ assert_equal Arch.new("i586"), Arch.i586
+ assert_equal Arch.new("i686"), Arch.i686
+ assert_equal Arch.new("x86_64"), Arch.x86_64
+ assert_equal Arch.new("ia64"), Arch.ia64
+ assert_equal Arch.new("ppc"), Arch.ppc
+ assert_equal Arch.new("ppc64"), Arch.ppc64
+ assert_equal Arch.new("s390"), Arch.s390
+ assert_equal Arch.new("s390x"), Arch.s390x
+ end
+end
--- /dev/null
+#
+# Test Bytecount
+#
+
+$:.unshift "../../../build/swig/ruby"
+
+
+# test loading of extension
+require 'test/unit'
+
+class LoadTest < Test::Unit::TestCase
+ require 'zypp'
+ include Zypp
+
+ def test_bytecount
+ g = ByteCount.new(ByteCount.G)
+ assert g
+ gb = ByteCount.new(ByteCount.GB)
+ assert gb
+ k = ByteCount.new(ByteCount.K)
+ assert k.to_i == 1024
+ mb = ByteCount.new(ByteCount.MB)
+ assert mb.to_i == 1000*1000
+ end
+end
--- /dev/null
+#
+# Test commit callbacks
+#
+
+$:.unshift "../../../build/swig/ruby"
+
+
+require 'test/unit'
+require 'zypp'
+
+class CommitReceiver
+ # Define class function, we pass the class (not an instance of the class)
+ # to the CommitCallbacks
+ def self.removal_start resolvable
+ $stderr.puts "Starting to remove #{resolvable}"
+ end
+end
+
+class CommitCallbacksTest < Test::Unit::TestCase
+ def test_removal_callback
+ commit_callbacks = Zypp::CommitCallbacks.new
+ assert_equal nil, commit_callbacks.receiver
+ # In Ruby the class is also an object, so we connect to the class
+ commit_callbacks.connect CommitReceiver
+ assert_equal CommitReceiver, commit_callbacks.receiver
+
+ z = Zypp::ZYppFactory::instance.getZYpp
+
+ z.initializeTarget(Zypp::Pathname.new("/"))
+ t = z.target
+ t.load
+ t.buildCache
+
+ emitter = Zypp::CommitCallbacksEmitter.new
+ p = z.pool
+ p.each do |item|
+ puts "Emitting removal of ", item
+ puts item.methods.inspect
+ emitter.remove_start(item)
+ break
+ end
+
+ commit_callbacks.disconnect
+ assert_equal nil, commit_callbacks.receiver
+ end
+end
--- /dev/null
+#
+# Test loading of the bindings
+#
+
+$:.unshift "../../../build/swig/ruby"
+
+
+# test loading of extension
+require 'test/unit'
+
+class LoadTest < Test::Unit::TestCase
+ def test_loading
+ require 'zypp'
+ assert true
+ end
+end
--- /dev/null
+#
+# Test starting of zypp
+#
+
+$:.unshift "../../../build/swig/ruby"
+
+
+# test loading of extension
+require 'test/unit'
+
+class LoadTest < Test::Unit::TestCase
+ def test_loading
+ require 'zypp'
+ zypp = Zypp::ZYppFactory::instance.getZYpp
+ assert zypp
+ zconfig = Zypp::ZConfig::instance
+ assert zconfig
+ puts zconfig.systemArchitecture
+ zconfig.setSystemArchitecture(Zypp::Arch.new("i686"))
+ puts zconfig.systemArchitecture
+ end
+end
--- /dev/null
+#
+# Example for target
+#
+
+$:.unshift "../../../build/swig/ruby"
+
+
+# test loading of extension
+require 'test/unit'
+
+class LoadTest < Test::Unit::TestCase
+ require 'zypp'
+ include Zypp
+ def test_target
+ z = ZYppFactory::instance.getZYpp
+
+ assert z.homePath
+ assert z.tmpPath
+
+ z.initializeTarget(Zypp::Pathname.new("/"))
+ t = z.target
+ assert t
+ t.load
+ t.buildCache
+
+ p = z.pool
+ assert p
+ assert p.size > 0
+
+ # Iterate over pool, gives PoolItems
+ i = 0
+ puts "#{p.size} PoolItems:"
+ p.each do | pi |
+ i = i + 1
+ break if i > 10
+ puts pi
+ # PoolItems have status and a resolvable
+# r = pi.resolvable
+# puts "#{r.name}-#{r.edition}"
+ end
+
+ assert true
+ end
+end
--- /dev/null
+%module zypp
+
+/* set this to 0 (zero) to only create a subset of the bindings
+ * for testing
+ */
+#define PRODUCTION 1
+
+#ifdef SWIGPERL5
+%{
+ #undef NORMAL
+ #undef readdir
+ #undef Fflush
+ #undef Mkdir
+ #undef strerror
+%}
+#endif
+
+%{
+/* Includes the header in the wrapper code */
+#ifdef SWIGRUBY
+#define REG_EXTENDED 1
+#define REG_ICASE (REG_EXTENDED << 1)
+#define REG_NEWLINE (REG_ICASE << 1)
+#define REG_NOSUB (REG_NEWLINE << 1)
+#endif
+
+/*
+ * type definitions to keep the C code generic
+ */
+
+#if defined(SWIGPYTHON)
+#define Target_Null_p(x) (x == Py_None)
+#define Target_INCREF(x) Py_INCREF(x)
+#define Target_DECREF(x) Py_DECREF(x)
+#define Target_True Py_True
+#define Target_False Py_False
+#define Target_Null Py_None
+#define Target_Type PyObject*
+#define Target_Bool(x) PyBool_FromLong(x)
+#define Target_WChar(x) PyInt_FromLong(x)
+#define Target_Int(x) PyInt_FromLong(x)
+#define Target_String(x) PyString_FromString(x)
+#define Target_Real(x) Py_None
+#define Target_Array() PyList_New(0)
+#define Target_SizedArray(len) PyList_New(len)
+#define Target_Append(x,y) PyList_Append(x,y)
+#define Target_DateTime(x) Py_None
+#include <Python.h>
+#define TARGET_THREAD_BEGIN_BLOCK SWIG_PYTHON_THREAD_BEGIN_BLOCK
+#define TARGET_THREAD_END_BLOCK SWIG_PYTHON_THREAD_END_BLOCK
+#define TARGET_THREAD_BEGIN_ALLOW SWIG_PYTHON_THREAD_BEGIN_ALLOW
+#define TARGET_THREAD_END_ALLOW SWIG_PYTHON_THREAD_END_ALLOW
+#endif
+
+#if defined(SWIGRUBY)
+#define Target_Null_p(x) NIL_P(x)
+#define Target_INCREF(x)
+#define Target_DECREF(x)
+#define Target_True Qtrue
+#define Target_False Qfalse
+#define Target_Null Qnil
+#define Target_Type VALUE
+#define Target_Bool(x) ((x)?Qtrue:Qfalse)
+#define Target_WChar(x) INT2FIX(x)
+#define Target_Int(x) INT2FIX(x)
+#define Target_String(x) rb_str_new2(x)
+#define Target_Real(x) rb_float_new(x)
+#define Target_Array() rb_ary_new()
+#define Target_SizedArray(len) rb_ary_new2(len)
+#define Target_Append(x,y) rb_ary_push(x,y)
+#define Target_DateTime(x) Qnil
+#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+#define TARGET_THREAD_END_BLOCK do {} while(0)
+#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+#define TARGET_THREAD_END_ALLOW do {} while(0)
+#include <ruby.h>
+#include <rubyio.h>
+#endif
+
+#if defined(SWIGPERL)
+#define TARGET_THREAD_BEGIN_BLOCK do {} while(0)
+#define TARGET_THREAD_END_BLOCK do {} while(0)
+#define TARGET_THREAD_BEGIN_ALLOW do {} while(0)
+#define TARGET_THREAD_END_ALLOW do {} while(0)
+
+SWIGINTERNINLINE SV *SWIG_From_long SWIG_PERL_DECL_ARGS_1(long value);
+SWIGINTERNINLINE SV *SWIG_FromCharPtr(const char *cptr);
+SWIGINTERNINLINE SV *SWIG_From_double SWIG_PERL_DECL_ARGS_1(double value);
+
+#define Target_Null_p(x) (x == NULL)
+#define Target_INCREF(x)
+#define Target_DECREF(x)
+#define Target_True (&PL_sv_yes)
+#define Target_False (&PL_sv_no)
+#define Target_Null NULL
+#define Target_Type SV *
+#define Target_Bool(x) (x)?Target_True:Target_False
+#define Target_WChar(x) NULL
+#define Target_Int(x) SWIG_From_long(x)
+#define Target_String(x) SWIG_FromCharPtr(x)
+#define Target_Real(x) SWIG_From_double(x)
+#define Target_Array() (SV *)newAV()
+#define Target_SizedArray(len) (SV *)newAV()
+#define Target_Append(x,y) av_push(((AV *)(x)), y)
+#define Target_DateTime(x) NULL
+#include <perl.h>
+#include <EXTERN.h>
+#endif
+
+
+#include <sstream>
+#include "zypp/base/PtrTypes.h"
+#include "zypp/base/ReferenceCounted.h"
+#include "zypp/Edition.h"
+#include "zypp/Pathname.h"
+#include "zypp/ResTraits.h"
+#include "zypp/ZYppFactory.h"
+#include "zypp/ZYpp.h"
+
+#include "zypp/ResObjects.h"
+#include "zypp/Target.h"
+#include "zypp/target/TargetImpl.h"
+#include "zypp/MediaSetAccess.h"
+#include "zypp/ResFilters.h"
+#include "zypp/OnMediaLocation.h"
+#include "zypp/Repository.h"
+#include "zypp/ServiceInfo.h"
+#include "zypp/RepoManager.h"
+#include "zypp/repo/RepoType.h"
+#include "zypp/TmpPath.h"
+#include "zypp/Resolver.h"
+#include "zypp/pool/GetResolvablesToInsDel.h"
+
+#include "zypp/Product.h"
+
+using namespace boost;
+using namespace zypp;
+using namespace zypp::repo;
+using namespace zypp::resfilter;
+using namespace zypp::filesystem;
+
+typedef std::list<std::string> StringList;
+
+%}
+
+/* prevent swig from creating a type called 'Target_Type' */
+#if defined(SWIGRUBY)
+#define Target_Type VALUE
+#endif
+#if defined(SWIGPYTHON)
+#define Target_Type PyObject*
+#endif
+#if defined(SWIGPERL)
+#define Target_Type SV *
+#endif
+
+#ifdef SWIGRUBY
+%include "ruby/std_list.i"
+%include "ruby/std_set.i"
+%include "ruby/ruby.i"
+#endif
+
+#ifdef SWIGPYTHON
+%include "std_list.i"
+%include "std_set.i"
+%include "python/python.i"
+#endif
+
+#ifdef SWIGPERL5
+%include "std_list.i"
+%include "perl5/perl.i"
+#endif
+
+#define VERSION ZYPP_VERSION
+
+/* These include files are pending to be cleaned up from C++ cruft */
+#if PRODUCTION /* set 0 for testing, these files still carry the full C++ cruft */
+
+%nodefault ByKind;
+
+%rename("+") "operator+";
+%rename("<<") "operator<<";
+%rename("!=") "operator!=";
+%rename("!") "operator!";
+%rename("==") "operator==";
+
+namespace zypp {
+ namespace base {
+ // silence 'Nothing known about class..' warning
+ class ReferenceCounted {};
+ }
+}
+
+%include "std_string.i"
+%include "stl.i"
+
+#ifdef BOOST_SMARTPTR_INCLUDE_DIR
+%import <boost/smart_ptr/scoped_ptr.hpp>
+%import <boost/smart_ptr/shared_ptr.hpp>
+%import <boost/smart_ptr/weak_ptr.hpp>
+%import <boost/smart_ptr/intrusive_ptr.hpp>
+#else
+%import <boost/scoped_ptr.hpp>
+%import <boost/shared_ptr.hpp>
+%import <boost/weak_ptr.hpp>
+%import <boost/intrusive_ptr.hpp>
+#endif
+%import <zypp/base/PtrTypes.h>
+%import <zypp/base/Flags.h>
+
+%include "IdStringType.i"
+%include "Pathname.i"
+%include "ByteCount.i"
+%include "Url.i"
+%include "NeedAType.i"
+%include "Edition.i"
+%include "Kind.i"
+%include "CheckSum.i"
+%include "Date.i"
+%include "Dep.i"
+%include "Capability.i"
+%include "Capabilities.i"
+%include "CapMatch.i"
+%include "OnMediaLocation.i"
+%include "Resolvable.i"
+%include "RepoType.i"
+%include "RepoInfo.i"
+%include "ServiceInfo.i"
+%include "ResTraits.i"
+%include "ResStatus.i"
+%include "ResObject.i"
+%include "Package.i"
+%include "Patch.i"
+%include "Pattern.i"
+%include "Product.i"
+%include "SrcPackage.i"
+%include "Repository.i"
+%include "RepoStatus.i"
+%include "RepoManager.i"
+%include "PublicKey.i"
+%include "KeyRing.i"
+%include "Target.i"
+%include "MediaSetAccess.i"
+%include "PoolItem.i"
+%include "ResPool.i"
+%include "ZYppCommitPolicy.i"
+%include "ZYppCommitResult.i"
+%include "TmpPath.i"
+%include "Resolver.i"
+%include "ZConfig.i"
+
+%ignore zypp::ZYpp::setTextLocale;
+%ignore zypp::ZYpp::getTextLocale;
+%ignore zypp::ZYpp::setRequestedLocales;
+%ignore zypp::ZYpp::getRequestedLocales;
+%ignore zypp::ZYpp::getAvailableLocales;
+%ignore zypp::ZYpp::architecture;
+%ignore zypp::ZYpp::setArchitecture;
+%ignore zypp::ZYpp::applyLocks;
+
+%include <zypp/ZYpp.h>
+
+%include "ZYppFactory.i"
+#endif
+
+%include "Arch.i"
+%include "Callbacks.i"
+
+//
+// helper
+//
+%{
+#include <zypp/base/LogControl.h>
+%}
+%inline %{
+ namespace zypp
+ {
+ void setZyppLogfile( const std::string & file_r )
+ {
+ base::LogControl::instance().logfile( file_r );
+ }
+ }
+%}
projects / external / libzypp-bindings.git / commitdiff