Add ruby/python ffi call rust dylib example

Author: pymongo

c_call_rust_lib/main.c

@@ -9,9 +9,15 @@ typedef struct {
     int x;
     int y;
 } Point;
-
 void print_point(Point point);
 
+// Rust:Box<T> -> C:opaque type(不透明数据类型)
+typedef struct OpaqueType Map;
+Map* map_new();
+void map_insert(Map* map, int k, int v);
+int map_get(Map* map, int k);
+void map_free(Map* map);
+
 /*
 static  link:
 cargo build && gcc main.c ../target/debug/libc_call_rust_lib.a && ./a.out
@@ -29,5 +35,11 @@ int main() {
     printf("sum = %d\n", sum);
     Point point = {.x=1, .y=2};
     print_point(point);
+
+    Map* map = map_new();
+    map_insert(map, 1, 1);
+    printf("map_get(map, 1) = %d\n", map_get(map, 1));
+    printf("map_get(map, 2) = %d\n", map_get(map, 2));
+    map_free(map);
     return 0;
 }

c_call_rust_lib/python_call_rust_lib.py

@@ -0,0 +1,39 @@
+#!/usr/bin/python3
+
+import ctypes
+
+
+class MapPtr(ctypes.Structure):
+    pass
+
+
+lib = ctypes.cdll.LoadLibrary("../target/debug/libc_call_rust_lib.dylib")
+lib.map_new.restype = ctypes.POINTER(MapPtr)
+lib.map_insert.argtypes = (ctypes.POINTER(MapPtr), ctypes.c_int, ctypes.c_int)
+lib.map_get.argtypes = (ctypes.POINTER(MapPtr), ctypes.c_int)
+lib.map_get.restype = ctypes.c_int
+lib.map_free.argtypes = (ctypes.POINTER(MapPtr),)
+
+
+class Map:
+    def __init__(self):
+        self.ptr: ctypes.POINTER(MapPtr) = lib.map_new()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        lib.map_free(self.ptr)
+
+    def insert(self, k: int, v: int):
+        lib.map_insert(self.ptr, k, v)
+
+    def get(self, k: int) -> int:
+        return lib.map_get(self.ptr, k)
+
+
+if __name__ == '__main__':
+    with Map() as my_map:
+        my_map.insert(1, 1)
+        print(f"map.get(1) = {my_map.get(1)}")
+        print(f"map.get(2) = {my_map.get(2)}")

c_call_rust_lib/ruby_call_rust_lib.rb

@@ -0,0 +1,17 @@
+#!/usr/bin/ruby
+
+require 'ffi'
+
+module MyLib
+    extend FFI::Library
+    ffi_lib "/Users/wuaoxiang/workspace/my_repo_or_learn/rust_learn/target/debug/libc_call_rust_lib.dylib"
+    attach_function :map_new, [], :pointer
+    attach_function :map_insert, [:pointer, :int, :int], :int
+    attach_function :map_get, [:pointer, :int], :int
+    attach_function :map_free, [:pointer], :void
+end
+
+map = MyLib.map_new
+MyLib.map_insert(map, 1, 1)
+p MyLib.map_get(map, 1)
+MyLib.map_free(map)

c_call_rust_lib/src/lib.rs

@@ -56,3 +56,61 @@ pub struct Point {
 pub extern "C" fn print_point(point: Point) {
     dbg!(point);
 }
+
+use std::collections::HashMap;
+pub struct Map(HashMap<c_int, c_int>);
+
+impl Map {
+    fn new() -> Self {
+        Self(HashMap::new())
+    }
+
+    fn insert(&mut self, key: c_int, value: c_int) {
+        self.0.insert(key, value);
+    }
+
+    fn get(&self, key: c_int) -> c_int {
+        return if let Some(&val) = self.0.get(&key) {
+            val
+        } else {
+            c_int::from(-1)
+        };
+    }
+}
+
+// Rust:Box<T> -> C:opaque type(不透明数据类型)
+#[no_mangle]
+pub extern "C" fn map_new() -> *mut Map {
+    // Map::new() as *mut Map
+    Box::into_raw(Box::new(Map::new()))
+}
+
+#[no_mangle]
+pub extern "C" fn map_insert(map: *mut Map, k: c_int, v: c_int) {
+    if map.is_null() {
+        return;
+    }
+    let map_deref = unsafe {
+        &mut *map
+    };
+    map_deref.insert(k, v);
+}
+
+#[no_mangle]
+pub extern "C" fn map_get(map: *const Map, k: c_int) -> c_int {
+    if map.is_null() {
+        return c_int::from(-1);
+    }
+    let map_deref = unsafe {
+        &*map
+    };
+    map_deref.get(k)
+}
+
+#[no_mangle]
+pub extern "C" fn map_free(map: *mut Map) {
+    if map.is_null() {
+        return;
+    }
+    Box::from(map);
+}