|
| 1 | +# Using Generated Bindings |
| 2 | + |
| 3 | +Consider following header file: |
| 4 | + |
| 5 | +```c |
| 6 | +struct point { |
| 7 | + float x; |
| 8 | + float y; |
| 9 | +}; |
| 10 | + |
| 11 | +struct vector { |
| 12 | + struct point a; |
| 13 | + struct point b; |
| 14 | +}; |
| 15 | + |
| 16 | +struct vector *add(struct vector *v1, struct vector *v2); |
| 17 | +``` |
| 18 | +
|
| 19 | +Bindgen will generate type aliases for the structs, binding for function `add` |
| 20 | +and helper functions that make usage of structs easier. |
| 21 | +```scala |
| 22 | +import scala.scalanative._ |
| 23 | +import scala.scalanative.native._ |
| 24 | +
|
| 25 | +@native.link("mylib") |
| 26 | +@native.extern |
| 27 | +object mylib { |
| 28 | + type struct_point = native.CStruct2[native.CFloat, native.CFloat] |
| 29 | + type struct_vector = native.CStruct2[struct_point, struct_point] |
| 30 | + def add(v1: native.Ptr[struct_vector], v2: native.Ptr[struct_vector]): native.Ptr[struct_vector] = native.extern |
| 31 | +} |
| 32 | +
|
| 33 | +import mylib._ |
| 34 | +
|
| 35 | +object mylibHelpers { |
| 36 | +
|
| 37 | + implicit class struct_point_ops(val p: native.Ptr[struct_point]) extends AnyVal { |
| 38 | + def x: native.CFloat = !p._1 |
| 39 | + def x_=(value: native.CFloat): Unit = !p._1 = value |
| 40 | + def y: native.CFloat = !p._2 |
| 41 | + def y_=(value: native.CFloat): Unit = !p._2 = value |
| 42 | + } |
| 43 | +
|
| 44 | + def struct_point()(implicit z: native.Zone): native.Ptr[struct_point] = native.alloc[struct_point] |
| 45 | +
|
| 46 | + implicit class struct_vector_ops(val p: native.Ptr[struct_vector]) extends AnyVal { |
| 47 | + def a: native.Ptr[struct_point] = p._1 |
| 48 | + def a_=(value: native.Ptr[struct_point]): Unit = !p._1 = !value |
| 49 | + def b: native.Ptr[struct_point] = p._2 |
| 50 | + def b_=(value: native.Ptr[struct_point]): Unit = !p._2 = !value |
| 51 | + } |
| 52 | +
|
| 53 | + def struct_vector()(implicit z: native.Zone): native.Ptr[struct_vector] = native.alloc[struct_vector] |
| 54 | +} |
| 55 | +``` |
| 56 | +Let's write code that creates two vectors, adds them and prints resulting |
| 57 | +vector. |
| 58 | + |
| 59 | +First we need to create points for vectors. We will use `native.Zone` to |
| 60 | +allocate struct (more information on memory management can be found |
| 61 | +here: [Scala Native memory management]). |
| 62 | + |
| 63 | +Helper object `mylibHelpers` contains function for struct allocation. |
| 64 | +To import it use `import mylibHelpers._` |
| 65 | + |
| 66 | +Let's create points for first vector: |
| 67 | +```scala |
| 68 | +import mylibHelpers._ |
| 69 | +import scala.scalanative.native.Zone |
| 70 | + |
| 71 | +object Hello extends App { |
| 72 | + Zone { implicit zone => |
| 73 | + val vec1p1 = struct_point() |
| 74 | + val vec1p2 = struct_point() |
| 75 | + } |
| 76 | +} |
| 77 | +``` |
| 78 | + |
| 79 | +Now we want to set fields of created points. Scala Native provides access |
| 80 | +to fields by using `_N` methods where `N` is index of a field |
| 81 | +(see [Scala Native memory layout types]). |
| 82 | + |
| 83 | +Bindgen generates implicit helper classes that wrap calls to `_N` in functions |
| 84 | +with meaningful names. We already imported helper class, so we can use the |
| 85 | +functions: |
| 86 | +```scala |
| 87 | +vec1p1.x = 0 |
| 88 | +vec1p1.y = 1 |
| 89 | + |
| 90 | +vec1p2.x = 6 |
| 91 | +vec1p2.y = 3 |
| 92 | +``` |
| 93 | + |
| 94 | +Lets create first vector. Note that `struct_vector` contains |
| 95 | +fields of type `struct_point` but setters accept variables of type |
| 96 | +`native.Ptr[struct_point]`. It helps to avoid Scala Native limitation that |
| 97 | +does not allow passing structs and arrays by value |
| 98 | +(see @github[scala-native/scala-native#555](scala-native/scala-native#555)). |
| 99 | +```scala |
| 100 | +val vec1 = struct_vector() |
| 101 | +vec1.a = vec1p1 |
| 102 | +vec1.b = vec1p2 |
| 103 | +``` |
| 104 | +Repeat these steps to create second vector. Once both vectors are created we can |
| 105 | +call `add` function and print the result: |
| 106 | +```scala |
| 107 | +val vec3 = mylib.add(vec1, vec2) |
| 108 | +println(s"(${vec3.a.x}, ${vec3.a.y}), (${vec3.b.x}, ${vec3.b.y})") |
| 109 | +``` |
| 110 | + |
| 111 | + [Scala Native memory management]: http://www.scala-native.org/en/latest/user/interop.html#memory-management |
| 112 | + [Scala Native memory layout types]: http://www.scala-native.org/en/latest/user/interop.html#memory-layout-types |
0 commit comments