rbind 0.0.27 → 0.0.28

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35c0ae5064a1ce8f8300cd4c05a55023ea335709
-  data.tar.gz: 199b59b9b1276492efc6c8dc1ae647f1767948f5
+  metadata.gz: e930dbda0aa8e1f1acf8758c78fad9324c0019bd
+  data.tar.gz: 62cf7fb25736383555dad7621b1df2fa0ddb5542
 SHA512:
-  metadata.gz: 1cdc8e6a92bf75d18c22b51e2bb8f109eba3d40e7ea098ec06ecef746cb42266c6b6fe9970f4287d16ea567eb3770b3909c0103473aca774e386436ed9d66602
-  data.tar.gz: 9a7da3274763ca86e8d898b8f941d58a802daa7b3c6a6dda3fdded7bbe307c8fea0dc423f130f303cfb996e26653d3f2df1c4fd5cf1ca84ff77d7d3cc7a32fb3
+  metadata.gz: 7b75baa4b7012be3076556b6980addc786630124005f2ff72e258cca0f0aa1e6a04e5623214c2723e159bbef661a0cced3f6b1b7778b0afd98d2794c996c24cc
+  data.tar.gz: 10d0e92af7049191962ea3c3197ffb08eec3f1eb09f88febe61993e78cf054da5f45d4e206071303878f6287b6542b6a62411f1e4fdd3b9f65e547a8c58cb9e8

data/lib/rbind/core/rbase.rb

@@ -123,7 +123,7 @@ module Rbind
         end
 
         def owner=(obj)
-            raise ArgumentError,"Cannot at self as owner" if obj.object_id == self.object_id
+            raise ArgumentError,"Cannot add self as owner" if obj.object_id == self.object_id
             @owner = obj
             @namespace = nil
         end

data/lib/rbind/core/rcast_operation.rb

@@ -8,6 +8,7 @@ module Rbind
                 @static = true
                 para << RParameter.new("ptr",from_class.to_ptr)
             end
+	    para << RParameter.new("parse_ownership",to_class.type("bool"))
             super(name,to_class.to_ptr,para)
         end
     end

data/lib/rbind/core/rclass.rb

@@ -86,37 +86,43 @@ module Rbind
             # temporarily add all base class operations
             own_ops = @operations.dup
             parent_classes.each do |k|
-                add_operation RCastOperation.new("castTo#{k.name}",k)
-                if k.polymorphic?
-                    add_operation RCastOperation.new("castFrom#{k.name}",self,k)
-                end
-                k.operations.each do |other_ops|
-                    next if other_ops.empty?
-                    ops = if @operations.has_key?(other_ops.first.name)
-                            @operations[other_ops.first.name]
-                          else
-                              []
-                          end
-                    other_ops.delete_if do |other_op|
-                        next true if !other_op || other_op.constructor?
-                        op = ops.find do |o|
-                            o == other_op
-                        end
-                        next false if !op
-                        next true if op.base_class == self
-                        next true if op.base_class == other_op.base_class
-                        # ambiguous name look up due to multi
-                        # inheritance
-                        op.ambiguous_name = true
-                        other_op.ambiguous_name = true
-                        false
-                    end
-                    other_ops = other_ops.map(&:dup)
-                    other_ops.each do |other|
-                        old = other.alias
-                        add_operation other
-                    end
+		add_operation RCastOperation.new("castTo#{k.name.gsub(/[:,<>]/,"_")}",k)
+                if k.polymorphic? && polymorphic?
+                    add_operation RCastOperation.new("castFrom#{k.name.gsub(/[:,<>]/,"_")}",self,k)
                 end
+		k.operations.each do |other_ops|
+		    next if other_ops.empty?
+		    ops = if @operations.has_key?(other_ops.first.name)
+			      @operations[other_ops.first.name]
+			  else
+			      []
+			  end
+		    other_ops.delete_if do |other_op|
+			next true if !other_op || other_op.constructor? || other_op.static?
+			#check for name hiding
+			if own_ops.has_key?(other_op.name)
+			    #puts "#{other_op} is shadowed by #{own_ops[other_op.name].first}"
+			    next true
+			end
+			op = ops.find do |o|
+			    o == other_op
+			end
+			next false if !op
+			next true if o.base_class == self
+			next true if o.base_class == other_op.base_class
+
+			# ambiguous name look up due to multi
+			# inheritance
+			op.ambiguous_name = true
+			other_op.ambiguous_name = true
+			false
+		    end
+		    other_ops = other_ops.map(&:dup)
+		    other_ops.each do |other|
+			old = other.alias
+			add_operation other
+		    end
+		end
             end
             # copy embedded arrays other wise they might get modified outside
             result = @operations.values.map(&:dup)
@@ -220,6 +226,7 @@ module Rbind
                 raise ArgumentError,"class #{klass.full_name} cannot be parent of its self"
             end
             @parent_classes[klass.name] = ParentClass.new(klass,accessor)
+	    raise "Cannot use namespace #{klass.full_name} as parent class for #{self.full_name}" unless(klass.respond_to?(:child?))
             klass.add_child(self,accessor) unless klass.child?(self)
             self
         end

data/lib/rbind/core/rgetter.rb

@@ -5,7 +5,7 @@ module Rbind
 
         def initialize(attr)
             @attribute = attr
-            super("get_#{attr.name}",attr.type)
+	    super("get_#{attr.name}",attr.type.to_const)
         end
 
         def attribute?

data/lib/rbind/core/rnamespace.rb

@@ -13,8 +13,8 @@ module Rbind
             attr_accessor :default_operator_alias
         end
         # TODO move somewhere else
-        self.default_type_names = [:int,:int8,:int32,:int64,:uint,:uint8,:uint32,:uint64,
-                                   :int8_t,:int32_t,:int64_t,:uint8_t,:uint32_t,:uint64_t,
+        self.default_type_names = [:int,:int8,:int16,:int32,:int64,:uint,:uint8,:uint16,:uint32,:uint64,
+                                   :int8_t,:int16_t,:int32_t,:int64_t,:uint8_t,:uint16_t,:uint32_t,:uint64_t,
                                    :bool,:double,:float,:void,:char,:size_t,:long,
                                    :uchar, :char16, :char32, :ushort, :ulong, :ulong_long,
                                    :uint128, :short, :long_long, :int128, :long_double,
@@ -260,12 +260,12 @@ module Rbind
             op.alias = if !other
                            op.alias
                        elsif op.alias
-                           name = "#{op.alias}#{@operations[op.name].size+1}"
+                           name = "#{op.alias}__#{@operations[op.name].size+1}"
                            ::Rbind.log.debug "add_operation: name clash: aliasing #{op.alias} --> #{name}"
                            name
                        else
                            op.auto_alias = true
-                           name = "#{op.name}#{@operations[op.name].size+1}"
+                           name = "#{op.name}__#{@operations[op.name].size+1}"
                            ::Rbind.log.debug "add_operation: name clash: #{op.name} --> #{name}"
                            name
                        end
@@ -292,6 +292,11 @@ module Rbind
             current_type
         end
 
+        def add_const_val(name,value)
+            c = RParameter.new(name,type("const int"),value)
+            add_const(c)
+        end
+
         def add_const(const)
             const.const!
             if(c = const(const.full_name,false,false))
@@ -415,10 +420,23 @@ module Rbind
             # under the given name
             t ||=  if search_owner && name =~ /([:\w]*)<(.*)>$/
                       t = type($1,false) if $1 && !$1.empty?
-                      t2 = type($2,false) if $2 && !$2.empty?
+		      t2 = if $2 && !$2.empty?
+			       t2 = $2.split(',')
+			       bok = true
+			       t2 = t2.map do |t3|
+				   t3 = type(t3,false)
+				   bok = false unless t3 
+				   t3
+			       end
+			       if bok
+				   t2
+			       else
+				   nil
+			       end
+			   end
                       # template is known to this library
                       if t && t2 
-                          name = "#{t.name}<#{t2.full_name}>"
+			  name = "#{t.name}<#{t2.map{|t|t.full_name}.join(",")}>"
                           t3 ||= t.owner.type(name,false,false)
                           t3 ||= begin
                                      if !t.template?
@@ -439,7 +457,8 @@ module Rbind
                       # generic template is unknown
                       # check if specialised template is known
                       elsif t2 && $1 && !$1.empty? 
-                          real_name = "#{$1}<#{t2.full_name}>".gsub(">>","> >")
+			  real_name = t2.map{|v|v.full_name}.join(",");
+                          real_name = "#{$1}<#{real_name}>".gsub(">>","> >")
                           type(real_name,false) if(real_name != name) # prevent stack level too deep
                       else
                           nil

data/lib/rbind/core/roperation.rb

@@ -10,6 +10,7 @@ module Rbind
         attr_accessor :ambiguous_name
         attr_accessor :index            # index if overloaded
         attr_accessor :static
+        attr_accessor :blocking
         attr_accessor :cplusplus_alias
 
         def initialize(name,return_type=nil,*args)
@@ -17,6 +18,7 @@ module Rbind
             @return_type = return_type
             @parameters = args.flatten
             @cplusplus_alias = true
+            @blocking = false
         end
 
         # indicates if an alias method shall be added
@@ -25,6 +27,10 @@ module Rbind
             !!@cplusplus_alias
         end
 
+        def blocking?
+            !!@blocking
+        end
+
         def add_parameter(para,&block)
             para = if para.is_a? String
                 raise "No owner. Cannot create parameter" unless owner

data/lib/rbind/core/rparameter.rb

@@ -2,6 +2,7 @@
 module Rbind
     class RParameter < RAttribute
         attr_accessor :default_value
+        attr_accessor :parse_ownership
 
         def initialize(name,type,default_value=nil)
             super(name,type)
@@ -26,6 +27,10 @@ module Rbind
             end
         end
 
+	def parse_ownership?
+	    @parse_ownership != nil
+	end
+
         def to_single_ptr
             t = self.clone
             t.type = type.to_single_ptr

data/lib/rbind/core/rtype_annotation.rb

@@ -93,7 +93,7 @@ module Rbind
         end
 
         def to_ref
-            to_annotation? :ref,true
+            to_annotation :ref,true
         end
 
         def ref?

data/lib/rbind/default_parser.rb

@@ -138,7 +138,25 @@ module Rbind
             parent_classes = $2
             flags = $3
             parent_classes = if parent_classes
-                                 parent_classes.gsub(" ","").split(",").map do |name|
+                                 classes = parent_classes.gsub(" ","").split(",")
+				 # join templates
+				 classes.each_with_index do |val,i|
+				     next unless val
+				     if val.include?("<")
+					 val = [val]
+					 (i+1).upto(classes.size-1) do |i2|
+					     val2 = classes[i2]
+					     val << val2
+					     classes[i2] = nil
+					     if val2.include?(">")
+						 break
+					     end
+					 end
+					 classes[i] = val.join(",")
+				     end
+				 end
+				classes.compact!
+				classes.map do |name|
                                      #TODO this should also call the user callback
                                      t = type(RBase.normalize(name),false)
                                      # remove namespace and try again
@@ -155,6 +173,11 @@ module Rbind
                                            end
                                      # auto add parent class
                                      t ||= begin
+					       # TODO fix error in parser
+					       # the parser always adds the current namespace
+					       # class Blas : public ::cv::Test
+					       # --> cv::::cv::Test
+					       name = name.gsub(/^.*::::/,"")	
                                                t = add_type(RClass.new(RBase.normalize(name)))
                                                t.extern_package_name = @extern_package_name
                                                t
@@ -262,11 +285,17 @@ module Rbind
             flags = normalize_flags(line_number,flags,:S,:O)
             return_type = if return_type_name && !return_type_name.empty?
                               t = find_type(owner,return_type_name)
-                              if !t.ptr? && flags.include?(:O)
-                                  t.to_ref
-                              else
-                                  t
-                              end
+			      if flags.include?(:O)
+				  if t.ptr?
+				     t
+				  else
+				      t.to_ref  # the opencv parser encodes references as flags
+				  end
+			      elsif t.basic_type? && t.name != "c_string"
+				  t
+			      else
+				  t.to_const
+			      end
                           end
             line_counter = 1
             args = a.map do |line|

data/lib/rbind/generator_c.rb

@@ -187,7 +187,7 @@ module Rbind
                def wrap_parameters
                    cparameters.map do |arg|
                        next if arg.type.basic_type?
-                       "#{arg.type.to_single_ptr.signature} #{arg.name}_ = fromC(#{arg.name});\n\t"
+		       "#{arg.type.to_single_ptr.signature} #{arg.name}_ = fromC(#{arg.name},#{arg.parse_ownership?});\n\t"
                    end.compact.join("")
                end
 
@@ -208,15 +208,24 @@ module Rbind
                                  end
                              end
                          elsif __getobj__.is_a?(RCastOperation)
-                             param = if paras.empty?
-                                        "rbind_obj_"
-                                     else
-                                        paras
-                                     end
-                             str = "#{return_type} *__rbind_temp_ = dynamic_cast<#{return_type}*>(#{param});\n"
-                             str += "\tif(!__rbind_temp_)\n"
-                             str += "\t\t throw std::runtime_error(\"Typecast failed, incompatible types\");\n"
-                             str + "\treturn toC(__rbind_temp_,false);"
+			     param1,param2,param3 = if parameters.size == 1
+						 ["rbind_obj_",paras,"rbind_obj"]
+					     else
+						 a = paras.split(",")
+						 a << parameters.first.name
+						 a
+					     end
+			     str = "#{return_type} *__rbind_temp_ = dynamic_cast<#{return_type}*>(#{param1});\n"
+			     str += "\tif(!__rbind_temp_)\n"
+			     str += "\t\t throw std::runtime_error(\"Typecast failed, incompatible types\");\n"
+			     str += "\tif(#{param2})\n"
+			     str += "\t{\n"
+			     str += "\t\tif(!#{param3}->bowner)\n"
+			     str += "\t\t    throw std::runtime_error(\"Cannot pass ownership. Object is owned by someone else. \");\n"
+			     str += "\t\telse\n"
+			     str += "\t\t    #{param3}->bowner = false;\n"
+			     str += "\t}\n"
+			     str + "\treturn toC(__rbind_temp_,#{param2});"
                          else
                              fct = if !constructor? && (return_type.name != "void" || return_type.ptr?)
                                        # operator+, operator++ etc

data/lib/rbind/generator_ruby.rb

@@ -15,7 +15,7 @@ module Rbind
         end
         self.ruby_default_value_map ||= {"true" => "true","TRUE" => "true", "false" => "false","FALSE" => "false"}
         self.ffi_type_map ||= {"char *" => "string","unsigned char" => "uchar" ,"const char *" => "string","uint8_t" => "uint8",
-                               "uint32_t" => "uint32","uint64_t" => "uint64","int8_t" => "int8","int32_t" => "int32","int64_t" => "int64" }
+                               "uint16_t" => "uint16","int16_t" => "int16", "uint32_t" => "uint32","uint64_t" => "uint64","int8_t" => "int8","int32_t" => "int32","int64_t" => "int64" }
 
 
         def self.keyword?(name)
@@ -62,6 +62,8 @@ module Rbind
             val = if parameter.type.basic_type? || parameter.type.ptr?
                       if ruby_default_value_map.has_key?(parameter.default_value)
                           ruby_default_value_map[parameter.default_value]
+                      elsif parameter.type.is_a? REnum
+                          ":#{parameter.default_value.split("::").last}"
                       elsif parameter.type.name == "float"
                           parameter.default_value.gsub("f","").gsub(/\.$/,".0").gsub(/^\./,"0.")
                       elsif parameter.type.name == "double"
@@ -131,7 +133,12 @@ module Rbind
             # map template classes
             # std::vector<std::string> -> Std::Vector::Std_String
             if name =~ /([\w:]*)<(.*)>$/
-                return "#{normalize_type_name($1,true)}::#{normalize_type_name($2,true).gsub("::","_")}"
+		name = $1
+		names = $2.split(",")
+		names.map! do |val|
+		    normalize_type_name(val,true).gsub("::","_")
+		end
+		return "#{normalize_type_name(name,true)}::#{names.join("_")}"
             else
                 name
             end
@@ -332,11 +339,10 @@ module Rbind
                                                   op_return_type = klass if klass.kind_of?(REnum)
                                               end
                                           end
-
                                           if op_return_type.basic_type?
                                               if op_return_type.ptr?
                                                   ":pointer"
-                                              elsif op_return_type.kind_of?(REnum)
+					      elsif op.return_type.to_raw.kind_of?(REnum)
                                                   ":#{normalize_enum op_return_type.to_raw.csignature}"
                                               else
                                                   ":#{normalize_bt op_return_type.to_raw.csignature}"
@@ -344,7 +350,7 @@ module Rbind
                                           else
                                               if op_return_type.extern_package_name
                                                   normalize_t("::#{op_return_type.extern_package_name}::#{op_return_type.to_raw.full_name}")
-                                              elsif op_return_type.kind_of?(REnum)
+					      elsif op_return_type.to_raw.kind_of?(REnum)
                                                   ":#{normalize_enum op_return_type.to_raw.full_name}"
                                               else
                                                   normalize_t op_return_type.to_raw.full_name
@@ -361,7 +367,7 @@ module Rbind
                             if p_type.basic_type?
                                 if p_type.ptr? || p.type.ref?
                                     ":pointer"
-                                elsif p.type.kind_of?(REnum)
+				elsif p.type.to_raw.kind_of?(REnum)
                                     # Includes enums, which need to be defined accordingly
                                     # using ffi:
                                     # enum :normalized_name, [:first, 1,
@@ -375,7 +381,7 @@ module Rbind
                             else
                                 if p_type.extern_package_name
                                     normalize_t("::#{p_type.extern_package_name}::#{p_type.to_raw.full_name}")
-                                elsif p_type.kind_of?(REnum)
+				elsif p_type.to_raw.kind_of?(REnum)
                                     ":#{normalize_enum p_type.to_raw.full_name}"
                                 else
                                     normalize_t p_type.to_raw.full_name
@@ -383,6 +389,7 @@ module Rbind
                             end
                         end
                         fct_name = normalize_m op.cname
+                        str += "@blocking = true; "if op.blocking?
                         str += "attach_function :#{fct_name},:#{op.cname},[#{args.join(",")}],#{return_type}\n"
                         str
                     end
@@ -675,7 +682,12 @@ module Rbind
                         HelperBase.log.warn "#{c.name}: no default value"
                         next
                     else
-                    "    #{c.name} = #{GeneratorRuby::normalize_type_name(c.default_value)}\n"
+                        val = begin
+                                  eval(c.default_value)
+                              rescue
+                                  GeneratorRuby::normalize_type_name(c.default_value)
+                              end
+                    "    #{c.name} = #{val}\n"
                     end
                 end.join
                 return str unless @compact_namespace

data/lib/rbind/templates/c/type_conversion.cc

@@ -17,7 +17,7 @@ const <%= cname %>* toC(const <%= full_name %>* ptr, bool owner)
 }
 
 // converts const <%= cname %> to const <%= full_name %>
-const <%= full_name %>* fromC(const <%= cname %>* ptr)
+const <%= full_name %>* fromC(const <%= cname %>* ptr,bool parse_owner)
 {
     if(ptr == NULL)
         throw std::runtime_error("<%= full_name %>: Null Pointer!");
@@ -38,14 +38,20 @@ const <%= full_name %>* fromC(const <%= cname %>* ptr)
     // check size
     if(ptr->size && sizeof(<%= full_name %>) > ptr->size)
         throw std::runtime_error("wrong object size for <%= full_name %>.");
+    if(parse_owner)
+        throw std::runtime_error("cannot parse ownerhsip for const parameter for <%= full_name %>.");
     return static_cast<const <%= full_name %>*>(ptr->obj_ptr);
 }
 
 // converts <%= cname %>* to <%= full_name %>*
-<%= full_name %>* fromC(<%= cname %>* ptr)
+<%= full_name %>* fromC(<%= cname %>* ptr,bool parse_owner)
 {
     if(ptr == NULL)
         return NULL;
-    return const_cast<<%= full_name %>*>(fromC(static_cast<const <%= cname %>*>(ptr)));
+    if(parse_owner && !ptr->bowner)
+        throw std::runtime_error("Cannot parse ownership. The given object is already owned by someone else  <%= full_name %>.");
+    if(parse_owner)
+	ptr->bowner = false;
+    return const_cast<<%= full_name %>*>(fromC(static_cast<const <%= cname %>*>(ptr),false));
 }
 

data/lib/rbind/templates/c/type_conversion.hpp

@@ -1,6 +1,6 @@
 // convert functions for <%= full_name %>* to and from <%= cname %>*
 const <%= cname %>* toC(const <%= full_name %>* ptr, bool owner = true);
 <%= cname %>* toC(<%= full_name %>* ptr, bool owner = true);
-const <%= full_name %>* fromC(const <%= cname %>* ptr);
-<%= full_name %>* fromC(<%= cname %>* ptr);
+const <%= full_name %>* fromC(const <%= cname %>* ptr,bool parse_ownership=false);
+<%= full_name %>* fromC(<%= cname %>* ptr,bool parse_ownership=false);
 

data/lib/rbind/tools/hdr_parser.py

@@ -1,7 +1,7 @@
 #!/usr/bin/env python
 
 from __future__ import print_function
-import os, sys, re, string
+import os, sys, re, string, io
 
 # the list only for debugging. The real list, used in the real OpenCV build, is specified in CMakeLists.txt
 opencv_hdr_list = [
@@ -17,7 +17,7 @@ opencv_hdr_list = [
 "../../objdetect/include/opencv2/objdetect.hpp",
 "../../imgcodecs/include/opencv2/imgcodecs.hpp",
 "../../videoio/include/opencv2/videoio.hpp",
-"../../highgui/include/opencv2/highgui.hpp"
+"../../highgui/include/opencv2/highgui.hpp",
 ]
 
 """
@@ -31,13 +31,17 @@ where the list of modifiers is yet another nested list of strings
 
 class CppHeaderParser(object):
 
-    def __init__(self):
+    def __init__(self, generate_umat_decls=False):
+        self._generate_umat_decls = generate_umat_decls
+
         self.BLOCK_TYPE = 0
         self.BLOCK_NAME = 1
         self.PROCESS_FLAG = 2
         self.PUBLIC_SECTION = 3
         self.CLASS_DECL = 4
 
+        self.namespaces = set()
+
     def batch_replace(self, s, pairs):
         for before, after in pairs:
             s = s.replace(before, after)
@@ -366,7 +370,7 @@ class CppHeaderParser(object):
             print(decl_str)
         return decl
 
-    def parse_func_decl(self, decl_str):
+    def parse_func_decl(self, decl_str, use_umat=False):
         """
         Parses the function or method declaration in the form:
         [([CV_EXPORTS] <rettype>) | CVAPI(rettype)]
@@ -443,6 +447,12 @@ class CppHeaderParser(object):
 
         rettype, funcname, modlist, argno = self.parse_arg(decl_start, -1)
 
+        # determine original return type, hack for return types with underscore
+        original_type = None
+        i = decl_start.rfind(funcname)
+        if i > 0:
+            original_type = decl_start[:i].replace("&", "").replace("const", "").strip()
+
         if argno >= 0:
             classname = top[1]
             if rettype == classname or rettype == "~" + classname:
@@ -529,41 +539,45 @@ class CppHeaderParser(object):
                         a = a[:eqpos].strip()
                     arg_type, arg_name, modlist, argno = self.parse_arg(a, argno)
                     if self.wrap_mode:
+                        mat = "UMat" if use_umat else "Mat"
+
+                        # TODO: Vectors should contain UMat, but this is not very easy to support and not very needed
+                        vector_mat = "vector_{}".format("Mat")
+                        vector_mat_template = "vector<{}>".format("Mat")
+
                         if arg_type == "InputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                         elif arg_type == "InputOutputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                             modlist.append("/IO")
                         elif arg_type == "OutputArray":
-                            arg_type = "Mat"
+                            arg_type = mat
                             modlist.append("/O")
                         elif arg_type == "InputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                         elif arg_type == "InputOutputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                             modlist.append("/IO")
                         elif arg_type == "OutputArrayOfArrays":
-                            arg_type = "vector_Mat"
+                            arg_type = vector_mat
                             modlist.append("/O")
-                        defval = self.batch_replace(defval, [("InputArrayOfArrays", "vector<Mat>"),
-                                                             ("InputOutputArrayOfArrays", "vector<Mat>"),
-                                                             ("OutputArrayOfArrays", "vector<Mat>"),
-                                                             ("InputArray", "Mat"),
-                                                             ("InputOutputArray", "Mat"),
-                                                             ("OutputArray", "Mat"),
+                        defval = self.batch_replace(defval, [("InputArrayOfArrays", vector_mat_template),
+                                                             ("InputOutputArrayOfArrays", vector_mat_template),
+                                                             ("OutputArrayOfArrays", vector_mat_template),
+                                                             ("InputArray", mat),
+                                                             ("InputOutputArray", mat),
+                                                             ("OutputArray", mat),
                                                              ("noArray", arg_type)]).strip()
                     args.append([arg_type, arg_name, defval, modlist])
                 npos = arg_start-1
 
-        npos = decl_str.replace(" ", "").find("=0", npos)
-        if npos >= 0:
-            # skip pure virtual functions
-            return []
-
         if static_method:
             func_modlist.append("/S")
 
-        return [funcname, rettype, func_modlist, args]
+        if original_type is None:
+            return [funcname, rettype, func_modlist, args]
+        else:
+            return [funcname, rettype, func_modlist, args, original_type]
 
     def get_dotted_name(self, name):
         """
@@ -598,7 +612,7 @@ class CppHeaderParser(object):
             n = "cv.Algorithm"
         return n
 
-    def parse_stmt(self, stmt, end_token):
+    def parse_stmt(self, stmt, end_token, use_umat=False):
         """
         parses the statement (ending with ';' or '}') or a block head (ending with '{')
 
@@ -690,7 +704,7 @@ class CppHeaderParser(object):
             # since we filtered off the other places where '(' can normally occur:
             #   - code blocks
             #   - function pointer typedef's
-            decl = self.parse_func_decl(stmt)
+            decl = self.parse_func_decl(stmt, use_umat=use_umat)
             # we return parse_flag == False to prevent the parser to look inside function/method bodies
             # (except for tracking the nested blocks)
             return stmt_type, "", False, decl
@@ -737,7 +751,7 @@ class CppHeaderParser(object):
         """
         self.hname = hname
         decls = []
-        f = open(hname, "rt")
+        f = io.open(hname, 'rt', encoding='utf-8')
         linelist = list(f.readlines())
         f.close()
 
@@ -833,6 +847,18 @@ class CppHeaderParser(object):
                                 decls.append(d)
                         else:
                             decls.append(decl)
+
+                            if self._generate_umat_decls:
+                                # If function takes as one of arguments Mat or vector<Mat> - we want to create the
+                                # same declaration working with UMat (this is important for T-Api access)
+                                args = decl[3]
+                                has_mat = len(list(filter(lambda x: x[0] in {"Mat", "vector_Mat"}, args))) > 0
+                                if has_mat:
+                                    _, _, _, umat_decl = self.parse_stmt(stmt, token, use_umat=True)
+                                    decls.append(umat_decl)
+                    if stmt_type == "namespace":
+                        chunks = [block[1] for block in self.block_stack if block[0] == 'namespace'] + [name]
+                        self.namespaces.add('.'.join(chunks))
                 else:
                     stmt_type, name, parse_flag = "block", "", False
 
@@ -869,7 +895,7 @@ class CppHeaderParser(object):
                     print()
 
 if __name__ == '__main__':
-    parser = CppHeaderParser()
+    parser = CppHeaderParser(generate_umat_decls=False)
     decls = []
   #  for hname in opencv_hdr_list:
   #      decls += parser.parse(hname)

data/lib/rbind/types/std_map.rb

@@ -1,6 +1,6 @@
 module Rbind
     class StdMap < RTemplateClass
-        def specialize(klass,*parameters)
+        def specialize(klass,parameters)
             if parameters.size < 2
                 raise ArgumentError,"StdMap does require at least two template parameters. Got: #{parameters}}"
             end
@@ -17,7 +17,6 @@ module Rbind
 
             klass.add_operation ROperation.new("size",type("size_t"))
             klass.add_operation ROperation.new("clear",type("void"))
-            klass.add_operation ROperation.new("capacity",type("size_t"))
             klass.add_operation ROperation.new("empty",type("bool"))
             klass.add_operation ROperation.new("operator[]",map_value_type, RParameter.new("key_type", map_key_type))
             klass.add_operation ROperation.new("at",map_value_type, RParameter.new("key_type",map_key_type))

data/lib/rbind/types/std_vector.rb

@@ -1,6 +1,6 @@
 module Rbind
     class StdVector < RTemplateClass
-        def specialize(klass,*parameters)
+        def specialize(klass,parameters)
             if parameters.size != 1
                 raise ArgumentError,"StdVector does only support one template parameter. Got: #{parameters}}"
             end

data/manifest.xml

@@ -6,5 +6,7 @@
   <license></license>
   <url>http://</url>
   <logo>http://</logo>
+
+  <depend package="gem-hooks" />
   <depend package="ffi" />
 </package>

data/rbind.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |s|
     s.name              = 'rbind'
-    s.version           = '0.0.27'
-    s.date              = '2015-03-08'
+    s.version           = '0.0.28'
+    s.date              = '2018-07-10'
     s.platform          = Gem::Platform::RUBY
     s.authors           = ['Alexander Duda']
-    s.email             = ['Alexander.Duda@dfki.de']
+    s.email             = ['Alexander.Duda@me.com']
     s.homepage          = 'http://github.com/D-Alex/rbind'
     s.summary           = 'Library for genereating automated ffi-bindings for c/c++ libraries'
     s.description       = 'Rbind is developed to automatically generate ruby bindings for OpenCV '\

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbind
 version: !ruby/object:Gem::Version
-  version: 0.0.27
+  version: 0.0.28
 platform: ruby
 authors:
 - Alexander Duda
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-08 00:00:00.000000000 Z
+date: 2018-07-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -28,7 +28,7 @@ description: Rbind is developed to automatically generate ruby bindings for Open
   but is not tight to this library.This gem is still under heavy development and the
   API might change in the future.
 email:
-- Alexander.Duda@dfki.de
+- Alexander.Duda@me.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -123,9 +123,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.2.3
 signing_key: 
 specification_version: 4
 summary: Library for genereating automated ffi-bindings for c/c++ libraries
 test_files: []
-has_rdoc: