You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@arrow.apache.org by uw...@apache.org on 2018/04/03 04:47:39 UTC
[arrow] branch master updated: ARROW-2378: [Rust] Rustfmt
This is an automated email from the ASF dual-hosted git repository.
uwe pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/arrow.git
The following commit(s) were added to refs/heads/master by this push:
new fce183c ARROW-2378: [Rust] Rustfmt
fce183c is described below
commit fce183cc0c5ccfa0b4fafc268f36af6177a5ccd3
Author: Maximilian Roos <m...@maxroos.com>
AuthorDate: Tue Apr 3 06:47:34 2018 +0200
ARROW-2378: [Rust] Rustfmt
As discussed in https://github.com/apache/arrow/pull/1818
Probably worth merging fairly soon to minimize conflicts. I'll iterate quickly on any feedback.
Author: Maximilian Roos <m...@maxroos.com>
Closes #1825 from maxim-lian/rustfmt and squashes the following commits:
bfeeb54 <Maximilian Roos> rustfmt-preview
fe7c228 <Maximilian Roos> move cargo fmt to rust script
e224515 <Maximilian Roos> hanging space
2c6375b <Maximilian Roos> travis lint
8a6f223 <Maximilian Roos> cargo fmt
---
ci/travis_script_rust.sh | 3 +
rust/src/array.rs | 157 +++++++++++++++++++++++++----------------------
rust/src/bitmap.rs | 34 +++++-----
rust/src/buffer.rs | 18 +++---
rust/src/datatypes.rs | 46 +++++++-------
rust/src/error.rs | 10 +--
rust/src/lib.rs | 1 -
rust/src/list.rs | 20 +++---
8 files changed, 154 insertions(+), 135 deletions(-)
diff --git a/ci/travis_script_rust.sh b/ci/travis_script_rust.sh
index 89554f6..4405d03 100755
--- a/ci/travis_script_rust.sh
+++ b/ci/travis_script_rust.sh
@@ -23,6 +23,9 @@ RUST_DIR=${TRAVIS_BUILD_DIR}/rust
pushd $RUST_DIR
+rustup component add rustfmt-preview
+cargo fmt --all -- --write-mode=diff
+cargo build
cargo test
popd
diff --git a/rust/src/array.rs b/rust/src/array.rs
index 15d89c3..6f377cb 100644
--- a/rust/src/array.rs
+++ b/rust/src/array.rs
@@ -39,18 +39,17 @@ pub enum ArrayData {
UInt32(Buffer<u32>),
UInt64(Buffer<u64>),
Utf8(List<u8>),
- Struct(Vec<Rc<Array>>)
+ Struct(Vec<Rc<Array>>),
}
macro_rules! arraydata_from_primitive {
- ($DT:ty, $AT:ident) => {
+ ($DT: ty, $AT: ident) => {
impl From<Vec<$DT>> for ArrayData {
fn from(v: Vec<$DT>) -> Self {
ArrayData::$AT(Buffer::from(v))
}
}
-
- }
+ };
}
arraydata_from_primitive!(bool, Boolean);
@@ -69,14 +68,18 @@ pub struct Array {
pub len: i32,
pub null_count: i32,
pub validity_bitmap: Option<Bitmap>,
- pub data: ArrayData
+ pub data: ArrayData,
}
impl Array {
-
/// Create a new array where there are no null values
pub fn new(len: usize, data: ArrayData) -> Self {
- Array { len: len as i32, data, validity_bitmap: None, null_count: 0 }
+ Array {
+ len: len as i32,
+ data,
+ validity_bitmap: None,
+ null_count: 0,
+ }
}
pub fn data(&self) -> &ArrayData {
@@ -86,7 +89,6 @@ impl Array {
pub fn len(&self) -> usize {
self.len as usize
}
-
}
/// type-safe array operations
@@ -95,54 +97,54 @@ trait ArrayOps<T> {
/// will pattern match the type of the array on every invocation. We should add
/// other efficient iterator and map methods so we can perform columnar operations
/// instead.
- fn get(&self, i: usize) -> Result<T,Error>;
+ fn get(&self, i: usize) -> Result<T, Error>;
/// Compare two same-typed arrays using a boolean closure e.g. eq, gt, lt, and so on
- fn compare(&self, other: &Array, f: &Fn(T,T) -> bool) -> Result<Vec<bool>, Error>;
+ fn compare(&self, other: &Array, f: &Fn(T, T) -> bool) -> Result<Vec<bool>, Error>;
/// Perform a computation on two same-typed arrays and produce a result of the same type e.g. c = a + b
- fn compute(&self, other: &Array, f: &Fn(T,T) -> T) -> Result<Vec<T>, Error>;
+ fn compute(&self, other: &Array, f: &Fn(T, T) -> T) -> Result<Vec<T>, Error>;
}
macro_rules! array_ops {
- ($DT:ty, $AT:ident) => {
+ ($DT: ty, $AT: ident) => {
impl ArrayOps<$DT> for Array {
- fn get(&self, i: usize) -> Result<$DT,Error> {
+ fn get(&self, i: usize) -> Result<$DT, Error> {
match self.data() {
- &ArrayData::$AT(ref buf) => Ok(unsafe {*buf.data().offset(i as isize)}),
- _ => Err(Error::from("Request for $DT but array is not $DT"))
+ &ArrayData::$AT(ref buf) => Ok(unsafe { *buf.data().offset(i as isize) }),
+ _ => Err(Error::from("Request for $DT but array is not $DT")),
}
}
- fn compare(&self, other: &Array, f: &Fn($DT,$DT) -> bool) -> Result<Vec<bool>, Error> {
+ fn compare(&self, other: &Array, f: &Fn($DT, $DT) -> bool) -> Result<Vec<bool>, Error> {
match (&self.data, &other.data) {
(&ArrayData::$AT(ref l), &ArrayData::$AT(ref r)) => {
let mut b: Vec<bool> = Vec::with_capacity(self.len as usize);
for i in 0..self.len as isize {
- let lv : $DT = unsafe { *l.data().offset(i) };
- let rv : $DT = unsafe { *r.data().offset(i) };
- b.push(f(lv,rv));
+ let lv: $DT = unsafe { *l.data().offset(i) };
+ let rv: $DT = unsafe { *r.data().offset(i) };
+ b.push(f(lv, rv));
}
Ok(b)
- },
- _ => Err(Error::from("Cannot compare arrays of this type"))
+ }
+ _ => Err(Error::from("Cannot compare arrays of this type")),
}
}
- fn compute(&self, other: &Array, f: &Fn($DT,$DT) -> $DT) -> Result<Vec<$DT>, Error> {
+ fn compute(&self, other: &Array, f: &Fn($DT, $DT) -> $DT) -> Result<Vec<$DT>, Error> {
match (&self.data, &other.data) {
(&ArrayData::$AT(ref l), &ArrayData::$AT(ref r)) => {
let mut b: Vec<$DT> = Vec::with_capacity(self.len as usize);
for i in 0..self.len as isize {
- let lv : $DT = unsafe { *l.data().offset(i) };
- let rv : $DT = unsafe { *r.data().offset(i) };
- b.push(f(lv,rv));
+ let lv: $DT = unsafe { *l.data().offset(i) };
+ let rv: $DT = unsafe { *r.data().offset(i) };
+ b.push(f(lv, rv));
}
Ok(b)
- },
- _ => Err(Error::from("Cannot compare arrays of this type"))
+ }
+ _ => Err(Error::from("Cannot compare arrays of this type")),
}
}
}
- }
+ };
}
array_ops!(bool, Boolean);
@@ -158,14 +160,18 @@ array_ops!(i32, Int32);
array_ops!(i64, Int64);
macro_rules! array_from_primitive {
- ($DT:ty) => {
+ ($DT: ty) => {
impl From<Vec<$DT>> for Array {
fn from(v: Vec<$DT>) -> Self {
- Array { len: v.len() as i32, null_count: 0, validity_bitmap: None, data: ArrayData::from(v) }
+ Array {
+ len: v.len() as i32,
+ null_count: 0,
+ validity_bitmap: None,
+ data: ArrayData::from(v),
+ }
}
}
- }
-
+ };
}
array_from_primitive!(bool);
@@ -180,23 +186,29 @@ array_from_primitive!(i32);
array_from_primitive!(i64);
macro_rules! array_from_optional_primitive {
- ($DT:ty, $DEFAULT:expr) => {
+ ($DT: ty, $DEFAULT: expr) => {
impl From<Vec<Option<$DT>>> for Array {
fn from(v: Vec<Option<$DT>>) -> Self {
let mut null_count = 0;
let mut validity_bitmap = Bitmap::new(v.len());
- for i in 0 .. v.len() {
+ for i in 0..v.len() {
if v[i].is_none() {
- null_count+=1;
+ null_count += 1;
validity_bitmap.clear(i);
}
}
- let values = v.iter().map(|x| x.unwrap_or($DEFAULT)).collect::<Vec<$DT>>();
- Array { len: values.len() as i32, null_count, validity_bitmap: Some(validity_bitmap), data: ArrayData::from(values) }
+ let values = v.iter()
+ .map(|x| x.unwrap_or($DEFAULT))
+ .collect::<Vec<$DT>>();
+ Array {
+ len: values.len() as i32,
+ null_count,
+ validity_bitmap: Some(validity_bitmap),
+ data: ArrayData::from(values),
+ }
}
}
- }
-
+ };
}
array_from_optional_primitive!(bool, false);
@@ -223,7 +235,7 @@ impl From<Vec<String>> for Array {
len: v.len() as i32,
null_count: 0,
validity_bitmap: None,
- data: ArrayData::Utf8(List::from(v))
+ data: ArrayData::Utf8(List::from(v)),
}
}
}
@@ -234,7 +246,7 @@ impl From<Vec<Rc<Array>>> for Array {
len: v.len() as i32,
null_count: 0,
validity_bitmap: None,
- data: ArrayData::Struct(v.iter().map(|a| a.clone()).collect())
+ data: ArrayData::Struct(v.iter().map(|a| a.clone()).collect()),
}
}
}
@@ -249,15 +261,18 @@ mod tests {
let a = Array::from(vec!["this", "is", "a", "test"]);
assert_eq!(4, a.len());
match a.data() {
- &ArrayData::Utf8(List{ ref data, ref offsets }) => {
+ &ArrayData::Utf8(List {
+ ref data,
+ ref offsets,
+ }) => {
assert_eq!(11, data.len());
assert_eq!(0, *offsets.get(0));
assert_eq!(4, *offsets.get(1));
assert_eq!(6, *offsets.get(2));
assert_eq!(7, *offsets.get(3));
assert_eq!(11, *offsets.get(4));
- },
- _ => panic!()
+ }
+ _ => panic!(),
}
}
@@ -271,8 +286,8 @@ mod tests {
assert_eq!("is", str::from_utf8(d.slice(1)).unwrap());
assert_eq!("a", str::from_utf8(d.slice(2)).unwrap());
assert_eq!("test", str::from_utf8(d.slice(3)).unwrap());
- },
- _ => panic!()
+ }
+ _ => panic!(),
}
}
@@ -290,7 +305,6 @@ mod tests {
#[test]
fn test_from_i32() {
-
let a = Array::from(vec![15, 14, 13, 12, 11]);
assert_eq!(5, a.len());
@@ -316,58 +330,53 @@ mod tests {
#[test]
fn test_struct() {
-
let _schema = Schema::new(vec![
Field::new("a", DataType::Int32, false),
Field::new("b", DataType::Float32, false),
]);
- let a = Rc::new(Array::from(vec![1,2,3,4,5]));
+ let a = Rc::new(Array::from(vec![1, 2, 3, 4, 5]));
let b = Rc::new(Array::from(vec![1.1, 2.2, 3.3, 4.4, 5.5]));
- let _ = Rc::new(Array::from(vec![a,b]));
+ let _ = Rc::new(Array::from(vec![a, b]));
}
#[test]
fn test_array_eq() {
- let a = Array::from(vec![1,2,3,4,5]);
- let b = Array::from(vec![5,4,3,2,1]);
- let c = a.compare(&b, &|a: i32,b: i32| a == b).unwrap();
- assert_eq!(c, vec![false,false,true,false,false]);
+ let a = Array::from(vec![1, 2, 3, 4, 5]);
+ let b = Array::from(vec![5, 4, 3, 2, 1]);
+ let c = a.compare(&b, &|a: i32, b: i32| a == b).unwrap();
+ assert_eq!(c, vec![false, false, true, false, false]);
}
#[test]
fn test_array_lt() {
- let a = Array::from(vec![1,2,3,4,5]);
- let b = Array::from(vec![5,4,3,2,1]);
- let c = a.compare(&b, &|a: i32,b: i32| a < b).unwrap();
- assert_eq!(c, vec![true,true,false,false,false]);
+ let a = Array::from(vec![1, 2, 3, 4, 5]);
+ let b = Array::from(vec![5, 4, 3, 2, 1]);
+ let c = a.compare(&b, &|a: i32, b: i32| a < b).unwrap();
+ assert_eq!(c, vec![true, true, false, false, false]);
}
#[test]
fn test_array_gt() {
- let a = Array::from(vec![1,2,3,4,5]);
- let b = Array::from(vec![5,4,3,2,1]);
- let c = a.compare(&b, &|a: i32,b: i32| a > b).unwrap();
- assert_eq!(c, vec![false,false,false,true,true]);
+ let a = Array::from(vec![1, 2, 3, 4, 5]);
+ let b = Array::from(vec![5, 4, 3, 2, 1]);
+ let c = a.compare(&b, &|a: i32, b: i32| a > b).unwrap();
+ assert_eq!(c, vec![false, false, false, true, true]);
}
#[test]
fn test_array_add() {
- let a = Array::from(vec![1,2,3,4,5]);
- let b = Array::from(vec![5,4,3,2,1]);
- let c = a.compute(&b, &|a: i32,b: i32| a + b).unwrap();
- assert_eq!(c, vec![6,6,6,6,6]);
+ let a = Array::from(vec![1, 2, 3, 4, 5]);
+ let b = Array::from(vec![5, 4, 3, 2, 1]);
+ let c = a.compute(&b, &|a: i32, b: i32| a + b).unwrap();
+ assert_eq!(c, vec![6, 6, 6, 6, 6]);
}
#[test]
fn test_array_multiply() {
- let a = Array::from(vec![1,2,3,4,5]);
- let b = Array::from(vec![5,4,3,2,1]);
- let c = a.compute(&b, &|a: i32,b: i32| a * b).unwrap();
- assert_eq!(c, vec![5,8,9,8,5]);
+ let a = Array::from(vec![1, 2, 3, 4, 5]);
+ let b = Array::from(vec![5, 4, 3, 2, 1]);
+ let c = a.compute(&b, &|a: i32, b: i32| a * b).unwrap();
+ assert_eq!(c, vec![5, 8, 9, 8, 5]);
}
}
-
-
-
-
diff --git a/rust/src/bitmap.rs b/rust/src/bitmap.rs
index 94c513a..59c6513 100644
--- a/rust/src/bitmap.rs
+++ b/rust/src/bitmap.rs
@@ -18,20 +18,25 @@
use super::buffer::Buffer;
pub struct Bitmap {
- bits: Buffer<u8>
+ bits: Buffer<u8>,
}
impl Bitmap {
-
pub fn new(num_bits: usize) -> Self {
- let num_bytes = num_bits/8 + if num_bits%8 > 0 { 1 } else { 0 };
+ let num_bytes = num_bits / 8 + if num_bits % 8 > 0 { 1 } else { 0 };
let r = num_bytes % 64;
- let len = if r==0 { num_bytes } else { num_bytes + 64-r };
+ let len = if r == 0 {
+ num_bytes
+ } else {
+ num_bytes + 64 - r
+ };
let mut v = Vec::with_capacity(len);
- for _ in 0 .. len {
+ for _ in 0..len {
v.push(255); // 1 is not null
}
- Bitmap { bits: Buffer::from(v) }
+ Bitmap {
+ bits: Buffer::from(v),
+ }
}
pub fn len(&self) -> i32 {
@@ -45,15 +50,13 @@ impl Bitmap {
pub fn set(&mut self, i: usize) {
let byte_offset = i / 8;
- let v : u8 = {
- self.bits.get(byte_offset) | (1_u8 << ((i % 8) as u8))
- };
+ let v: u8 = { self.bits.get(byte_offset) | (1_u8 << ((i % 8) as u8)) };
self.bits.set(byte_offset, v);
}
pub fn clear(&mut self, i: usize) {
let byte_offset = i / 8;
- let v : u8 = self.bits.get(byte_offset) ^ (1_u8 << ((i % 8) as u8));
+ let v: u8 = self.bits.get(byte_offset) ^ (1_u8 << ((i % 8) as u8));
self.bits.set(byte_offset, v);
}
}
@@ -64,14 +67,14 @@ mod tests {
#[test]
fn test_bitmap_length() {
- assert_eq!(64, Bitmap::new(63*8).len());
- assert_eq!(64, Bitmap::new(64*8).len());
- assert_eq!(128, Bitmap::new(65*8).len());
+ assert_eq!(64, Bitmap::new(63 * 8).len());
+ assert_eq!(64, Bitmap::new(64 * 8).len());
+ assert_eq!(128, Bitmap::new(65 * 8).len());
}
#[test]
fn test_set_clear_bit() {
- let mut b = Bitmap::new(64*8);
+ let mut b = Bitmap::new(64 * 8);
assert_eq!(true, b.is_set(12));
b.clear(12);
assert_eq!(false, b.is_set(12));
@@ -80,6 +83,3 @@ mod tests {
}
}
-
-
-
diff --git a/rust/src/buffer.rs b/rust/src/buffer.rs
index 44fc007..e8c884e 100644
--- a/rust/src/buffer.rs
+++ b/rust/src/buffer.rs
@@ -23,11 +23,10 @@ use super::memory::*;
pub struct Buffer<T> {
data: *const T,
- len: i32
+ len: i32,
}
impl<T> Buffer<T> {
-
pub fn new(data: *const T, len: i32) -> Self {
Buffer { data, len }
}
@@ -41,7 +40,7 @@ impl<T> Buffer<T> {
}
pub fn slice(&self, start: usize, end: usize) -> &[T] {
- unsafe { slice::from_raw_parts(self.data.offset(start as isize), (end-start) as usize) }
+ unsafe { slice::from_raw_parts(self.data.offset(start as isize), (end - start) as usize) }
}
pub fn get(&self, i: usize) -> &T {
@@ -91,7 +90,7 @@ impl<T> Iterator for BufferIterator<T> where T: Copy {
}
macro_rules! array_from_primitive {
- ($DT:ty) => {
+ ($DT: ty) => {
impl From<Vec<$DT>> for Buffer<$DT> {
fn from(v: Vec<$DT>) -> Self {
// allocate aligned memory buffer
@@ -102,13 +101,17 @@ macro_rules! array_from_primitive {
len: len as i32,
data: unsafe {
let dst = mem::transmute::<*const u8, *mut libc::c_void>(buffer);
- libc::memcpy(dst, mem::transmute::<*const $DT, *const libc::c_void>(v.as_ptr()), len * sz);
+ libc::memcpy(
+ dst,
+ mem::transmute::<*const $DT, *const libc::c_void>(v.as_ptr()),
+ len * sz,
+ );
mem::transmute::<*mut libc::c_void, *const $DT>(dst)
- }
+ },
}
}
}
- }
+ };
}
array_from_primitive!(bool);
@@ -123,7 +126,6 @@ array_from_primitive!(i16);
array_from_primitive!(i32);
array_from_primitive!(i64);
-
#[cfg(test)]
mod tests {
use super::*;
diff --git a/rust/src/datatypes.rs b/rust/src/datatypes.rs
index cf104f3..a812f32 100644
--- a/rust/src/datatypes.rs
+++ b/rust/src/datatypes.rs
@@ -15,7 +15,7 @@
// specific language governing permissions and limitations
// under the License.
-#[derive(Debug,Clone)]
+#[derive(Debug, Clone)]
pub enum DataType {
Boolean,
Int8,
@@ -29,23 +29,22 @@ pub enum DataType {
Float32,
Float64,
Utf8,
- Struct(Vec<Field>)
+ Struct(Vec<Field>),
}
-#[derive(Debug,Clone)]
+#[derive(Debug, Clone)]
pub struct Field {
pub name: String,
pub data_type: DataType,
- pub nullable: bool
+ pub nullable: bool,
}
impl Field {
-
pub fn new(name: &str, data_type: DataType, nullable: bool) -> Self {
Field {
name: name.to_string(),
data_type: data_type,
- nullable: nullable
+ nullable: nullable,
}
}
@@ -54,32 +53,33 @@ impl Field {
}
}
-#[derive(Debug,Clone)]
+#[derive(Debug, Clone)]
pub struct Schema {
- pub columns: Vec<Field>
+ pub columns: Vec<Field>,
}
impl Schema {
-
/// create an empty schema
- pub fn empty() -> Self { Schema { columns: vec![] } }
+ pub fn empty() -> Self {
+ Schema { columns: vec![] }
+ }
- pub fn new(columns: Vec<Field>) -> Self { Schema { columns: columns } }
+ pub fn new(columns: Vec<Field>) -> Self {
+ Schema { columns: columns }
+ }
/// look up a column by name and return a reference to the column along with it's index
pub fn column(&self, name: &str) -> Option<(usize, &Field)> {
- self.columns.iter()
+ self.columns
+ .iter()
.enumerate()
- .find(|&(_,c)| c.name == name)
+ .find(|&(_, c)| c.name == name)
}
pub fn to_string(&self) -> String {
- let s : Vec<String> = self.columns.iter()
- .map(|c| c.to_string())
- .collect();
+ let s: Vec<String> = self.columns.iter().map(|c| c.to_string()).collect();
s.join(",")
}
-
}
#[cfg(test)]
@@ -91,10 +91,14 @@ mod tests {
let _person = Schema::new(vec![
Field::new("first_name", DataType::Utf8, false),
Field::new("last_name", DataType::Utf8, false),
- Field::new("address", DataType::Struct(vec![
- Field::new("street", DataType::Utf8, false),
- Field::new("zip", DataType::UInt16, false),
- ]), false),
+ Field::new(
+ "address",
+ DataType::Struct(vec![
+ Field::new("street", DataType::Utf8, false),
+ Field::new("zip", DataType::UInt16, false),
+ ]),
+ false,
+ ),
]);
}
}
diff --git a/rust/src/error.rs b/rust/src/error.rs
index 8379780..d1fb742 100644
--- a/rust/src/error.rs
+++ b/rust/src/error.rs
@@ -17,13 +17,15 @@
use std::convert::*;
-#[derive(Debug,Clone)]
+#[derive(Debug, Clone)]
pub struct Error {
- msg: String
+ msg: String,
}
impl From<&'static str> for Error where {
fn from(msg: &'static str) -> Self {
- Error { msg: String::from(msg) }
+ Error {
+ msg: String::from(msg),
+ }
}
-}
\ No newline at end of file
+}
diff --git a/rust/src/lib.rs b/rust/src/lib.rs
index b2caa61..cd1154d 100644
--- a/rust/src/lib.rs
+++ b/rust/src/lib.rs
@@ -25,4 +25,3 @@ pub mod datatypes;
pub mod list;
pub mod error;
pub mod memory;
-
diff --git a/rust/src/list.rs b/rust/src/list.rs
index a3a4e76..aee8c76 100644
--- a/rust/src/list.rs
+++ b/rust/src/list.rs
@@ -17,31 +17,30 @@
use std::str;
-use bytes::{BytesMut, BufMut};
+use bytes::{BufMut, BytesMut};
use super::buffer::Buffer;
pub struct List<T> {
pub data: Buffer<T>,
- pub offsets: Buffer<i32>
+ pub offsets: Buffer<i32>,
}
impl<T> List<T> {
-
pub fn len(&self) -> i32 {
- self.offsets.len()-1
+ self.offsets.len() - 1
}
pub fn slice(&self, index: usize) -> &[T] {
let start = *self.offsets.get(index) as usize;
- let end = *self.offsets.get(index+1) as usize;
+ let end = *self.offsets.get(index + 1) as usize;
&self.data.slice(start, end)
}
}
impl From<Vec<String>> for List<u8> {
fn from(v: Vec<String>) -> Self {
- let mut offsets : Vec<i32> = Vec::with_capacity(v.len() + 1);
+ let mut offsets: Vec<i32> = Vec::with_capacity(v.len() + 1);
let mut buf = BytesMut::with_capacity(v.len() * 32);
offsets.push(0_i32);
v.iter().for_each(|s| {
@@ -51,7 +50,10 @@ impl From<Vec<String>> for List<u8> {
let bytes = buf.freeze();
let buffer = Buffer::new(bytes.as_ptr(), bytes.len() as i32);
- List { data: buffer, offsets: Buffer::from(offsets) }
+ List {
+ data: buffer,
+ offsets: Buffer::from(offsets),
+ }
}
}
@@ -62,8 +64,6 @@ impl From<Vec<&'static str>> for List<u8> {
}
}
-
-
#[cfg(test)]
mod tests {
use super::*;
@@ -78,4 +78,4 @@ mod tests {
assert_eq!("test", str::from_utf8(list.slice(3)).unwrap());
}
-}
\ No newline at end of file
+}
--
To stop receiving notification emails like this one, please contact
uwe@apache.org.