add rust bindings

Author: hendrikmuhs

keyvi/bin/keyvi_c/c_api.cpp

@@ -182,6 +182,29 @@ keyvi_bytes keyvi_match_get_msgpacked_value(const struct keyvi_match* match) {
   return keyvi_bytes{data_size, static_cast<const uint8_t*>(data_ptr)};
 }
 
+keyvi_bytes keyvi_match_get_msgpacked_value_compressed(const struct keyvi_match* match,
+                                                       keyvi::compression::CompressionAlgorithm compression) {
+  const keyvi_bytes empty_keyvi_bytes{0, nullptr};
+
+  if (!match->obj_) {
+    return empty_keyvi_bytes;
+  }
+
+  const std::string compressed_value = match->obj_->GetMsgPackedValueAsString(compression);
+
+  const size_t data_size = compressed_value.size();
+  if (0 == data_size) {
+    return empty_keyvi_bytes;
+  }
+  auto* data_ptr = malloc(data_size);
+  if (nullptr == data_ptr) {
+    return empty_keyvi_bytes;
+  }
+  memcpy(data_ptr, compressed_value.c_str(), data_size);
+
+  return keyvi_bytes{data_size, static_cast<const uint8_t*>(data_ptr)};
+}
+
 char* keyvi_match_get_matched_string(const keyvi_match* match) {
   return std_2_c_string(match->obj_ ? match->obj_->GetMatchedString() : "");
 }

keyvi/include/keyvi/c_api/c_api.h

@@ -32,6 +32,8 @@ extern "C" {
 #include <stddef.h>
 #include <stdint.h>
 
+#include "keyvi/compression/compression_algorithm.h"
+
 struct keyvi_dictionary;
 struct keyvi_match;
 struct keyvi_match_iterator;
@@ -92,6 +94,9 @@ char* keyvi_match_get_value_as_string(const struct keyvi_match*);
 
 keyvi_bytes keyvi_match_get_msgpacked_value(const struct keyvi_match*);
 
+keyvi_bytes keyvi_match_get_msgpacked_value_compressed(const struct keyvi_match*,
+                                                       keyvi::compression::CompressionAlgorithm);
+
 char* keyvi_match_get_matched_string(const struct keyvi_match*);
 
 //////////////////////

rust/Cargo.toml

@@ -19,3 +19,4 @@ serde_json = ">=1.0"
 [dev-dependencies]
 rayon = "0.9"
 rand = ">=0.4"
+snap = "1.1"

rust/build.rs

@@ -49,8 +49,10 @@ fn main() {
         .header("keyvi_core/keyvi/include/keyvi/c_api/c_api.h")
         .clang_arg("-x")
         .clang_arg("c++")
+        .clang_arg("-Ikeyvi_core/keyvi/include")
         .enable_cxx_namespaces()
         .layout_tests(true)
+        .rustified_enum("keyvi::compression::CompressionAlgorithm")
         .allowlist_function("keyvi_bytes_destroy")
         .allowlist_function("keyvi_string_destroy")
         .allowlist_function("keyvi_create_dictionary")
@@ -65,6 +67,7 @@ fn main() {
         .allowlist_function("keyvi_match_destroy")
         .allowlist_function("keyvi_match_get_matched_string")
         .allowlist_function("keyvi_match_get_msgpacked_value")
+        .allowlist_function("keyvi_match_get_msgpacked_value_compressed")
         .allowlist_function("keyvi_match_get_score")
         .allowlist_function("keyvi_match_get_value_as_string")
         .allowlist_function("keyvi_match_is_empty")

rust/src/keyvi_match.rs

@@ -73,6 +73,20 @@ impl KeyviMatch {
         msgpacked_value
     }
 
+    pub fn get_msgpacked_value_compressed(&self, compression_algorithm: root::keyvi::compression::CompressionAlgorithm) -> Vec<u8> {
+        let kv_bytes = unsafe { root::keyvi_match_get_msgpacked_value_compressed(self.match_ptr_, compression_algorithm) };
+        let msgpacked_value = if kv_bytes.data_size == 0 {
+            Vec::new()
+        } else {
+            unsafe {
+                slice::from_raw_parts(kv_bytes.data_ptr, kv_bytes.data_size as usize).to_vec()
+            }
+        };
+        unsafe { root::keyvi_bytes_destroy(kv_bytes) };
+
+        msgpacked_value
+    }
+
     pub fn is_empty(&self) -> bool {
         unsafe { root::keyvi_match_is_empty(self.match_ptr_) }
     }

rust/src/lib.rs

@@ -36,3 +36,5 @@ pub mod dictionary;
 pub mod keyvi_match;
 pub mod keyvi_match_iterator;
 pub mod keyvi_string;
+
+pub type Compression = bindings::root::keyvi::compression::CompressionAlgorithm;

rust/tests/tests.rs

@@ -1,6 +1,7 @@
 extern crate rand;
 extern crate rayon;
 extern crate serde_json;
+extern crate snap;
 
 extern crate keyvi;
 
@@ -10,6 +11,7 @@ mod tests {
     use rand::Rng;
     use rayon::prelude::*;
     use serde_json::Value;
+    use snap::raw::Decoder;
 
     use keyvi::dictionary;
 
@@ -85,6 +87,20 @@ mod tests {
         assert!(m.get_value_as_string().is_empty());
     }
 
+    #[test]
+    fn match_msgpacked_value_compressed_array() {
+        let m = dictionary::Dictionary::new("test_data/test.kv")
+            .unwrap()
+            .get("a");
+
+        assert_eq!(m.get_msgpacked_value_compressed(keyvi::Compression::NO_COMPRESSION), vec![146, 12, 13]);
+
+        let mut snap_decoder = Decoder::new();
+        let value_compressed = m.get_msgpacked_value_compressed(keyvi::Compression::SNAPPY_COMPRESSION);
+        let value_uncompressed = snap_decoder.decompress_vec(&value_compressed);
+        assert_eq!(value_uncompressed.unwrap(), vec![146, 12, 13]);
+    }
+
     #[test]
     fn match_value() {
         let d = dictionary::Dictionary::new("test_data/test.kv").unwrap();