rbind 0.0.16 → 0.0.17

data/lib/rbind/core/roperation.rb

@@ -7,19 +7,39 @@ module Rbind
         attr_accessor :base_class
         attr_accessor :ambiguous_name
         attr_accessor :index            # index if overloaded
+        attr_accessor :static
+        attr_accessor :cplusplus_alias
 
-        def initialize(name,return_type,*args)
+        def initialize(name,return_type=nil,*args)
             super(name)
-            raise ArgumentError ,"wrong type #{return_type}" if return_type && !return_type.is_a?(RDataType)
             @return_type = return_type
             @parameters = args.flatten
-            @parameters.each do |para|
-                raise ArgumentError ,"wrong parameter type#{para}" if !para.is_a?(RParameter)
+            @cplusplus_alias = true
+        end
+
+        # indicates if an alias method shall be added
+        # having the same name style like the c++ method
+        def cplusplus_alias?
+            !!@cplusplus_alias
+        end
+
+        def add_parameter(para,&block)
+            para = if para.is_a? String
+                raise "No owner. Cannot create parameter" unless owner
+                para = RParameter.new(para,owner.void)
+                owner.instance_exec(para,&block) if block
+                para
+            else
+                para
+            end
+            if @parameters.find{|p| p.name == para.name}
+                raise RuntimeError,"duplicate parameter name #{para}"
             end
-            @cparameters = @parameters
+            @parameters << para
         end
 
         def ==(other)
+            return false if other.class != self.class
             return false unless name == other.name
             @parameters.each_with_index do |p,i|
                 return false if p != other.parameters[i]
@@ -58,33 +78,34 @@ module Rbind
             @parameters[idx]
         end
 
-        def valid_flags
-            super << :S << :explicit
+        def static?
+            !instance_method?
         end
 
-        def static?
-            @flags.include?(:S)
+        def to_static
+            op = self.dup
+            op.static = true
+            op
         end
 
         def generate_signatures
             s = "#{return_type.signature} " unless constructor?
             s = "#{s}#{full_name}(#{parameters.map(&:signature).join(", ")})"
-            
+
             cs = if constructor?
                     owner.to_ptr.csignature if owner
                 else
                     if return_type.basic_type?
                         return_type.csignature
                     else
-                        return_type.to_ptr.csignature
+                        return_type.to_single_ptr.csignature
                     end
                 end
             paras = cparameters.map do |p|
                 if p.type.basic_type?
                     p.csignature
                 else
-                    tp = p.to_ptr
-                    "#{tp.csignature}"
+                    p.to_single_ptr.csignature
                 end
             end.join(", ")
             cs = "#{cs} #{cname}(#{paras})"
@@ -92,28 +113,39 @@ module Rbind
         end
 
         def instance_method?
-            owner.is_a?(RStruct) && !constructor? && !static?
+            owner.is_a?(RClass) && !constructor? && !@static
+        end
+
+        def cparameters
+            return @cparameters if @cparameters
+            if instance_method?
+                p = RParameter.new("rbind_obj",owner)
+                [p] +  @parameters
+            else
+                @parameters.dup
+            end
         end
 
         def owner=(obj)
             super
             @base_class ||=obj
-            @cparameters = if instance_method?
-                               p = RParameter.new("rbind_obj",obj,nil,:IO)
-                               [p] +  @parameters
-                           else
-                               @parameters
-                           end
             @parameters.each do |para|
                 para.owner = self
             end
             self
         end
 
+        # generates documentation based on the method signature
+        def generate_doc
+
+        end
+
         def constructor?
             !@return_type
         end
 
+        # returns true if the method is a setter or getter
+        # generated for a class attribute
         def attribute?
             false
         end

data/lib/rbind/core/rparameter.rb

@@ -3,13 +3,14 @@ module Rbind
     class RParameter < RAttribute
         attr_accessor :default_value
 
-        def initialize(name,type,default_value=nil,*flags)
-            super(name,type,*flags)
+        def initialize(name,type,default_value=nil)
+            super(name,type)
             self.default_value = default_value
         end
 
         def default_value=(val)
-            @default_value = if val && !val.empty?
+            val = val.to_s
+            @default_value = if !val.empty?
                                  val.chomp.chomp(" ")
                              else
                                  nil
@@ -25,16 +26,50 @@ module Rbind
             end
         end
 
-        def valid_flags
-            [:IO,:O]
+        def to_single_ptr
+            t = self.clone
+            t.type = type.to_single_ptr
+            t
+        end
+
+        def remove_const!
+            @type = type.remove_const
+            self
+        end
+
+        def const!
+            return self if const?
+            @type = type.to_const
+            self
+        end
+
+        def to_const
+            return self if const?
+            para = self.dup
+            para.type = type.to_const
+            self
+        end
+
+        def const?
+            type.const?
+        end
+
+        def ref?
+            type.ref?
+        end
+
+        def basic_type?
+            type.basic_type?
         end
 
         def generate_signatures
-            c,cs = super
             if default_value
-                c = "#{c}=#{default_value}"
+                sigs = super
+                sigs[0] += " = #{default_value}"
+                sigs
+            else
+                super
             end
-            [c,cs]
         end
     end
 end

data/lib/rbind/core/rpointer.rb

@@ -0,0 +1,70 @@
+require 'delegate'
+
+module Rbind
+    class RPointer < SimpleDelegator
+        attr_accessor :const
+
+        def initialize(type)
+            super(type)
+        end
+
+        def name
+            super.to_s + "*"
+        end
+
+        def full_name
+            super.to_s + "*"
+        end
+
+        def signature(sig=nil)
+            super.to_s + "*"
+        end
+
+        def csignature(sig=nil)
+            super.to_s + "*"
+        end
+
+        def ptr?
+            true
+        end
+
+        def ref?
+            false
+        end
+
+        def raw?
+            false
+        end
+
+        def remove_const
+            RPointer.new __getobj__.remove_const
+        end
+
+        def to_ptr
+            RPointer.new(self)
+        end
+
+        def to_ref
+            RReference.new(self)
+        end
+
+        def to_const
+            return self if const?
+            RTypeQualifier.new(self,:const => true)
+        end
+
+        def signature(sig=nil)
+            generate_signatures[0]
+        end
+
+        def csignature(sig=nil)
+            generate_signatures[1]
+        end
+
+        def generate_signatures
+            __getobj__.generate_signatures.map do |s|
+                s + "*"
+            end
+        end
+    end
+end

data/lib/rbind/core/rreference.rb

@@ -0,0 +1,54 @@
+require 'delegate'
+
+module Rbind
+    class RReference < SimpleDelegator
+        attr_accessor :const
+
+        def initialize(type)
+            super(type)
+        end
+
+        def ref?
+            true
+        end
+
+        def ptr?
+            false
+        end
+
+        def raw?
+            false
+        end
+
+        def to_ptr
+            RPointer.new(self)
+        end
+
+        def to_ref
+            RReference.new(self)
+        end
+
+        def to_const
+            return self if const?
+            RTypeQualifier.new(self,:const => true)
+        end
+
+        def remove_const
+            RReference.new __getobj__.remove_const
+        end
+
+        def signature(sig=nil)
+            generate_signatures[0]
+        end
+
+        def csignature(sig=nil)
+            generate_signatures[1]
+        end
+
+        def generate_signatures
+            __getobj__.generate_signatures.map do |s|
+                s + "&"
+            end
+        end
+    end
+end

data/lib/rbind/core/rtemplate_class.rb

@@ -0,0 +1,49 @@
+
+module Rbind
+    class RTemplateParameter < RDataType
+        def template?
+            true
+        end
+    end
+
+    class RTemplateClassSpecialization < RClass
+        attr_accessor :template,:template_parameters
+
+        def initialize(name,template,*parameters)
+            super(name)
+            @name = @name.gsub(">>","> >") # force overwrite to match c++ syntax
+            @template = template
+            @template_parameteres = parameters
+        end
+
+        def specialize_ruby
+            template.specialize_ruby_specialization(self)
+        end
+    end
+
+    class RTemplateClass < RClass
+        def initialize(name,*parent_classes)
+            raise "parent classes for template classes are not supported!" if !parent_classes.empty?
+            super
+        end
+
+        def template?
+            true
+        end
+
+        # called by RNamespace
+        def do_specialize(name,*parameters)
+            klass = RTemplateClassSpecialization.new(name,self,*parameters)
+            specialize(klass,*parameters)
+        end
+
+        # hook for implementing the specialization
+        def specialize(klass,*parameters)
+        end
+
+        # hook for generating additional ruby code going to be embedded into the
+        # class definition
+        def specialize_ruby_specialization(klass)
+        end
+    end
+end

data/lib/rbind/core/rtype_qualifier.rb

@@ -0,0 +1,60 @@
+require 'delegate'
+
+module Rbind
+    class RTypeQualifier < SimpleDelegator
+        attr_accessor :const
+
+        def initialize(type,options=Hash.new)
+            super(type)
+            @const = options[:const]
+        end
+
+        def const?
+            !!@const
+        end
+
+        def to_single_ptr
+            t = to_raw
+            t = t.to_const if const?
+            t.to_ptr
+        end
+
+        def to_ptr
+            RPointer.new(self)
+        end
+
+        def to_ref
+            RReference.new(self)
+        end
+
+        def to_const
+            return self if const?
+            RTypeQualifier.new(self,:const => true)
+        end
+
+        def remove_const
+            __getobj__
+        end
+
+        def raw?
+            false
+        end
+
+        def signature(sig=nil)
+            generate_signatures[0]
+        end
+
+        def csignature(sig=nil)
+            generate_signatures[1]
+        end
+
+        def generate_signatures
+            str = if const?
+                      "const "
+                  end
+            __getobj__.generate_signatures.map do |s|
+                str + s
+            end
+        end
+    end
+end

data/lib/rbind/default_parser.rb

@@ -3,35 +3,25 @@ module Rbind
     class DefaultParser < RNamespace
         extend ::Rbind::Logger
 
-        def initialize
-            super("root")
-            self.root = true
-            add_default_types
-            @on_type_not_found
+        def initialize(root = nil)
+            super(nil,root)
+            add_default_types if !root
         end
 
-        def normalize_flags(line_number,flags)
+        def normalize_flags(line_number,flags,*valid_flags)
             flags.map do |flag|
                 next if flag.empty?
                 if flag =~ /(\w*)(.*)/
                     DefaultParser.log.debug "input line #{line_number}: ignoring flag #{$2}" unless $2.empty?
-                    $1.to_sym
+                    flag = $1.to_sym
+                    DefaultParser.log.debug "input line #{line_number}: ignoring flag #{$1}" unless valid_flags.include?(flag)
+                    flag
                 else
                     raise "cannot parse flag #{flag.inspect}"
                 end
             end.compact
         end
 
-        def normalize_default_value(value)
-            value = value.gsub(/std::vector</,"vector<")
-            val = value.gsub(/(.?)vector<(.*)>/,'\1vector_\2')
-            if value != val
-                normalize_default_value(val)
-            else
-                val
-            end
-        end
-
         def add_data_type_name(name)
             t = RDataType.new(name)
             add_type t
@@ -44,12 +34,6 @@ module Rbind
             ns
         end
 
-        def add_struct_name(name)
-            s = RStruct.new(name)
-            add_type s
-            s
-        end
-
         def add_class_name(name)
             klass = RClass.new(name)
             add_type klass
@@ -60,11 +44,28 @@ module Rbind
             @on_type_not_found = block
         end
 
+        # reverse template masking done by the opencv parser
+        def unmask_template(type_name)
+            if(type_name =~/<.*>/)
+                return type_name
+            end
+
+            if(type_name =~/^vector/ || type_name =~/^Ptr/)
+               if(type_name =~ /^([a-zA-Z\d]*)_([_a-zA-Z\d]*) ?(\(?.*)\)? */)
+                  "#{$1}<#{unmask_template($2)}>#{$3}"
+               else
+                   type_name
+               end
+            else
+                type_name
+            end
+        end
 
         def find_type(owner,type_name)
+            type_name = unmask_template(type_name)
             t = owner.type(type_name,false)
             return t if t
-            
+
             normalized = type_name.split("_")
             name = normalized.shift
             while !normalized.empty?
@@ -88,10 +89,15 @@ module Rbind
             array = flags.shift.split(" ")
             type_name = array.shift
             para_name = array.shift
-            default = normalize_default_value(array.join(" "))
+            default = unmask_template(array.join(" "))
             type = find_type(owner,type_name)
-            flags = normalize_flags(line_number,flags)
-            RParameter.new(para_name,type,default,flags)
+            flags = normalize_flags(line_number,flags,:IO,:O)
+            type = if flags.include?(:O) || flags.include?(:IO) || type.basic_type?
+                       type
+                   else
+                       type.to_const
+                   end
+            RParameter.new(para_name,type,default)
         rescue RuntimeError => e
             raise "input line #{line_number}: #{e}"
         end
@@ -102,8 +108,10 @@ module Rbind
             type_name = array[0]
             name = array[1]
             type = find_type(owner,type_name)
-            flags = normalize_flags(line_number,flags)
-            RAttribute.new(name,type,flags)
+            flags = normalize_flags(line_number,flags,:RW,:R)
+            a = RAttribute.new(name,type)
+            a.writeable!(true) if flags.include? :RW
+            a
         rescue RuntimeError => e
             raise "input line #{line_number}: #{e}"
         end
@@ -111,7 +119,7 @@ module Rbind
         def parse_class(line_number,string)
             lines = string.split("\n")
             a = lines.shift.rstrip
-            unless a =~ /class ([a-zA-Z\.\d_:]*) ?:?([a-zA-Z\.\:, \d_]*)(.*)/
+            unless a =~ /class ([<>a-zA-Z\.\d_:]*) ?:?([<>a-zA-Z\.\:, \d_]*)(.*)/
                 raise "cannot parse class #{a}"
             end
             name = $1
@@ -134,7 +142,7 @@ module Rbind
                                  end
                              end
             flags = if flags
-                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact)
+                       normalize_flags(line_number,flags.gsub(" ","").split("/").compact,:Simple)
                     end
             t = RClass.new(name,*parent_classes)
             t = if t2 = type(t.full_name,false)
@@ -147,10 +155,10 @@ module Rbind
                         t2
                     end
                 else
+                    t.name = t.name.gsub(">>","> >")
                     add_type(t)
                     t
                 end
-            t.flags = flags if flags
             line_counter = 1
             lines.each do |line|
                 a = attribute(line_counter+line_number,line,t)
@@ -169,7 +177,7 @@ module Rbind
             flags = first_line.split(" /")
             name = flags.shift.split(" ")[1]
             flags = normalize_flags(line_number,flags)
-            klass = RStruct.new(name,flags)
+            klass = RClass.new(name)
             add_type(klass)
             line_counter = 1
             a.each do |line|
@@ -195,8 +203,7 @@ module Rbind
                        normalize_flags(line_number,flags.gsub(" ","").split("/").compact)
                     end
 
-            c = RConst.new(name,value)
-            c.flags = flags if flags
+            c = RParameter.new(name,find_type(self,"const int"),value)
             c.extern_package_name = @extern_package_name
             add_const(c)
             [c,1]
@@ -237,7 +244,12 @@ module Rbind
             end
             op = ::Rbind::ROperation.new(name,return_type,*args)
             op.alias = alias_name if alias_name && !alias_name.empty?
-            op.flags = normalize_flags(line_number,flags)
+            flags = normalize_flags(line_number,flags,:S)
+            op = if flags.include?(:S)
+                     op.to_static
+                 else
+                     op
+                 end
             type(op.namespace,true).add_operation(op)
             [op,line_counter]
         end