Add rpc-port-parcel APIs for rust

Change-Id: Id1951c9e87fca4d24390c6d3d71126628b298be3
Signed-off-by: pjh9216 <jh9216.park@samsung.com>

diff --git a/src/rust-rpc-port/src/parcel/mod.rs b/src/rust-rpc-port/src/parcel/mod.rs
index b2cab606215932e3e04dae162fc961937aa84297..a904907afbb60206c19102235a49f62c4db45e3d 100644 (file)
--- a/src/rust-rpc-port/src/parcel/mod.rs
+++ b/src/rust-rpc-port/src/parcel/mod.rs
@@ -43,6 +43,14 @@ extern "C" {
     fn rpc_port_parcel_read_array_count(h: *mut c_void, count: *mut i32) -> i32;
     fn rpc_port_parcel_burst_read(h: *mut c_void, buf: *mut u8, size: u32) -> i32;
     fn rpc_port_parcel_burst_write(h: *mut c_void, buf: *const u8, size: u32) -> i32;
+    fn rpc_port_parcel_reserve(h: *mut c_void, size: u32) -> i32;
+    fn rpc_port_parcel_create_from_parcel(h: *mut *mut c_void, origin_parcel: *mut c_void,
+        start_pos: u32, size: u32) -> i32;
+    fn rpc_port_parcel_set_data_size(h: *mut c_void, size: u32) -> i32;
+    fn rpc_port_parcel_get_data_size(h: *mut c_void, size: *mut u32) -> i32;
+    fn rpc_port_parcel_pin(h: *mut c_void) -> i32;
+    fn rpc_port_parcel_get_reader(h: *mut c_void, reader_pos: *mut u32) -> i32;
+    fn rpc_port_parcel_set_reader(h: *mut c_void, reader_pos: u32) -> i32;
 }
 
 #[derive(Debug)]
@@ -58,6 +66,13 @@ impl Parcel {
         Self { handle }
     }
 
+    pub fn new_from(origin_parcel: &Parcel, start_pos: u32, size: u32) -> Self {
+        let mut handle = std::ptr::null_mut();
+        let ret = unsafe { rpc_port_parcel_create_from_parcel(&mut handle, origin_parcel.handle, start_pos, size) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_create_from_parcel : {}", ret);
+        Self { handle }
+    }
+
     pub fn new_without_header() -> Self {
         let mut handle = std::ptr::null_mut();
         let ret = unsafe { rpc_port_parcel_create_without_header(&mut handle) };
@@ -287,6 +302,40 @@ impl Parcel {
         let ret = unsafe { rpc_port_parcel_burst_write(self.handle, ptr, buf.len() as u32) };
         assert_eq!(ret, 0, "failed at rpc_port_parcel_burst_write : {}", ret);
     }
+
+    pub fn reserve(&self, size: u32) {
+        let ret = unsafe { rpc_port_parcel_reserve(self.handle, size) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_reserve : {}", ret);
+    }
+
+    pub fn set_data_size(&self, size: u32) {
+        let ret = unsafe { rpc_port_parcel_set_data_size(self.handle, size) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_set_data_size : {}", ret);
+    }
+
+    pub fn get_data_size(&self) -> u32 {
+        let mut size = 0;
+        let ret = unsafe { rpc_port_parcel_get_data_size(self.handle, &mut size as *mut u32) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_get_data_size : {}", ret);
+        size
+    }
+
+    pub fn pin(&self) {
+        let ret = unsafe { rpc_port_parcel_pin(self.handle) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_pin : {}", ret);
+    }
+
+    pub fn set_reader(&self, reader_pos: u32) {
+        let ret = unsafe { rpc_port_parcel_set_reader(self.handle, reader_pos) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_set_reader : {}", ret);
+    }
+
+    pub fn get_reader(&self) -> u32 {
+        let mut reader_pos = 0;
+        let ret = unsafe { rpc_port_parcel_get_reader(self.handle, &mut reader_pos as *mut u32) };
+        assert_eq!(ret, 0, "failed at rpc_port_parcel_get_reader : {}", ret);
+        reader_pos
+    }
 }
 
 impl Drop for Parcel {

diff --git a/src/rust-rpc-port/src/parcel/tests.rs b/src/rust-rpc-port/src/parcel/tests.rs
index 20c9acb0a2a813d636eb03c10abe2916898041bc..648804bfa58bf42452c5509f8fb0f60fae836978 100644 (file)
--- a/src/rust-rpc-port/src/parcel/tests.rs
+++ b/src/rust-rpc-port/src/parcel/tests.rs
@@ -143,4 +143,52 @@ fn test_parcel_from_raw() {
     let parcel2 = Parcel::from_raw(&raw);
     let test_str = parcel2.read_string();
     assert_eq!(test_str, "test");
-  }
+}
+
+#[test]
+fn test_parcel_get_set_data_size() {
+    let mut parcel = Parcel::new();
+
+    parcel.write_str("test");
+    parcel.set_data_size(4);
+    let size = parcel.get_data_size();
+    assert_eq!(size, 4);
+}
+
+#[test]
+fn test_parcel_reserve() {
+    let mut parcel = Parcel::new();
+
+    parcel.write_str("test");
+    parcel.set_data_size(0);
+    parcel.reserve(4);
+
+    let size = parcel.get_data_size();
+    assert_eq!(size, 4);
+}
+
+#[test]
+fn test_parcel_pin() {
+    let mut parcel = Parcel::new();
+
+    parcel.write_str("test");
+    parcel.pin();
+
+    let mut sub_parcel = Parcel::new_from(&parcel, 0, 4);
+}
+
+#[test]
+fn test_parcel_create_from_parcel() {
+    let mut parcel = Parcel::new();
+    parcel.write_str("test");
+    let data_size1 = parcel.get_data_size();
+    parcel.write_str("str1");
+    let data_size2 = parcel.get_data_size();
+    parcel.pin();
+
+    let mut sub_parcel = Parcel::new_from(&parcel, data_size1, data_size2 - data_size1);
+    sub_parcel.reserve(data_size2 - data_size1);
+    let s = sub_parcel.read_string();
+
+    assert_eq!(s, "str1");
+}