Modified ruby functors to remove ruby prefix.

Added new test for functors.



git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@9776 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/ruby/Makefile.in

@@ -21,6 +21,7 @@ CPP_TEST_CASES = \
 	li_factory \
 	li_std_map \
 	li_std_set \
+	li_std_functors \
 	naming \
 	primitive_types \
 	std_containers \

Examples/test-suite/ruby/li_std_functors.i

@@ -0,0 +1,17 @@
+%module stl_new
+
+%include <std_vector.i>
+%include <std_deque.i>
+%include <std_list.i>
+%include <std_set.i>
+%include <std_map.i>
+
+%template(Vector  ) std::vector  <swig::LANGUAGE_OBJ>;
+%template(Deque   ) std::deque   <swig::LANGUAGE_OBJ>;
+%template(List    ) std::list    <swig::LANGUAGE_OBJ>;
+
+%template(Set     ) std::set     <swig::LANGUAGE_OBJ,
+                                   swig::BinaryPredicate<> >;
+%template(Map     ) std::map     <swig::LANGUAGE_OBJ,swig::LANGUAGE_OBJ,
+                                   swig::BinaryPredicate<> >;
+

Examples/test-suite/ruby/li_std_functors_runme.rb

@@ -0,0 +1,65 @@
+#!/usr/bin/env ruby
+#
+# This is a test of STL containers using proc
+# objects to change the sorting function used in them.  Same as a
+# std::binary_predicate in C++.
+#
+# Author::    
+# Copyright:: 
+# License::   Ruby
+#
+
+require 'swig_assert'
+require 'stl_new'
+
+
+def _set(container)
+  swig_assert_each_line(<<EOF, binding)
+    cont = #{container}.new
+    [9,1,8,2,7,3,6,4,5].each { |x| cont.insert(x) }
+    i0 = cont.begin()
+    cont.to_a == [1,2,3,4,5,6,7,8,9]
+    cont = #{container}.new( proc { |a,b| b < a } )
+    [9,1,8,2,7,3,6,4,5].each { |x| cont.insert(x) }
+    cont.to_a == [9, 8, 7, 6, 5, 4, 3, 2, 1]
+    cont = #{container}.new( proc { |a,b| b > a } )
+    [9,1,8,2,7,3,6,4,5].each { |x| cont.insert(x) }
+    cont.to_a == [1, 2, 3, 4, 5, 6, 7, 8, 9]
+    cont = #{container}.new(proc { |a,b| b < a } )
+    cont.insert(1)
+    cont.to_a == [1]
+    i0 = cont.begin()
+    cont.erase(i0) # don't use i0 anymore, it is invalid now
+    cont.to_a == []
+EOF
+end
+    
+def _map(container)
+  swig_assert_each_line(<<EOF, binding)
+    cont = #{container}.new
+    cont['z'] = 9
+    cont['y'] = 1
+    cont['x'] = 8
+    cont['w'] = 2
+    cont.to_a == [['w',2],['x',8],['y',1],['z',9]]
+
+    cont = #{container}.new(proc { |a,b| b < a } )
+    cont['z'] = 9
+    cont['y'] = 1
+    cont['x'] = 8
+    cont['w'] = 2
+    cont.to_a == [['z',9],['y',1],['x',8],['w',2]]
+EOF
+end
+
+def test
+  yield method(:_set), Stl_new::Set
+  yield method(:_map), Stl_new::Map
+end
+
+
+test do |proc, container|
+  proc.call(container)
+end
+
+

Lib/ruby/rubystdfunctors.swg

@@ -59,46 +59,46 @@ int SWIG_Ruby_arity( VALUE proc, int minimal )
 
 namespace swig {
 
-  %apply GC_VALUE { RubyUnaryPredicate, RubyBinaryPredicate, RubyUnaryFunction,
-		      RubyBinaryFunction };
+  %apply GC_VALUE { UnaryPredicate, BinaryPredicate, UnaryFunction,
+		      BinaryFunction };
 
   %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
-    RubyUnaryPredicate, RubyUnaryPredicate&, RubyUnaryFunction, RubyUnaryFunction&
+    UnaryPredicate, UnaryPredicate&, UnaryFunction, UnaryFunction&
   {
     $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 1);
   }
 
   %typecheck(SWIG_TYPECHECK_POINTER,noblock=1) 
-    RubyBinaryPredicate, RubyBinaryPredicate&, RubyBinaryFunction, RubyBinaryFunction& {
+    BinaryPredicate, BinaryPredicate&, BinaryFunction, BinaryFunction& {
     $1 = SWIG_Ruby_isCallable($input) && SWIG_Ruby_arity($input, 2);
   }
 
-  %typemap(in,noblock=1) RubyUnaryFunction&, RubyUnaryFunction {
-    $1 = new swig::RubyUnaryFunction<>($input);
+  %typemap(in,noblock=1) UnaryFunction&, UnaryFunction {
+    $1 = new swig::UnaryFunction<>($input);
   }
-  %typemap(in,noblock=1) RubyUnaryPredicate&, RubyUnaryPredicate {
-    $1 = new swig::RubyUnaryPredicate<>($input);
+  %typemap(in,noblock=1) UnaryPredicate&, UnaryPredicate {
+    $1 = new swig::UnaryPredicate<>($input);
   }
 
-  %typemap(in,noblock=1)  RubyBinaryFunction&, RubyBinaryFunction {
-    $1 = new swig::RubyBinaryFunction<>($input);
+  %typemap(in,noblock=1)  BinaryFunction&, BinaryFunction {
+    $1 = new swig::BinaryFunction<>($input);
   }
-  %typemap(in,noblock=1) RubyBinaryPredicate&, RubyBinaryPredicate {
-    $1 = new swig::RubyBinaryPredicate<>($input);
+  %typemap(in,noblock=1) BinaryPredicate&, BinaryPredicate {
+    $1 = new swig::BinaryPredicate<>($input);
   }
 
 
-  %ignore RubyBinaryFunction;
-  struct RubyBinaryFunction {};
+  %ignore BinaryFunction;
+  struct BinaryFunction {};
 
-  %ignore RubyUnaryFunction;
-  struct RubyUnaryFunction {};
+  %ignore UnaryFunction;
+  struct UnaryFunction {};
 
-  %ignore RubyBinaryPredicate;
-  struct RubyBinaryPredicate {};
+  %ignore BinaryPredicate;
+  struct BinaryPredicate {};
 
-  %ignore RubyUnaryPredicate;
-  struct RubyUnaryPredicate {};
+  %ignore UnaryPredicate;
+  struct UnaryPredicate {};
 
 }
 
@@ -109,9 +109,9 @@ namespace swig {
   static ID call_id = rb_intern("call");
 
   template <class _DefaultFunc = std::less<GC_VALUE> >
-  struct RubyBinaryPredicate : GC_VALUE, std::binary_function<GC_VALUE, GC_VALUE, bool>
+  struct BinaryPredicate : GC_VALUE, std::binary_function<GC_VALUE, GC_VALUE, bool>
   {
-    RubyBinaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    BinaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
     bool operator()(GC_VALUE arg1, GC_VALUE arg2) const
     {
       if (_obj != Qnil) {
@@ -127,9 +127,9 @@ namespace swig {
   };
 
   template <class _DefaultFunc = std::less<GC_VALUE> >
-  struct RubyBinaryFunction : GC_VALUE, std::binary_function<GC_VALUE, GC_VALUE, GC_VALUE>
+  struct BinaryFunction : GC_VALUE, std::binary_function<GC_VALUE, GC_VALUE, GC_VALUE>
   {
-    RubyBinaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    BinaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
     GC_VALUE operator()(GC_VALUE arg1, GC_VALUE arg2) const
     {
       if (_obj != Qnil) {
@@ -145,9 +145,9 @@ namespace swig {
   };
 
 
-  struct RubyUnaryPredicate : GC_VALUE, std::unary_function<GC_VALUE, bool>
+  struct UnaryPredicate : GC_VALUE, std::unary_function<GC_VALUE, bool>
   {
-    RubyUnaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    UnaryPredicate(VALUE obj = Qnil) : GC_VALUE(obj) { }
     bool operator()(GC_VALUE arg1) const
     {
       SWIG_RUBY_THREAD_BEGIN_BLOCK;
@@ -157,9 +157,9 @@ namespace swig {
     }
   };
 
-  struct RubyUnaryFunction : GC_VALUE, std::unary_function<GC_VALUE, GC_VALUE>
+  struct UnaryFunction : GC_VALUE, std::unary_function<GC_VALUE, GC_VALUE>
   {
-    RubyUnaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
+    UnaryFunction(VALUE obj = Qnil) : GC_VALUE(obj) { }
     GC_VALUE operator()(GC_VALUE arg1) const
     {
       SWIG_RUBY_THREAD_BEGIN_BLOCK;
@@ -168,6 +168,8 @@ namespace swig {
       return GC_VALUE(res);
     }
   };
+
+
 }
 %}