From 1886482c77eb334fc32f1ff8ecce3aebd3e868c6 Mon Sep 17 00:00:00 2001 From: Jinkun Jang Date: Wed, 13 Mar 2013 01:44:06 +0900 Subject: [PATCH] Tizen 2.1 base --- CMakeLists.txt | 75 ++ README | 20 + VERSION.cmake | 3 + examples/perl/list_target_resolvables.pl | 34 + examples/perl/test.pl | 64 + examples/python/bytecount.py | 10 + examples/python/date.py | 10 + examples/python/exception.py | 25 + examples/python/install_updates_dryrun.py | 68 + examples/python/keyring.py | 35 + examples/python/list_resolvables.py | 33 + examples/python/loading.py | 7 + examples/python/url.py | 21 + examples/ruby/bytecount.rb | 11 + examples/ruby/exception.rb | 35 + examples/ruby/keyring.rb | 32 + examples/ruby/list_target_resolvables.rb | 34 + examples/ruby/mediasetaccess_example.rb | 14 + examples/ruby/parse1.rb | 64 + examples/ruby/parse2.rb | 64 + examples/ruby/play_with_pool_and_target.rb | 21 + examples/ruby/play_with_repos.rb | 19 + examples/ruby/test.rb | 25 + examples/ruby/test2.rb | 18 + examples/ruby/url.rb | 22 + examples/testImports.sh | 21 + libzypp-bindings.spec.cmake | 108 ++ packaging/libzypp-bindings.changes | 142 ++ packaging/libzypp-bindings.spec | 75 ++ packaging/meego-add-more-class.patch | 111 ++ packaging/remove-perl-binding.patch | 1885 +++++++++++++++++++++++++++ packaging/support-armv7-architectures.patch | 26 + swig/Arch.i | 238 ++++ swig/ByteCount.i | 49 + swig/CMakeLists.txt | 29 + swig/Callbacks.i | 613 +++++++++ swig/CapMatch.i | 1 + swig/Capabilities.i | 10 + swig/Capability.i | 22 + swig/CheckSum.i | 2 + swig/CommitCallbacks.h | 193 +++ swig/Date.i | 3 + swig/Dep.i | 3 + swig/Edition.i | 18 + swig/IdStringType.i | 2 + swig/KeyRing.i | 27 + swig/Kind.i | 5 + swig/MediaSetAccess.i | 3 + swig/NeedAType.i | 7 + swig/OnMediaLocation.i | 2 + swig/Package.i | 4 + swig/Patch.i | 5 + swig/Pathname.i | 12 + swig/Pattern.i | 1 + swig/PoolItem.i | 23 + swig/Product.i | 2 + swig/PublicKey.i | 1 + swig/RepoInfo.i | 56 + swig/RepoManager.i | 1 + swig/RepoStatus.i | 1 + swig/RepoType.i | 1 + swig/Repository.i | 3 + swig/ResObject.i | 13 + swig/ResPool.i | 92 ++ swig/ResStatus.i | 28 + swig/ResTraits.i | 77 ++ swig/Resolvable.i | 4 + swig/Resolver.i | 27 + swig/ServiceInfo.i | 1 + swig/SrcPackage.i | 1 + swig/Target.i | 23 + swig/TmpPath.i | 4 + swig/Url.i | 1 + swig/ZConfig.i | 2 + swig/ZYppCommitPolicy.i | 10 + swig/ZYppCommitResult.i | 11 + swig/ZYppFactory.i | 9 + swig/perl5/CMakeLists.txt | 57 + swig/perl5/perl.i | 91 ++ swig/perl5/tests/CMakeLists.txt | 8 + swig/perl5/tests/loading.pl | 7 + swig/perl5/tests/starting.pl | 9 + swig/python/CMakeLists.txt | 48 + swig/python/python.i | 55 + swig/python/tests/CMakeLists.txt | 11 + swig/python/tests/arch.py | 46 + swig/python/tests/commit_callbacks.py | 273 ++++ swig/python/tests/installed_path.py | 27 + swig/python/tests/loading.py | 16 + swig/python/tests/problems.py | 21 + swig/python/tests/repoinfo.py | 70 + swig/python/tests/starting.py | 19 + swig/ruby/CMakeLists.txt | 62 + swig/ruby/ruby.i | 125 ++ swig/ruby/std_list.i | 533 ++++++++ swig/ruby/std_set.i | 527 ++++++++ swig/ruby/tests/CMakeLists.txt | 11 + swig/ruby/tests/arch.rb | 55 + swig/ruby/tests/bytecount.rb | 25 + swig/ruby/tests/commit_callbacks.rb | 46 + swig/ruby/tests/loading.rb | 16 + swig/ruby/tests/starting.rb | 22 + swig/ruby/tests/target.rb | 44 + swig/zypp.i | 283 ++++ 104 files changed, 7279 insertions(+) create mode 100644 CMakeLists.txt create mode 100644 README create mode 100644 VERSION.cmake create mode 100644 examples/perl/list_target_resolvables.pl create mode 100644 examples/perl/test.pl create mode 100755 examples/python/bytecount.py create mode 100755 examples/python/date.py create mode 100755 examples/python/exception.py create mode 100755 examples/python/install_updates_dryrun.py create mode 100755 examples/python/keyring.py create mode 100755 examples/python/list_resolvables.py create mode 100644 examples/python/loading.py create mode 100755 examples/python/url.py create mode 100755 examples/ruby/bytecount.rb create mode 100755 examples/ruby/exception.rb create mode 100755 examples/ruby/keyring.rb create mode 100755 examples/ruby/list_target_resolvables.rb create mode 100755 examples/ruby/mediasetaccess_example.rb create mode 100755 examples/ruby/parse1.rb create mode 100755 examples/ruby/parse2.rb create mode 100755 examples/ruby/play_with_pool_and_target.rb create mode 100755 examples/ruby/play_with_repos.rb create mode 100755 examples/ruby/test.rb create mode 100755 examples/ruby/test2.rb create mode 100755 examples/ruby/url.rb create mode 100755 examples/testImports.sh create mode 100644 libzypp-bindings.spec.cmake create mode 100644 packaging/libzypp-bindings.changes create mode 100644 packaging/libzypp-bindings.spec create mode 100644 packaging/meego-add-more-class.patch create mode 100644 packaging/remove-perl-binding.patch create mode 100644 packaging/support-armv7-architectures.patch create mode 100644 swig/Arch.i create mode 100644 swig/ByteCount.i create mode 100644 swig/CMakeLists.txt create mode 100644 swig/Callbacks.i create mode 100644 swig/CapMatch.i create mode 100644 swig/Capabilities.i create mode 100644 swig/Capability.i create mode 100644 swig/CheckSum.i create mode 100644 swig/CommitCallbacks.h create mode 100644 swig/Date.i create mode 100644 swig/Dep.i create mode 100644 swig/Edition.i create mode 100644 swig/IdStringType.i create mode 100644 swig/KeyRing.i create mode 100644 swig/Kind.i create mode 100644 swig/MediaSetAccess.i create mode 100644 swig/NeedAType.i create mode 100644 swig/OnMediaLocation.i create mode 100644 swig/Package.i create mode 100644 swig/Patch.i create mode 100644 swig/Pathname.i create mode 100644 swig/Pattern.i create mode 100644 swig/PoolItem.i create mode 100644 swig/Product.i create mode 100644 swig/PublicKey.i create mode 100644 swig/RepoInfo.i create mode 100644 swig/RepoManager.i create mode 100644 swig/RepoStatus.i create mode 100644 swig/RepoType.i create mode 100644 swig/Repository.i create mode 100644 swig/ResObject.i create mode 100644 swig/ResPool.i create mode 100644 swig/ResStatus.i create mode 100644 swig/ResTraits.i create mode 100644 swig/Resolvable.i create mode 100644 swig/Resolver.i create mode 100644 swig/ServiceInfo.i create mode 100644 swig/SrcPackage.i create mode 100644 swig/Target.i create mode 100644 swig/TmpPath.i create mode 100644 swig/Url.i create mode 100644 swig/ZConfig.i create mode 100644 swig/ZYppCommitPolicy.i create mode 100644 swig/ZYppCommitResult.i create mode 100644 swig/ZYppFactory.i create mode 100644 swig/perl5/CMakeLists.txt create mode 100644 swig/perl5/perl.i create mode 100644 swig/perl5/tests/CMakeLists.txt create mode 100644 swig/perl5/tests/loading.pl create mode 100644 swig/perl5/tests/starting.pl create mode 100644 swig/python/CMakeLists.txt create mode 100644 swig/python/python.i create mode 100644 swig/python/tests/CMakeLists.txt create mode 100644 swig/python/tests/arch.py create mode 100644 swig/python/tests/commit_callbacks.py create mode 100644 swig/python/tests/installed_path.py create mode 100644 swig/python/tests/loading.py create mode 100644 swig/python/tests/problems.py create mode 100644 swig/python/tests/repoinfo.py create mode 100644 swig/python/tests/starting.py create mode 100644 swig/ruby/CMakeLists.txt create mode 100644 swig/ruby/ruby.i create mode 100644 swig/ruby/std_list.i create mode 100644 swig/ruby/std_set.i create mode 100644 swig/ruby/tests/CMakeLists.txt create mode 100644 swig/ruby/tests/arch.rb create mode 100644 swig/ruby/tests/bytecount.rb create mode 100644 swig/ruby/tests/commit_callbacks.rb create mode 100644 swig/ruby/tests/loading.rb create mode 100644 swig/ruby/tests/starting.rb create mode 100644 swig/ruby/tests/target.rb create mode 100644 swig/zypp.i diff --git a/CMakeLists.txt b/CMakeLists.txt new file mode 100644 index 0000000..622e8cc --- /dev/null +++ b/CMakeLists.txt @@ -0,0 +1,75 @@ +# +# 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) + diff --git a/README b/README new file mode 100644 index 0000000..bfe1fde --- /dev/null +++ b/README @@ -0,0 +1,20 @@ + +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("/") + diff --git a/VERSION.cmake b/VERSION.cmake new file mode 100644 index 0000000..98f5dd9 --- /dev/null +++ b/VERSION.cmake @@ -0,0 +1,3 @@ +SET(VERSION_MAJOR "0") +SET(VERSION_MINOR "5") +SET(VERSION_PATCH "10") diff --git a/examples/perl/list_target_resolvables.pl b/examples/perl/list_target_resolvables.pl new file mode 100644 index 0000000..61cd765 --- /dev/null +++ b/examples/perl/list_target_resolvables.pl @@ -0,0 +1,34 @@ +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"; + +} diff --git a/examples/perl/test.pl b/examples/perl/test.pl new file mode 100644 index 0000000..dfab9d0 --- /dev/null +++ b/examples/perl/test.pl @@ -0,0 +1,64 @@ +use zypp; +use rpdbtozypp; + +$z = zyppc::ZYppFactory_instance(); +$zypp = $z->getZYpp; +$pdb = rpdbtozypp::PdbToZypp->new; +print "Package to install: "; +$ipkg = ; +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"; + } + } +} diff --git a/examples/python/bytecount.py b/examples/python/bytecount.py new file mode 100755 index 0000000..912fa05 --- /dev/null +++ b/examples/python/bytecount.py @@ -0,0 +1,10 @@ +#!/usr/bin/python + +from zypp import ByteCount + +print ByteCount(ByteCount.G) +print ByteCount(ByteCount.GB) + +x = ByteCount(ByteCount.K) +print int(x) + diff --git a/examples/python/date.py b/examples/python/date.py new file mode 100755 index 0000000..965d2f3 --- /dev/null +++ b/examples/python/date.py @@ -0,0 +1,10 @@ +#!/usr/bin/python + +from zypp import Date + +print Date() + +d = Date.now() +print d +print d.form("%F %T") + diff --git a/examples/python/exception.py b/examples/python/exception.py new file mode 100755 index 0000000..9b7e6ec --- /dev/null +++ b/examples/python/exception.py @@ -0,0 +1,25 @@ +#!/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" + diff --git a/examples/python/install_updates_dryrun.py b/examples/python/install_updates_dryrun.py new file mode 100755 index 0000000..ba1a134 --- /dev/null +++ b/examples/python/install_updates_dryrun.py @@ -0,0 +1,68 @@ +#! /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 diff --git a/examples/python/keyring.py b/examples/python/keyring.py new file mode 100755 index 0000000..83cf5ff --- /dev/null +++ b/examples/python/keyring.py @@ -0,0 +1,35 @@ +#!/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 + diff --git a/examples/python/list_resolvables.py b/examples/python/list_resolvables.py new file mode 100755 index 0000000..8138390 --- /dev/null +++ b/examples/python/list_resolvables.py @@ -0,0 +1,33 @@ +#! /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( ) ) diff --git a/examples/python/loading.py b/examples/python/loading.py new file mode 100644 index 0000000..b688d84 --- /dev/null +++ b/examples/python/loading.py @@ -0,0 +1,7 @@ +# test loading of pywsman +import sys + +# cmake build dir +sys.path.insert(0, '../../build/swig/python') + +import zypp diff --git a/examples/python/url.py b/examples/python/url.py new file mode 100755 index 0000000..07c772c --- /dev/null +++ b/examples/python/url.py @@ -0,0 +1,21 @@ +#!/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 + diff --git a/examples/ruby/bytecount.rb b/examples/ruby/bytecount.rb new file mode 100755 index 0000000..56393a8 --- /dev/null +++ b/examples/ruby/bytecount.rb @@ -0,0 +1,11 @@ +#!/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 + diff --git a/examples/ruby/exception.rb b/examples/ruby/exception.rb new file mode 100755 index 0000000..346d2d3 --- /dev/null +++ b/examples/ruby/exception.rb @@ -0,0 +1,35 @@ +#!/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 + diff --git a/examples/ruby/keyring.rb b/examples/ruby/keyring.rb new file mode 100755 index 0000000..6aee8e0 --- /dev/null +++ b/examples/ruby/keyring.rb @@ -0,0 +1,32 @@ +#!/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 + diff --git a/examples/ruby/list_target_resolvables.rb b/examples/ruby/list_target_resolvables.rb new file mode 100755 index 0000000..c9bbe29 --- /dev/null +++ b/examples/ruby/list_target_resolvables.rb @@ -0,0 +1,34 @@ +#!/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 + diff --git a/examples/ruby/mediasetaccess_example.rb b/examples/ruby/mediasetaccess_example.rb new file mode 100755 index 0000000..4a8cb91 --- /dev/null +++ b/examples/ruby/mediasetaccess_example.rb @@ -0,0 +1,14 @@ +#!/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 + diff --git a/examples/ruby/parse1.rb b/examples/ruby/parse1.rb new file mode 100755 index 0000000..90500c9 --- /dev/null +++ b/examples/ruby/parse1.rb @@ -0,0 +1,64 @@ +#!/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 + diff --git a/examples/ruby/parse2.rb b/examples/ruby/parse2.rb new file mode 100755 index 0000000..373077c --- /dev/null +++ b/examples/ruby/parse2.rb @@ -0,0 +1,64 @@ +#!/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 + diff --git a/examples/ruby/play_with_pool_and_target.rb b/examples/ruby/play_with_pool_and_target.rb new file mode 100755 index 0000000..2642e82 --- /dev/null +++ b/examples/ruby/play_with_pool_and_target.rb @@ -0,0 +1,21 @@ +#!/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 + diff --git a/examples/ruby/play_with_repos.rb b/examples/ruby/play_with_repos.rb new file mode 100755 index 0000000..d134176 --- /dev/null +++ b/examples/ruby/play_with_repos.rb @@ -0,0 +1,19 @@ +#!/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 + diff --git a/examples/ruby/test.rb b/examples/ruby/test.rb new file mode 100755 index 0000000..7b63c45 --- /dev/null +++ b/examples/ruby/test.rb @@ -0,0 +1,25 @@ +#!/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 diff --git a/examples/ruby/test2.rb b/examples/ruby/test2.rb new file mode 100755 index 0000000..2bafee5 --- /dev/null +++ b/examples/ruby/test2.rb @@ -0,0 +1,18 @@ +#!/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 + diff --git a/examples/ruby/url.rb b/examples/ruby/url.rb new file mode 100755 index 0000000..81f3848 --- /dev/null +++ b/examples/ruby/url.rb @@ -0,0 +1,22 @@ +#!/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}" + diff --git a/examples/testImports.sh b/examples/testImports.sh new file mode 100755 index 0000000..79cb92a --- /dev/null +++ b/examples/testImports.sh @@ -0,0 +1,21 @@ +#! /bin/bash + +echo "====Ruby=========" +ruby <getZYpp; +EOF \ No newline at end of file diff --git a/libzypp-bindings.spec.cmake b/libzypp-bindings.spec.cmake new file mode 100644 index 0000000..4c7d92f --- /dev/null +++ b/libzypp-bindings.spec.cmake @@ -0,0 +1,108 @@ +# +# 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 diff --git a/packaging/libzypp-bindings.changes b/packaging/libzypp-bindings.changes new file mode 100644 index 0000000..452aaa5 --- /dev/null +++ b/packaging/libzypp-bindings.changes @@ -0,0 +1,142 @@ +* Tue Dec 20 2011 Zhang Qiang - 0.5.9.1 +- depend special version of libzypp for opensuse 11.4 and 11.3 + +* Mon Oct 24 2011 Zhang Qiang - 0.5.9 +- Add loadSolvFile API to load solv file + +* Sun Sep 18 2011 Zhang Qiang - 0.5.9 +- Add CapNames to return provides info +- Add a patch to provide PoolQuery interface. + +* Fri Sep 02 2011 Gui Chen - 0.5.9 +- Update to 0.5.9 + +* Mon Aug 01 2011 Gui Chen - 0.5.8 +- Added armv7tnhl and armv7thl support + +* Fri Jan 21 2011 Marko Saukko - 0.5.8 +- Added armv7hl and armv7nhl architectures (BMC#12713) + +* Tue Jan 04 2011 Yi Yang - 0.5.8 +- Support builtin arm architectures + +* Fri Dec 17 2010 Yi Yang - 0.5.8 +- Update to 0.5.8 + +* Thu Nov 25 2010 Yi Yang - 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 diff --git a/packaging/libzypp-bindings.spec b/packaging/libzypp-bindings.spec new file mode 100644 index 0000000..a7c4af2 --- /dev/null +++ b/packaging/libzypp-bindings.spec @@ -0,0 +1,75 @@ +# +# 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* diff --git a/packaging/meego-add-more-class.patch b/packaging/meego-add-more-class.patch new file mode 100644 index 0000000..dae84d7 --- /dev/null +++ b/packaging/meego-add-more-class.patch @@ -0,0 +1,111 @@ +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 ++%include "std_vector.i" ++namespace std { ++ %template(PoolItemVector) vector; ++} ++namespace zypp ++{ ++ namespace detail ++ { ++ %ignore operator<<; ++ } ++} ++%{ ++#include ++using std::vector; ++%} ++ ++#ifdef SWIGPYTHON ++%extend zypp::PoolQuery { ++std::vector queryResults (zypp::ResPool pool) ++{ ++#define for_(IT,BEG,END) for ( typeof(BEG) IT = BEG; IT != END; ++IT ) ++ std::vector 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 ++ ++#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 +\ No newline at end of file ++%ignore zypp::operator<<; ++%include +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 +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; diff --git a/packaging/remove-perl-binding.patch b/packaging/remove-perl-binding.patch new file mode 100644 index 0000000..b49b59b --- /dev/null +++ b/packaging/remove-perl-binding.patch @@ -0,0 +1,1885 @@ +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::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), f(const std::list&), f(const std::list*): +-// the parameter being read-only, either a Ruby array or a +-// previously wrapped std::list can be passed. +-// -- f(std::list&), f(std::list*): +-// the parameter must be modified; therefore, only a wrapped std::list +-// can be passed. +-// -- std::list 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& f(), std::list* f(), const std::list& f(), +-// const std::list* f(): +-// the list is returned by reference; therefore, a wrapped std::list +-// is returned +-// ------------------------------------------------------------------------ +- +-%{ +-#include +-#include +-#include +-%} +- +-// exported class +- +-namespace std { +- +- %mixin list "Enumerable"; +- +- template class list { +- %typemap(in) list { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1; +- for (unsigned int i=0; iptr[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& (std::list temp), +- const list* (std::list temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = &temp; +- for (unsigned int i=0; iptr[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::const_iterator it = self->begin(); +- it != self->end(); +- ++it ) +- { +- T* x = &(*it); +- rb_yield(SWIG_NewPointerObj((void *) x, +- $descriptor(T *), 0)); +- } +- } +- +- +- %typemap(out) list { +- $result = rb_ary_new2($1.size()); +- unsigned int i = 0; +- for ( std::list::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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const list&, +- const list* { +- /* 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* 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 &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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 "Enumerable"; +- template class list { +- %typemap(in) list { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = std::list(size); +- for (unsigned int i=0; iptr[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& (std::list temp), +- const list* (std::list temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- temp = std::list(size); +- $1 = &temp; +- for (unsigned int i=0; iptr[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 { +- $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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const list&, +- const list* { +- /* 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* 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 &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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 "Enumerable"; +- template<> class list { +- %typemap(in) list { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = std::list(size); +- for (unsigned int i=0; iptr[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& (std::list temp), +- const list* (std::list temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- temp = std::list(size); +- $1 = &temp; +- for (unsigned int i=0; iptr[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 { +- $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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const list&, +- const list* { +- /* 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* 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 &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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::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), f(const std::set&), f(const std::set*): +-// the parameter being read-only, either a Ruby array or a +-// previously wrapped std::set can be passed. +-// -- f(std::set&), f(std::set*): +-// the parameter must be modified; therefore, only a wrapped std::set +-// can be passed. +-// -- std::set 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& f(), std::set* f(), const std::set& f(), +-// const std::set* f(): +-// the set is returned by reference; therefore, a wrapped std::set +-// is returned +-// ------------------------------------------------------------------------ +- +-%{ +-#include +-#include +-#include +-%} +- +-// exported class +- +-namespace std { +- +- %mixin set "Enumerable"; +- +- template class set { +- %typemap(in) set { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1; +- for (unsigned int i=0; iptr[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& (std::set temp), +- const set* (std::set temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = &temp; +- for (unsigned int i=0; iptr[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::iterator it = self->begin(); +- it != self->end(); +- ++it ) +- { +- T* x = (T *) &(*it); +- rb_yield(SWIG_NewPointerObj((void *) x, +- $descriptor(T *), 0)); +- } +- } +- +- +- %typemap(out) set { +- $result = rb_ary_new2($1.size()); +- unsigned int i = 0; +- for ( std::set::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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const set&, +- const set* { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- public: +- set(); +- set(const set &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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 "Enumerable"; +- template class set { +- %typemap(in) set { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = std::set(size); +- for (unsigned int i=0; iptr[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& (std::set temp), +- const set* (std::set temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- temp = std::set(size); +- $1 = &temp; +- for (unsigned int i=0; iptr[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 { +- $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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const set&, +- const set* { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- public: +- set(); +- set(const set &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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 "Enumerable"; +- template<> class set { +- %typemap(in) set { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- $1 = std::set(size); +- for (unsigned int i=0; iptr[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& (std::set temp), +- const set* (std::set temp) { +- if (rb_obj_is_kind_of($input,rb_cArray)) { +- unsigned int size = RARRAY($input)->len; +- temp = std::set(size); +- $1 = &temp; +- for (unsigned int i=0; iptr[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 { +- $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 { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $&1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- %typecheck(SWIG_TYPECHECK_VECTOR) const set&, +- const set* { +- /* 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* v; +- if (SWIG_ConvertPtr($input,(void **) &v, +- $1_descriptor,0) != -1) +- $1 = 1; +- else +- $1 = 0; +- } +- } +- public: +- set(); +- set(const set &); +- +- %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 && isize()); +- if (i<0) i+= size; +- if (i>=0 && i::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 +-#include +-#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 +-#include +-#endif +- +- + #include + #include "zypp/base/PtrTypes.h" + #include "zypp/base/ReferenceCounted.h" +@@ -144,33 +71,15 @@ typedef std::list 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 */ diff --git a/packaging/support-armv7-architectures.patch b/packaging/support-armv7-architectures.patch new file mode 100644 index 0000000..bf2f45e --- /dev/null +++ b/packaging/support-armv7-architectures.patch @@ -0,0 +1,26 @@ +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 + */ diff --git a/swig/Arch.i b/swig/Arch.i new file mode 100644 index 0000000..1129197 --- /dev/null +++ b/swig/Arch.i @@ -0,0 +1,238 @@ +/* + * 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(); + } +} diff --git a/swig/ByteCount.i b/swig/ByteCount.i new file mode 100644 index 0000000..03f17c6 --- /dev/null +++ b/swig/ByteCount.i @@ -0,0 +1,49 @@ + + +#ifdef SWIGRUBY + +namespace zypp +{ + // how to do that? + // %rename "ByteCount::operator SizeType()" to_i; +} + +#endif + + +// TODO: tell make about dependencies +%include + + +#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 + diff --git a/swig/CMakeLists.txt b/swig/CMakeLists.txt new file mode 100644 index 0000000..efa48c4 --- /dev/null +++ b/swig/CMakeLists.txt @@ -0,0 +1,29 @@ +# +# 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) diff --git a/swig/Callbacks.i b/swig/Callbacks.i new file mode 100644 index 0000000..9a91ddb --- /dev/null +++ b/swig/Callbacks.i @@ -0,0 +1,613 @@ +/* + * Callbacks.i + * + * Callback glue code + * + * Author: Klaus Kaempf + * + */ + + +/* + * Commit callbacks + * + */ + +%{ +#include +#include +/* + * 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 +{ + + 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 +{ + + 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 +{ + + 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 +{ + + 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" + diff --git a/swig/CapMatch.i b/swig/CapMatch.i new file mode 100644 index 0000000..f9f4117 --- /dev/null +++ b/swig/CapMatch.i @@ -0,0 +1 @@ +%include diff --git a/swig/Capabilities.i b/swig/Capabilities.i new file mode 100644 index 0000000..88e5c30 --- /dev/null +++ b/swig/Capabilities.i @@ -0,0 +1,10 @@ + +%include + +#ifdef SWIGRUBY +by_value_iterator(zypp::Capabilities); +#endif + +#ifdef SWIGPERL5 +forwarditer(zypp::Capabilities, zypp::Capability); +#endif diff --git a/swig/Capability.i b/swig/Capability.i new file mode 100644 index 0000000..4d574b5 --- /dev/null +++ b/swig/Capability.i @@ -0,0 +1,22 @@ +// 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 + +%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; + } +} + + diff --git a/swig/CheckSum.i b/swig/CheckSum.i new file mode 100644 index 0000000..0a0add8 --- /dev/null +++ b/swig/CheckSum.i @@ -0,0 +1,2 @@ +%include + diff --git a/swig/CommitCallbacks.h b/swig/CommitCallbacks.h new file mode 100644 index 0000000..6df36be --- /dev/null +++ b/swig/CommitCallbacks.h @@ -0,0 +1,193 @@ +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 _install_resolvable; + callback::SendReport _remove_resolvable; + callback::SendReport _patch_message; + callback::SendReport _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 diff --git a/swig/Date.i b/swig/Date.i new file mode 100644 index 0000000..f436832 --- /dev/null +++ b/swig/Date.i @@ -0,0 +1,3 @@ + +// TODO: tell make about dependencies +%include diff --git a/swig/Dep.i b/swig/Dep.i new file mode 100644 index 0000000..9fce196 --- /dev/null +++ b/swig/Dep.i @@ -0,0 +1,3 @@ + +%nodefault Dep; +%include "zypp/Dep.h" diff --git a/swig/Edition.i b/swig/Edition.i new file mode 100644 index 0000000..db08090 --- /dev/null +++ b/swig/Edition.i @@ -0,0 +1,18 @@ +// 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; +%include diff --git a/swig/IdStringType.i b/swig/IdStringType.i new file mode 100644 index 0000000..ef67a56 --- /dev/null +++ b/swig/IdStringType.i @@ -0,0 +1,2 @@ +%include +%include diff --git a/swig/KeyRing.i b/swig/KeyRing.i new file mode 100644 index 0000000..dd938fc --- /dev/null +++ b/swig/KeyRing.i @@ -0,0 +1,27 @@ + +%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 +%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_Ptr; + %template(KeyRing_Ptr) intrusive_ptr; +} + +%template(List_PublicKey) std::list; diff --git a/swig/Kind.i b/swig/Kind.i new file mode 100644 index 0000000..7f71dfc --- /dev/null +++ b/swig/Kind.i @@ -0,0 +1,5 @@ + +%ignore zypp::ResKind::satIdent( const std::string & name_r ) const; + +%template(IdStringResKind) zypp::IdStringType; +%include diff --git a/swig/MediaSetAccess.i b/swig/MediaSetAccess.i new file mode 100644 index 0000000..5775d28 --- /dev/null +++ b/swig/MediaSetAccess.i @@ -0,0 +1,3 @@ + +%include + diff --git a/swig/NeedAType.i b/swig/NeedAType.i new file mode 100644 index 0000000..23192ce --- /dev/null +++ b/swig/NeedAType.i @@ -0,0 +1,7 @@ + +typedef std::string Label; + +typedef std::string Text; + +typedef std::string Vendor; + diff --git a/swig/OnMediaLocation.i b/swig/OnMediaLocation.i new file mode 100644 index 0000000..d2b633f --- /dev/null +++ b/swig/OnMediaLocation.i @@ -0,0 +1,2 @@ + +%include \ No newline at end of file diff --git a/swig/Package.i b/swig/Package.i new file mode 100644 index 0000000..734c59d --- /dev/null +++ b/swig/Package.i @@ -0,0 +1,4 @@ +//%ignore zypp::Package::checksum(); + +%include + diff --git a/swig/Patch.i b/swig/Patch.i new file mode 100644 index 0000000..acd62b4 --- /dev/null +++ b/swig/Patch.i @@ -0,0 +1,5 @@ +%ignore zypp::Patch::reboot_needed; +%ignore zypp::Patch::affects_pkg_manager; +%ignore zypp::Patch::id; + +%include \ No newline at end of file diff --git a/swig/Pathname.i b/swig/Pathname.i new file mode 100644 index 0000000..6b7305b --- /dev/null +++ b/swig/Pathname.i @@ -0,0 +1,12 @@ +// 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 diff --git a/swig/Pattern.i b/swig/Pattern.i new file mode 100644 index 0000000..3d88887 --- /dev/null +++ b/swig/Pattern.i @@ -0,0 +1 @@ +%include \ No newline at end of file diff --git a/swig/PoolItem.i b/swig/PoolItem.i new file mode 100644 index 0000000..34a2eeb --- /dev/null +++ b/swig/PoolItem.i @@ -0,0 +1,23 @@ +%include + +#ifdef SWIGPERL5 +#else +%template(PoolItemSet) std::set; +#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(); + } +} diff --git a/swig/Product.i b/swig/Product.i new file mode 100644 index 0000000..4b8ce3f --- /dev/null +++ b/swig/Product.i @@ -0,0 +1,2 @@ +%ignore zypp::Product::type; +%include diff --git a/swig/PublicKey.i b/swig/PublicKey.i new file mode 100644 index 0000000..3f4341f --- /dev/null +++ b/swig/PublicKey.i @@ -0,0 +1 @@ +%include \ No newline at end of file diff --git a/swig/RepoInfo.i b/swig/RepoInfo.i new file mode 100644 index 0000000..f86a254 --- /dev/null +++ b/swig/RepoInfo.i @@ -0,0 +1,56 @@ +#ifdef SWIGPERL5 +#else +%template(UrlSet) std::set; +#endif + +namespace zypp +{ + namespace repo + { + %ignore operator==; + %ignore operator!=; + %ignore operator<<; + %ignore operator<; + } + typedef std::list 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 + +// 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 +typedef std::list RepoInfoList; +%template(RepoInfoList) std::list; + +%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(); + } +} diff --git a/swig/RepoManager.i b/swig/RepoManager.i new file mode 100644 index 0000000..8f7870d --- /dev/null +++ b/swig/RepoManager.i @@ -0,0 +1 @@ +%include diff --git a/swig/RepoStatus.i b/swig/RepoStatus.i new file mode 100644 index 0000000..8f89dae --- /dev/null +++ b/swig/RepoStatus.i @@ -0,0 +1 @@ +%include \ No newline at end of file diff --git a/swig/RepoType.i b/swig/RepoType.i new file mode 100644 index 0000000..d9f1164 --- /dev/null +++ b/swig/RepoType.i @@ -0,0 +1 @@ +%include \ No newline at end of file diff --git a/swig/Repository.i b/swig/Repository.i new file mode 100644 index 0000000..e7a2ecb --- /dev/null +++ b/swig/Repository.i @@ -0,0 +1,3 @@ +%ignore zypp::Repository::name; + +%include diff --git a/swig/ResObject.i b/swig/ResObject.i new file mode 100644 index 0000000..d25b6ef --- /dev/null +++ b/swig/ResObject.i @@ -0,0 +1,13 @@ +%ignore zypp::make_res_object; +%ignore zypp::ResObject::installsize; +%ignore zypp::ResObject::size; + +%include + +%extend intrusive_ptr +{ + int __cmp__(intrusive_ptr& other) + { + return *self == other; + } +} diff --git a/swig/ResPool.i b/swig/ResPool.i new file mode 100644 index 0000000..c57f57c --- /dev/null +++ b/swig/ResPool.i @@ -0,0 +1,92 @@ +// 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 + +%ignore zypp::pool::operator<<; +%include +namespace zypp +{ + typedef ::std::list PoolItemList; + %template(PoolItemList) ::std::list; +} + +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 + +} diff --git a/swig/ResStatus.i b/swig/ResStatus.i new file mode 100644 index 0000000..e91df8c --- /dev/null +++ b/swig/ResStatus.i @@ -0,0 +1,28 @@ + +%include + +#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(); + } +} diff --git a/swig/ResTraits.i b/swig/ResTraits.i new file mode 100644 index 0000000..664113d --- /dev/null +++ b/swig/ResTraits.i @@ -0,0 +1,77 @@ + +/** Base of ResTraits. Defines the Resolvable::Kind type. */ +/*struct ResolvableTraits +{ + typedef KindOf KindType; +};*/ + +namespace zypp +{ + /** ResTraits. Defines common types and the Kind value. */ + template + struct ResTraits + { + typedef zypp::intrusive_ptr<_Res> PtrType; + typedef zypp::intrusive_ptr constPtrType; + }; + + typedef intrusive_ptr ResObject_constPtr; + typedef intrusive_ptr ResObject_Ptr; + %template(ResObject_constPtr) intrusive_ptr; + %template(ResObject_Ptr) intrusive_ptr; + +} + +%template(ResTraitsResolvable) zypp::ResTraits; +%template(ResTraitsResObject) zypp::ResTraits; + +// 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 X##_constPtr; + typedef intrusive_ptr X##_Ptr; + %template(X##_constPtr) intrusive_ptr; + %template(X##_Ptr) intrusive_ptr; + + 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( p ); } + inline bool isKind##X( const zypp::PoolItem & p ) + { return isKind( p.resolvable() ); } + inline X::constPtr asKind##X( const zypp::Resolvable::constPtr & p ) + { return asKind( p ); } + inline X::constPtr asKind##X( const zypp::PoolItem & p ) + { return asKind( p.resolvable() ); } + } +} + +#if defined(SWIGPYTHON) +%pythoncode +{ + def KindOf##X(): + return KindOfResolvable( #X ) +} +#endif +%enddef + +%STUFF(Package) +%STUFF(Patch) +%STUFF(SrcPackage) +%STUFF(Pattern) +%STUFF(Product) diff --git a/swig/Resolvable.i b/swig/Resolvable.i new file mode 100644 index 0000000..7055b9f --- /dev/null +++ b/swig/Resolvable.i @@ -0,0 +1,4 @@ +%ignore zypp::make; +%import +%include + diff --git a/swig/Resolver.i b/swig/Resolver.i new file mode 100644 index 0000000..2d1f402 --- /dev/null +++ b/swig/Resolver.i @@ -0,0 +1,27 @@ +#ifdef SWIGPERL5 + %template(StringList) std::list; +#endif + +%include +%include +%include +%include + +namespace zypp +{ + typedef intrusive_ptr< Resolver > Resolver_Ptr; + %template(Resolver_Ptr) intrusive_ptr; + +#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 +} + diff --git a/swig/ServiceInfo.i b/swig/ServiceInfo.i new file mode 100644 index 0000000..fb9004f --- /dev/null +++ b/swig/ServiceInfo.i @@ -0,0 +1 @@ +%include diff --git a/swig/SrcPackage.i b/swig/SrcPackage.i new file mode 100644 index 0000000..b239fe6 --- /dev/null +++ b/swig/SrcPackage.i @@ -0,0 +1 @@ +%include ; diff --git a/swig/Target.i b/swig/Target.i new file mode 100644 index 0000000..0c81a33 --- /dev/null +++ b/swig/Target.i @@ -0,0 +1,23 @@ +%ignore zypp::Target::reset; +#if ZYPP_VERSION > 631 +namespace zypp +{ + // Redefine nested class in global scope for SWIG + struct DistributionLabel {}; +} +#endif +%include +namespace zypp +{ +typedef intrusive_ptr Target_Ptr; +%template(Target_Ptr) intrusive_ptr; +} +#if ZYPP_VERSION > 631 +%{ + namespace zypp + { + // Tell c++ compiler about SWIGs global class + typedef Target::DistributionLabel DistributionLabel; + } +%} +#endif \ No newline at end of file diff --git a/swig/TmpPath.i b/swig/TmpPath.i new file mode 100644 index 0000000..d8b2ea8 --- /dev/null +++ b/swig/TmpPath.i @@ -0,0 +1,4 @@ + +// TODO: tell make about dependencies +%include + diff --git a/swig/Url.i b/swig/Url.i new file mode 100644 index 0000000..e3a65b3 --- /dev/null +++ b/swig/Url.i @@ -0,0 +1 @@ +%include diff --git a/swig/ZConfig.i b/swig/ZConfig.i new file mode 100644 index 0000000..d4b6c08 --- /dev/null +++ b/swig/ZConfig.i @@ -0,0 +1,2 @@ +%include + diff --git a/swig/ZYppCommitPolicy.i b/swig/ZYppCommitPolicy.i new file mode 100644 index 0000000..b0bce36 --- /dev/null +++ b/swig/ZYppCommitPolicy.i @@ -0,0 +1,10 @@ +#if ZYPP_VERSION > 615 +#ifdef SWIGRUBY +%rename("dryRun=") ZYppCommitPolicy::dryRun(bool); +%rename("rpmNoSignature=") ZYppCommitPolicy::rpmNoSignature(bool); +%rename("syncPoolAfterCommit=") ZYppCommitPolicy::syncPoolAfterCommit(bool); +#endif + +%include +%include +#endif \ No newline at end of file diff --git a/swig/ZYppCommitResult.i b/swig/ZYppCommitResult.i new file mode 100644 index 0000000..ef5cae4 --- /dev/null +++ b/swig/ZYppCommitResult.i @@ -0,0 +1,11 @@ +%include + +%extend zypp::ZYppCommitResult +{ + std::string asString() const + { + std::ostringstream str; + str << *self; + return str.str(); + } +} diff --git a/swig/ZYppFactory.i b/swig/ZYppFactory.i new file mode 100644 index 0000000..1c1d676 --- /dev/null +++ b/swig/ZYppFactory.i @@ -0,0 +1,9 @@ + +%include + +namespace zypp +{ +typedef intrusive_ptr ZYpp_Ptr; +%template(ZYpp_Ptr) intrusive_ptr; +} + diff --git a/swig/perl5/CMakeLists.txt b/swig/perl5/CMakeLists.txt new file mode 100644 index 0000000..df226a4 --- /dev/null +++ b/swig/perl5/CMakeLists.txt @@ -0,0 +1,57 @@ +# +# 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 new file mode 100644 index 0000000..8c60f30 --- /dev/null +++ b/swig/perl5/perl.i @@ -0,0 +1,91 @@ + +%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 new file mode 100644 index 0000000..af6e7a7 --- /dev/null +++ b/swig/perl5/tests/CMakeLists.txt @@ -0,0 +1,8 @@ +# +# 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 new file mode 100644 index 0000000..0f45c2d --- /dev/null +++ b/swig/perl5/tests/loading.pl @@ -0,0 +1,7 @@ +#!/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 new file mode 100644 index 0000000..09d3954 --- /dev/null +++ b/swig/perl5/tests/starting.pl @@ -0,0 +1,9 @@ +#!/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/python/CMakeLists.txt b/swig/python/CMakeLists.txt new file mode 100644 index 0000000..284bcb0 --- /dev/null +++ b/swig/python/CMakeLists.txt @@ -0,0 +1,48 @@ +# +# 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}) diff --git a/swig/python/python.i b/swig/python/python.i new file mode 100644 index 0000000..139cc2d --- /dev/null +++ b/swig/python/python.i @@ -0,0 +1,55 @@ + + +%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(tmp.c_str())); + return NULL; + } +} + diff --git a/swig/python/tests/CMakeLists.txt b/swig/python/tests/CMakeLists.txt new file mode 100644 index 0000000..932da25 --- /dev/null +++ b/swig/python/tests/CMakeLists.txt @@ -0,0 +1,11 @@ +## +# 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) diff --git a/swig/python/tests/arch.py b/swig/python/tests/arch.py new file mode 100644 index 0000000..524d217 --- /dev/null +++ b/swig/python/tests/arch.py @@ -0,0 +1,46 @@ +# +# 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() diff --git a/swig/python/tests/commit_callbacks.py b/swig/python/tests/commit_callbacks.py new file mode 100644 index 0000000..24a1ff3 --- /dev/null +++ b/swig/python/tests/commit_callbacks.py @@ -0,0 +1,273 @@ +# +# 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() diff --git a/swig/python/tests/installed_path.py b/swig/python/tests/installed_path.py new file mode 100644 index 0000000..95cecd7 --- /dev/null +++ b/swig/python/tests/installed_path.py @@ -0,0 +1,27 @@ +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() diff --git a/swig/python/tests/loading.py b/swig/python/tests/loading.py new file mode 100644 index 0000000..4072ea7 --- /dev/null +++ b/swig/python/tests/loading.py @@ -0,0 +1,16 @@ +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() diff --git a/swig/python/tests/problems.py b/swig/python/tests/problems.py new file mode 100644 index 0000000..0406290 --- /dev/null +++ b/swig/python/tests/problems.py @@ -0,0 +1,21 @@ +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() diff --git a/swig/python/tests/repoinfo.py b/swig/python/tests/repoinfo.py new file mode 100644 index 0000000..9934f09 --- /dev/null +++ b/swig/python/tests/repoinfo.py @@ -0,0 +1,70 @@ +#!/usr/bin/python +# +# Author: Jan Blunck +# + +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() diff --git a/swig/python/tests/starting.py b/swig/python/tests/starting.py new file mode 100644 index 0000000..91d4f4d --- /dev/null +++ b/swig/python/tests/starting.py @@ -0,0 +1,19 @@ +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() diff --git a/swig/ruby/CMakeLists.txt b/swig/ruby/CMakeLists.txt new file mode 100644 index 0000000..08d6329 --- /dev/null +++ b/swig/ruby/CMakeLists.txt @@ -0,0 +1,62 @@ +# +# 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 new file mode 100644 index 0000000..d2d3025 --- /dev/null +++ b/swig/ruby/ruby.i @@ -0,0 +1,125 @@ + +%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 new file mode 100644 index 0000000..f6d36e6 --- /dev/null +++ b/swig/ruby/std_list.i @@ -0,0 +1,533 @@ +/* ----------------------------------------------------------------------------- + * 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::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), f(const std::list&), f(const std::list*): +// the parameter being read-only, either a Ruby array or a +// previously wrapped std::list can be passed. +// -- f(std::list&), f(std::list*): +// the parameter must be modified; therefore, only a wrapped std::list +// can be passed. +// -- std::list 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& f(), std::list* f(), const std::list& f(), +// const std::list* f(): +// the list is returned by reference; therefore, a wrapped std::list +// is returned +// ------------------------------------------------------------------------ + +%{ +#include +#include +#include +%} + +// exported class + +namespace std { + + %mixin list "Enumerable"; + + template class list { + %typemap(in) list { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1; + for (unsigned int i=0; iptr[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& (std::list temp), + const list* (std::list temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = &temp; + for (unsigned int i=0; iptr[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::const_iterator it = self->begin(); + it != self->end(); + ++it ) + { + T* x = &(*it); + rb_yield(SWIG_NewPointerObj((void *) x, + $descriptor(T *), 0)); + } + } + + + %typemap(out) list { + $result = rb_ary_new2($1.size()); + unsigned int i = 0; + for ( std::list::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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const list&, + const list* { + /* 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* 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 &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 "Enumerable"; + template class list { + %typemap(in) list { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = std::list(size); + for (unsigned int i=0; iptr[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& (std::list temp), + const list* (std::list temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + temp = std::list(size); + $1 = &temp; + for (unsigned int i=0; iptr[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 { + $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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const list&, + const list* { + /* 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* 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 &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 "Enumerable"; + template<> class list { + %typemap(in) list { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = std::list(size); + for (unsigned int i=0; iptr[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& (std::list temp), + const list* (std::list temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + temp = std::list(size); + $1 = &temp; + for (unsigned int i=0; iptr[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 { + $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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const list&, + const list* { + /* 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* 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 &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 new file mode 100644 index 0000000..af2a146 --- /dev/null +++ b/swig/ruby/std_set.i @@ -0,0 +1,527 @@ +/* ----------------------------------------------------------------------------- + * 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::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), f(const std::set&), f(const std::set*): +// the parameter being read-only, either a Ruby array or a +// previously wrapped std::set can be passed. +// -- f(std::set&), f(std::set*): +// the parameter must be modified; therefore, only a wrapped std::set +// can be passed. +// -- std::set 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& f(), std::set* f(), const std::set& f(), +// const std::set* f(): +// the set is returned by reference; therefore, a wrapped std::set +// is returned +// ------------------------------------------------------------------------ + +%{ +#include +#include +#include +%} + +// exported class + +namespace std { + + %mixin set "Enumerable"; + + template class set { + %typemap(in) set { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1; + for (unsigned int i=0; iptr[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& (std::set temp), + const set* (std::set temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = &temp; + for (unsigned int i=0; iptr[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::iterator it = self->begin(); + it != self->end(); + ++it ) + { + T* x = (T *) &(*it); + rb_yield(SWIG_NewPointerObj((void *) x, + $descriptor(T *), 0)); + } + } + + + %typemap(out) set { + $result = rb_ary_new2($1.size()); + unsigned int i = 0; + for ( std::set::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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const set&, + const set* { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + public: + set(); + set(const set &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 "Enumerable"; + template class set { + %typemap(in) set { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = std::set(size); + for (unsigned int i=0; iptr[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& (std::set temp), + const set* (std::set temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + temp = std::set(size); + $1 = &temp; + for (unsigned int i=0; iptr[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 { + $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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const set&, + const set* { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + public: + set(); + set(const set &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 "Enumerable"; + template<> class set { + %typemap(in) set { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + $1 = std::set(size); + for (unsigned int i=0; iptr[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& (std::set temp), + const set* (std::set temp) { + if (rb_obj_is_kind_of($input,rb_cArray)) { + unsigned int size = RARRAY($input)->len; + temp = std::set(size); + $1 = &temp; + for (unsigned int i=0; iptr[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 { + $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 { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $&1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + %typecheck(SWIG_TYPECHECK_VECTOR) const set&, + const set* { + /* 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* v; + if (SWIG_ConvertPtr($input,(void **) &v, + $1_descriptor,0) != -1) + $1 = 1; + else + $1 = 0; + } + } + public: + set(); + set(const set &); + + %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 && isize()); + if (i<0) i+= size; + if (i>=0 && i::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 new file mode 100644 index 0000000..3b084df --- /dev/null +++ b/swig/ruby/tests/CMakeLists.txt @@ -0,0 +1,11 @@ +# +# 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 new file mode 100644 index 0000000..3e2f508 --- /dev/null +++ b/swig/ruby/tests/arch.rb @@ -0,0 +1,55 @@ +# +# 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 new file mode 100644 index 0000000..5b46e14 --- /dev/null +++ b/swig/ruby/tests/bytecount.rb @@ -0,0 +1,25 @@ +# +# 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 new file mode 100644 index 0000000..74767ce --- /dev/null +++ b/swig/ruby/tests/commit_callbacks.rb @@ -0,0 +1,46 @@ +# +# 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 new file mode 100644 index 0000000..01ae25a --- /dev/null +++ b/swig/ruby/tests/loading.rb @@ -0,0 +1,16 @@ +# +# 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 new file mode 100644 index 0000000..5f3afb2 --- /dev/null +++ b/swig/ruby/tests/starting.rb @@ -0,0 +1,22 @@ +# +# 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 new file mode 100644 index 0000000..cfecfff --- /dev/null +++ b/swig/ruby/tests/target.rb @@ -0,0 +1,44 @@ +# +# 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 new file mode 100644 index 0000000..08d573b --- /dev/null +++ b/swig/zypp.i @@ -0,0 +1,283 @@ +%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 +#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 +#include +#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 +#include +#endif + + +#include +#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 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 +%import +%import +%import +#else +%import +%import +%import +%import +#endif +%import +%import + +%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 + +%include "ZYppFactory.i" +#endif + +%include "Arch.i" +%include "Callbacks.i" + +// +// helper +// +%{ +#include +%} +%inline %{ + namespace zypp + { + void setZyppLogfile( const std::string & file_r ) + { + base::LogControl::instance().logfile( file_r ); + } + } +%} -- 2.7.4