ffi-efl 0.0.2 → 0.0.3

data/lib/efl/elementary.rb

@@ -2,7 +2,20 @@
 # -*- coding: UTF-8 -*-
 #
 require 'efl/evas'
-require 'efl/elementary/elementary-ffi'
+#
+module Efl
+    module Elm
+        extend Efl::FFIHelper
+        steal_ffitype Efl::Evas, :evas_smart_cb
+        steal_ffitype Efl::Evas, :evas_load_error
+        steal_ffitype Efl::Evas, :evas_callback_type
+        steal_ffitype Efl::Evas, :evas_object_box_data_p
+    end
+end
+#
+require 'efl/ffi/elementary'
+#
+Efl::Evas::REvasObject.proxy_list << [Efl::Elm,'elm_'].freeze   # append not prepend !
 #
 module Efl
     module Elm
@@ -10,30 +23,30 @@ module Efl
         class << self
             def init *args
                 a = args.select { |e| e.is_a? String }
-                return Efl::API.elm_init 0, FFI::MemoryPointer::NULL if a.length==0
+                return Efl::Elm.elm_init 0, FFI::MemoryPointer::NULL if a.length==0
                 ptr = FFI::MemoryPointer.new :pointer, a.length
                 a.each_with_index do |s,i|
                     ptr[i].write_pointer FFI::MemoryPointer.from_string(s)
                 end
-                Efl::API.elm_init a.length, ptr
+                Efl::Elm.elm_init a.length, ptr
             end
         end
         #
         class ElmWin
-            include Efl::Helper
-            @func_prefixes = [ 'elm_win_', 'elm_' ].freeze
+            include Efl::ClassHelper
+            proxy_list [Efl::Elm,'elm_win_'].freeze, [Efl::Elm,'elm_'].freeze
             def initialize parent, title, type=:elm_win_basic
-                @evas_object = Evas::EvasObject.new Efl::API.elm_win_add parent, title, type
-                @ptr = @evas_object.ptr
+                @evas_object = Efl::Evas::REvasObject.new Efl::Elm.elm_win_add parent, title, type
+                @ptr = @evas_object.to_ptr
                 yield self,@evas_object if block_given?
             end
             def add e
-                eo = Evas::EvasObject.new Efl::API.send "elm_#{e}_add", @ptr
+                eo = Efl::Evas::REvasObject.new Efl::Elm.send "elm_#{e}_add", @ptr
                 yield eo if block_given?
                 eo
             end
             def smart_callback_add event_str, cb, data=FFI::MemoryPointer::NULL
-                Efl::API.evas_object_smart_callback_add @ptr, event_str, cb, data
+                Efl::Evas.evas_object_smart_callback_add @ptr, event_str, cb, data
             end
         end
         #

data/lib/efl/evas.rb

@@ -1,42 +1,80 @@
 #! /usr/bin/env ruby
 # -*- coding: UTF-8 -*-
 #
-require 'efl/evas/evas-ffi'
+require 'efl/ffi/evas'
 #
 module Efl
+    #
     module Evas
         #
-        class Evas
-            include Efl::Helper
-            @func_prefixes = [ 'evas_' ].freeze
+        EVAS_ENGINE_BUFFER_DEPTH_ARGB32 = 0
+        EVAS_ENGINE_BUFFER_DEPTH_BGRA32 = 1
+        EVAS_ENGINE_BUFFER_DEPTH_RGB24  = 2
+        EVAS_ENGINE_BUFFER_DEPTH_BGR24  = 3
+        EVAS_ENGINE_BUFFER_DEPTH_RGB32  = 4
+        #
+        callback :new_update_region_cb, [:int, :int, :int, :int, :int_p], :pointer
+        callback :free_update_region_cb, [:int, :int, :int, :int, :pointer], :void
+        #
+        class EngineInfoStruct < FFI::Struct
+            layout  :magic,                 :int
+        end
+        class EngineInfoBufferFuncStruct < FFI::Struct
+            layout  :new_update_region,     :new_update_region_cb,
+                    :free_update_region,    :free_update_region_cb
+        end
+        class EngineInfoBufferInfoStruct < FFI::Struct
+            layout  :depth_type,            :int,
+                    :dest_buffer,           :pointer,
+                    :dest_buffer_row_bytes, :int,
+                    :use_color_key,         :char,
+                    :alpha_threshold,       :int,
+                    :color_key_r,           :int,
+                    :color_key_g,           :int,
+                    :color_key_b,           :int,
+                    :func,                  EngineInfoBufferFuncStruct,
+        end
+        class EngineInfoBufferStruct < FFI::Struct
+            layout  :magic,                 EngineInfoStruct,
+                    :info,                  EngineInfoBufferInfoStruct,
+#                    :func,                  EvasEngineInfoBufferFunc,
+                    :mode,                  :evas_engine_render_mode,
+        end
+        #
+        class REvas
+            #
+            include Efl::ClassHelper
+            proxy_list [Efl::Evas,'evas_'].freeze
+            #
             def initialize o=nil
                 @ptr = (
                     case o
                     when NilClass
-                        FFI::AutoPointer.new Efl::API.evas_new, method(:free)
+                        FFI::AutoPointer.new Efl::Evas.evas_new, method(:free)
                     when self.class
-                        o.ptr
+                        o.to_ptr
                     when FFI::AutoPointer
                         o
                     when FFI::Pointer
                         FFI::AutoPointer.new o, method(:free)
                     else
-                        raise ArgumentError.new "#{ptr.class} valid argument"
+                        raise ArgumentError.new "wrong argument #{o.class.name}"
                     end
                 )
                 yield self if block_given?
             end
-            def free
-                Efl::API.evas_free @ptr
+            def free p=nil
+                return Efl::Evas.evas_free p unless p.nil?
+                Efl::Evas.evas_free @ptr
                 @ptr=nil
             end
-            def === o
-                @ptr === o.ptr
+            def object_add t
+                Efl::Evas::REvasObject.new Efl::Evas.send "evas_object_#{t}_add", @ptr
             end
             def output_size_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::API.evas_output_size_get @ptr, x, y
+                Efl::Evas.evas_output_size_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
             def output_viewport_get
@@ -44,45 +82,49 @@ module Efl
                 y = FFI::MemoryPointer.new :int
                 w = FFI::MemoryPointer.new :int
                 h = FFI::MemoryPointer.new :int
-                Efl::API.evas_output_viewport_get @ptr, x, y, w, h
+                Efl::Evas.evas_output_viewport_get @ptr, x, y, w, h
                 [ x.read_int, y.read_int, w.read_int, h.read_int ]
             end
             def pointer_output_xy_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::API.evas_pointer_output_xy_get @ptr, x, y
+                Efl::Evas.evas_pointer_output_xy_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
             def pointer_canvas_xy_get
                 x = FFI::MemoryPointer.new :int
                 y = FFI::MemoryPointer.new :int
-                Efl::API.evas_pointer_canvas_xy_get @ptr, x, y
+                Efl::Evas.evas_pointer_canvas_xy_get @ptr, x, y
                 [ x.read_int, y.read_int ]
             end
         end
         #
-        class EvasObject
-            include Efl::Helper
-            @func_prefixes = [ 'evas_object_', 'evas_' ].freeze
+        class REvasObject
+            #
+            include Efl::ClassHelper
+            proxy_list [Efl::Evas,'evas_object_'].freeze, [Efl::Evas,'evas_'].freeze
+            #
             def initialize o=nil
                 @ptr = (
                     case o
                     when NilClass
-                        FFI::AutoPointer.new Efl::API.evas_new, method(:free)
+                        FFI::AutoPointer.new Efl::Evas.evas_new, method(:free)
                     when self.class
-                        o.ptr
+                        o.to_ptr
                     when FFI::AutoPointer
                         o
                     when FFI::Pointer
                         FFI::AutoPointer.new o, method(:free)
                     else
-                        raise ArgumentError.new "#{ptr.class} valid argument"
+                        raise ArgumentError.new "wrong argument #{o.class.name}"
                     end
                 )
                 yield self if block_given?
             end
-            def free
-                Efl::API.evas_object_del @ptr
+            def free p=nil
+                return Efl::Evas.evas_object_del p unless p.nil?
+                Efl::Evas.evas_object_del @ptr
+                @ptr.free
                 @ptr=nil
             end
             def geometry_get
@@ -90,7 +132,7 @@ module Efl
                 y = FFI::MemoryPointer.new :int
                 w = FFI::MemoryPointer.new :int
                 h = FFI::MemoryPointer.new :int
-                Efl::API.evas_object_geometry_get @evas, x, y, w, h
+                Efl::Evas.evas_object_geometry_get @evas, x, y, w, h
                 [ x.read_int, y.read_int, w.read_int, h.read_int ]
             end
             def color_get
@@ -98,7 +140,7 @@ module Efl
                 g = FFI::MemoryPointer.new :int
                 b = FFI::MemoryPointer.new :int
                 a = FFI::MemoryPointer.new :int
-                Efl::API.evas_object_color_get @evas, r, g, b, a
+                Efl::Evas.evas_object_color_get @evas, r, g, b, a
                 [ r.read_int, g.read_int, b.read_int, a.read_int ]
             end
         end

data/lib/efl/{ecore/ecore-ffi.rb → ffi/ecore.rb}

@@ -6,13 +6,15 @@ require 'efl/ffi'
 module Efl
     #
     module Ecore
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'ecore_'+m.to_s, *args, &block
+            sym = 'ecore_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
         ffi_lib 'ecore'
         #
@@ -384,6 +386,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/{ecore/ecore_evas-ffi.rb → ffi/ecore_evas.rb}

@@ -5,16 +5,18 @@ require 'efl/ffi'
 #
 module Efl
     #
-    module Ecore_evas
+    module EcoreEvas
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'ecore_'+m.to_s, *args, &block
+            sym = 'ecore_evas_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
-        ffi_lib 'ecore'
+        ffi_lib 'ecore_evas'
         #
         # ENUMS
         # typedef enum _Ecore_Evas_Engine_Type {...} Ecore_Evas_Engine_Type;
@@ -372,6 +374,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/{ecore/ecore_getopt-ffi.rb → ffi/ecore_getopt.rb}

@@ -6,13 +6,15 @@ require 'efl/ffi'
 module Efl
     #
     module EcoreGetopt
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'ecore_getopt_'+m.to_s, *args, &block
+            sym = 'ecore_getopt_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
         ffi_lib 'ecore'
         #
@@ -62,6 +64,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/{ecore/ecore_input-ffi.rb → ffi/ecore_input.rb}

@@ -6,15 +6,17 @@ require 'efl/ffi'
 module Efl
     #
     module EcoreInput
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'ecore_'+m.to_s, *args, &block
+            sym = 'ecore_event_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
-        ffi_lib 'ecore'
+        ffi_lib 'ecore_input'
         #
         # ENUMS
         # typedef enum _Ecore_Event_Modifier {...} Ecore_Event_Modifier;
@@ -72,6 +74,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/{edje/edje-ffi.rb → ffi/edje.rb}

@@ -6,13 +6,15 @@ require 'efl/ffi'
 module Efl
     #
     module Edje
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'edje_'+m.to_s, *args, &block
+            sym = 'edje_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
         ffi_lib 'edje'
         #
@@ -121,7 +123,7 @@ module Efl
         fcts = [
         # EAPI extern Edje_Version *edje_version;
         # FIXME
-        # EAPI const char *edje_external_param_type_str(Edje_External_Param_Type type) EINA_PURE;
+        # EAPI const char *edje_external_param_type_str(Edje_External_Param_Type type);
         [ :edje_external_param_type_str, [ :edje_external_param_type ], :string ],
         # EAPI int edje_init (void);
         [ :edje_init, [  ], :int ],
@@ -410,7 +412,7 @@ module Efl
         [ :edje_external_type_array_register, [ :edje_external_type_info_p ], :void ],
         # EAPI void edje_external_type_array_unregister (const Edje_External_Type_Info *array);
         [ :edje_external_type_array_unregister, [ :edje_external_type_info_p ], :void ],
-        # EAPI unsigned int edje_external_type_abi_version_get (void) EINA_CONST;
+        # EAPI unsigned int edje_external_type_abi_version_get (void);
         [ :edje_external_type_abi_version_get, [  ], :uint ],
         # EAPI Eina_Iterator *edje_external_iterator_get (void);
         [ :edje_external_iterator_get, [  ], :eina_iterator_p ],
@@ -453,6 +455,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/{eet/eet-ffi.rb → ffi/eet.rb}

@@ -6,13 +6,15 @@ require 'efl/ffi'
 module Efl
     #
     module Eet
+        #
+        extend Efl::FFIHelper
+        #
         def self.method_missing m, *args, &block
-            return Efl::API.send 'eet_'+m.to_s, *args, &block
+            sym = 'eet_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
         end
-    end
-    #
-    module API
-        #
         #
         ffi_lib 'eet'
         #
@@ -327,6 +329,7 @@ module Efl
         ]
         #
         attach_fcts fcts
+        #
     end
 end
 #

data/lib/efl/ffi/eina.rb

@@ -0,0 +1,48 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi'
+#
+module Efl
+    #
+    module Eina
+        #
+        extend Efl::FFIHelper
+        #
+        def self.method_missing m, *args, &block
+            sym = 'eina_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
+        end
+        #
+        ffi_lib 'eina'
+        #
+        # ENUMS
+        #
+        # TYPEDEFS
+        # typedef struct _Eina_Version Eina_Version;
+        typedef :pointer, :eina_version
+        #
+        # CALLBACKS
+        #
+        # FUNCTIONS
+        fcts = [
+        # EAPI extern Eina_Version *eina_version;
+        # FIXME
+        # EAPI int eina_init(void);
+        [ :eina_init, [  ], :int ],
+        # EAPI int eina_shutdown(void);
+        [ :eina_shutdown, [  ], :int ],
+        # EAPI int eina_threads_init(void);
+        [ :eina_threads_init, [  ], :int ],
+        # EAPI int eina_threads_shutdown(void);
+        [ :eina_threads_shutdown, [  ], :int ],
+        ]
+        #
+        attach_fcts fcts
+        #
+    end
+end
+#
+# EOF

data/lib/efl/ffi/eina_hash.rb

@@ -0,0 +1,111 @@
+#! /usr/bin/env ruby
+# -*- coding: UTF-8 -*-
+#
+require 'efl/ffi'
+#
+module Efl
+    #
+    module EinaHash
+        #
+        extend Efl::FFIHelper
+        #
+        def self.method_missing m, *args, &block
+            sym = 'eina_hash_'+m.to_s
+            raise NameError.new "#{self.name}.#{sym} (#{m})" if not self.respond_to? sym
+            self.module_eval "def self.#{m} *args, █ r=self.#{sym}(*args); yield r if block_given?; r; end"
+            self.send sym, *args, &block
+        end
+        #
+        ffi_lib 'eina'
+        #
+        # ENUMS
+        #
+        # TYPEDEFS
+        # typedef struct _Eina_Hash Eina_Hash;
+        typedef :pointer, :eina_hash
+        typedef :pointer, :eina_hash_p
+        # typedef struct _Eina_Hash_Tuple Eina_Hash_Tuple;
+        typedef :pointer, :eina_hash_tuple
+        #
+        # CALLBACKS
+        # typedef unsigned int (*Eina_Key_Length) (const void *key);
+        callback :eina_key_length, [ :void_p ], :uint
+        # typedef int (*Eina_Key_Cmp) (const void *key1, int key1_length, const void *key2, int key2_length);
+        callback :eina_key_cmp, [ :void_p, :int, :void_p, :int ], :int
+        # typedef int (*Eina_Key_Hash) (const void *key, int key_length);
+        callback :eina_key_hash, [ :void_p, :int ], :int
+        # typedef Eina_Bool (*Eina_Hash_Foreach) (const Eina_Hash *hash, const void *key, void *data, void *fdata);
+        callback :eina_hash_foreach, [ :eina_hash_p, :void_p, :void_p, :void_p ], :eina_bool
+        #
+        # FUNCTIONS
+        fcts = [
+        # EAPI Eina_Hash *eina_hash_new(Eina_Key_Length key_length_cb, Eina_Key_Cmp key_cmp_cb, Eina_Key_Hash key_hash_cb, Eina_Free_Cb data_free_cb, int buckets_power_size);
+        [ :eina_hash_new, [ :eina_key_length, :eina_key_cmp, :eina_key_hash, :eina_free_cb, :int ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_string_djb2_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_string_djb2_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_string_superfast_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_string_superfast_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_string_small_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_string_small_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_int32_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_int32_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_int64_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_int64_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_pointer_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_pointer_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Hash *eina_hash_stringshared_new(Eina_Free_Cb data_free_cb);
+        [ :eina_hash_stringshared_new, [ :eina_free_cb ], :eina_hash_p ],
+        # EAPI Eina_Bool eina_hash_add(Eina_Hash *hash, const void *key, const void *data);
+        [ :eina_hash_add, [ :eina_hash_p, :void_p, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_direct_add(Eina_Hash *hash, const void *key, const void *data);
+        [ :eina_hash_direct_add, [ :eina_hash_p, :void_p, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_del(Eina_Hash *hash, const void *key, const void *data);
+        [ :eina_hash_del, [ :eina_hash_p, :void_p, :void_p ], :eina_bool ],
+        # EAPI void *eina_hash_find(const Eina_Hash *hash, const void *key);
+        [ :eina_hash_find, [ :eina_hash_p, :void_p ], :void_p ],
+        # EAPI void *eina_hash_modify(Eina_Hash *hash, const void *key, const void *data);
+        [ :eina_hash_modify, [ :eina_hash_p, :void_p, :void_p ], :void_p ],
+        # EAPI void *eina_hash_set(Eina_Hash *hash, const void *key, const void *data);
+        [ :eina_hash_set, [ :eina_hash_p, :void_p, :void_p ], :void_p ],
+        # EAPI Eina_Bool eina_hash_move(Eina_Hash *hash, const void *old_key, const void *new_key);
+        [ :eina_hash_move, [ :eina_hash_p, :void_p, :void_p ], :eina_bool ],
+        # EAPI void eina_hash_free(Eina_Hash *hash);
+        [ :eina_hash_free, [ :eina_hash_p ], :void ],
+        # EAPI void eina_hash_free_buckets(Eina_Hash *hash);
+        [ :eina_hash_free_buckets, [ :eina_hash_p ], :void ],
+        # EAPI int eina_hash_population(const Eina_Hash *hash);
+        [ :eina_hash_population, [ :eina_hash_p ], :int ],
+        # EAPI Eina_Bool eina_hash_add_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash, const void *data);
+        [ :eina_hash_add_by_hash, [ :eina_hash_p, :void_p, :int, :int, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_direct_add_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash, const void *data);
+        [ :eina_hash_direct_add_by_hash, [ :eina_hash_p, :void_p, :int, :int, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_del_by_key_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash);
+        [ :eina_hash_del_by_key_hash, [ :eina_hash_p, :void_p, :int, :int ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_del_by_key(Eina_Hash *hash, const void *key);
+        [ :eina_hash_del_by_key, [ :eina_hash_p, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_del_by_data(Eina_Hash *hash, const void *data);
+        [ :eina_hash_del_by_data, [ :eina_hash_p, :void_p ], :eina_bool ],
+        # EAPI Eina_Bool eina_hash_del_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash, const void *data);
+        [ :eina_hash_del_by_hash, [ :eina_hash_p, :void_p, :int, :int, :void_p ], :eina_bool ],
+        # EAPI void *eina_hash_find_by_hash(const Eina_Hash *hash, const void *key, int key_length, int key_hash);
+        [ :eina_hash_find_by_hash, [ :eina_hash_p, :void_p, :int, :int ], :void_p ],
+        # EAPI void *eina_hash_modify_by_hash(Eina_Hash *hash, const void *key, int key_length, int key_hash, const void *data);
+        [ :eina_hash_modify_by_hash, [ :eina_hash_p, :void_p, :int, :int, :void_p ], :void_p ],
+        # EAPI Eina_Iterator *eina_hash_iterator_key_new(const Eina_Hash *hash);
+        [ :eina_hash_iterator_key_new, [ :eina_hash_p ], :eina_iterator_p ],
+        # EAPI Eina_Iterator *eina_hash_iterator_data_new(const Eina_Hash *hash);
+        [ :eina_hash_iterator_data_new, [ :eina_hash_p ], :eina_iterator_p ],
+        # EAPI Eina_Iterator *eina_hash_iterator_tuple_new(const Eina_Hash *hash);
+        [ :eina_hash_iterator_tuple_new, [ :eina_hash_p ], :eina_iterator_p ],
+        # EAPI void eina_hash_foreach(const Eina_Hash *hash, Eina_Hash_Foreach cb, const void *fdata);
+        [ :eina_hash_foreach, [ :eina_hash_p, :eina_hash_foreach, :void_p ], :void ],
+        # EAPI int eina_hash_superfast(const char *key, int len);
+        [ :eina_hash_superfast, [ :string, :int ], :int ],
+        ]
+        #
+        attach_fcts fcts
+        #
+    end
+end
+#
+# EOF