Removed azure stuff

Cargo.toml

@@ -16,7 +16,6 @@ rust-version = "1.62"
 [dependencies]
 oneshot = "0.1.5"
 base64 = "0.21.0"
-byteorder = "1.4.3"
 crc32fast = "1.3.2"
 once_cell = "1.10.0"
 regex = { version = "1.5.5", default-features = false, features = ["std", "unicode"] }

common/Cargo.toml

@@ -13,7 +13,6 @@ repository = "https://github.com/quickwit-oss/tantivy"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
-byteorder = "1.4.3"
 ownedbytes = { version= "0.5", path="../ownedbytes" }
 async-trait = "0.1"
 time = { version = "0.3.10", features = ["serde-well-known"] }

common/src/lib.rs

@@ -2,8 +2,6 @@
 
 use std::ops::Deref;
 
-pub use byteorder::LittleEndian as Endianness;
-
 mod bitset;
 mod datetime;
 pub mod file_slice;

common/src/serialize.rs

@@ -1,9 +1,7 @@
 use std::io::{Read, Write};
 use std::{fmt, io};
 
-use byteorder::{ReadBytesExt, WriteBytesExt};
-
-use crate::{Endianness, VInt};
+use crate::VInt;
 
 #[derive(Default)]
 struct Counter(u64);
@@ -107,11 +105,13 @@ impl<Left: BinarySerializable + FixedSize, Right: BinarySerializable + FixedSize
 
 impl BinarySerializable for u32 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u32::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
 
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<u32> {
-        reader.read_u32::<Endianness>()
+        let mut buf = [0u8; 4];
+        reader.read_exact(&mut buf)?;
+        Ok(u32::from_le_bytes(buf))
     }
 }
 
@@ -121,11 +121,13 @@ impl FixedSize for u32 {
 
 impl BinarySerializable for u16 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u16::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
 
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<u16> {
-        reader.read_u16::<Endianness>()
+        let mut buf = [0u8; 2];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -135,10 +137,12 @@ impl FixedSize for u16 {
 
 impl BinarySerializable for u64 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u64::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        reader.read_u64::<Endianness>()
+        let mut buf = [0u8; 8];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -148,10 +152,12 @@ impl FixedSize for u64 {
 
 impl BinarySerializable for u128 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u128::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        reader.read_u128::<Endianness>()
+        let mut buf = [0u8; 16];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -161,10 +167,12 @@ impl FixedSize for u128 {
 
 impl BinarySerializable for f32 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_f32::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        reader.read_f32::<Endianness>()
+        let mut buf = [0u8; 4];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -174,10 +182,12 @@ impl FixedSize for f32 {
 
 impl BinarySerializable for i64 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_i64::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        reader.read_i64::<Endianness>()
+        let mut buf = [0u8; Self::SIZE_IN_BYTES];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -187,10 +197,12 @@ impl FixedSize for i64 {
 
 impl BinarySerializable for f64 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_f64::<Endianness>(*self)
+        writer.write_all(&self.to_le_bytes())
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
-        reader.read_f64::<Endianness>()
+        let mut buf = [0u8; Self::SIZE_IN_BYTES];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -200,10 +212,12 @@ impl FixedSize for f64 {
 
 impl BinarySerializable for u8 {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u8(*self)
+        writer.write_all(&self.to_le_bytes())
     }
-    fn deserialize<R: Read>(reader: &mut R) -> io::Result<u8> {
-        reader.read_u8()
+    fn deserialize<R: Read>(reader: &mut R) -> io::Result<Self> {
+        let mut buf = [0u8; Self::SIZE_IN_BYTES];
+        reader.read_exact(&mut buf)?;
+        Ok(Self::from_le_bytes(buf))
     }
 }
 
@@ -213,10 +227,10 @@ impl FixedSize for u8 {
 
 impl BinarySerializable for bool {
     fn serialize<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
-        writer.write_u8(u8::from(*self))
+        (*self as u8).serialize(writer)
     }
     fn deserialize<R: Read>(reader: &mut R) -> io::Result<bool> {
-        let val = reader.read_u8()?;
+        let val = u8::deserialize(reader)?;
         match val {
             0 => Ok(false),
             1 => Ok(true),

common/src/vint.rs

@@ -1,8 +1,6 @@
 use std::io;
 use std::io::{Read, Write};
 
-use byteorder::{ByteOrder, LittleEndian};
-
 use super::BinarySerializable;
 
 /// Variable int serializes a u128 number
@@ -127,7 +125,7 @@ pub fn serialize_vint_u32(val: u32, buf: &mut [u8; 8]) -> &[u8] {
             5,
         ),
     };
-    LittleEndian::write_u64(&mut buf[..], res);
+    buf.copy_from_slice(&res.to_le_bytes());
     &buf[0..num_bytes]
 }
 

src/schema/term.rs

@@ -364,8 +364,7 @@ where B: AsRef<[u8]>
     /// (this does not include the field.)
     ///
     /// If the term is a string, its value is utf-8 encoded.
-    /// If the term is a u64, its value is encoded according
-    /// to `byteorder::BigEndian`.
+    /// If the term is a u64, its value is encoded in big endian.
     pub fn value_bytes(&self) -> &[u8] {
         &self.0.as_ref()[TERM_METADATA_LENGTH..]
     }

src/termdict/fst_termdict/term_info_store.rs

@@ -1,7 +1,6 @@
 use std::cmp;
 use std::io::{self, Read, Write};
 
-use byteorder::{ByteOrder, LittleEndian};
 use common::{BinarySerializable, FixedSize};
 use tantivy_bitpacker::{compute_num_bits, BitPacker};
 
@@ -104,7 +103,7 @@ fn extract_bits(data: &[u8], addr_bits: usize, num_bits: u8) -> u64 {
     let addr_byte = addr_bits / 8;
     let bit_shift = (addr_bits % 8) as u64;
     let val_unshifted_unmasked: u64 = if data.len() >= addr_byte + 8 {
-        LittleEndian::read_u64(&data[addr_byte..][..8])
+        u64::from_le_bytes(data[addr_byte..][..8].try_into().unwrap())
     } else {
         // the buffer is not large enough.
         // Let's copy the few remaining bytes to a 8 byte buffer
@@ -113,7 +112,7 @@ fn extract_bits(data: &[u8], addr_bits: usize, num_bits: u8) -> u64 {
         let data_to_copy = &data[addr_byte..];
         let nbytes = data_to_copy.len();
         buf[..nbytes].copy_from_slice(data_to_copy);
-        LittleEndian::read_u64(&buf)
+        u64::from_le_bytes(buf)
     };
     let val_shifted_unmasked = val_unshifted_unmasked >> bit_shift;
     let mask = (1u64 << u64::from(num_bits)) - 1;

stacker/Cargo.toml

@@ -6,5 +6,4 @@ license = "MIT"
 
 [dependencies]
 murmurhash32 = "0.3"
-byteorder = "1"
 common = { version = "0.5", path = "../common/", package = "tantivy-common" }

stacker/src/arena_hashmap.rs

@@ -1,6 +1,5 @@
 use std::{iter, mem, slice};
 
-use byteorder::{ByteOrder, NativeEndian};
 use murmurhash32::murmurhash2;
 
 use super::{Addr, MemoryArena};
@@ -155,7 +154,7 @@ impl ArenaHashMap {
     #[inline]
     fn get_key_value(&self, addr: Addr) -> (&[u8], Addr) {
         let data = self.memory_arena.slice_from(addr);
-        let key_bytes_len = NativeEndian::read_u16(data) as usize;
+        let key_bytes_len = u16::from_ne_bytes(data[..2].try_into().unwrap()) as usize;
         let key_bytes: &[u8] = &data[2..][..key_bytes_len];
         (key_bytes, addr.offset(2u32 + key_bytes_len as u32))
     }
@@ -273,7 +272,7 @@ impl ArenaHashMap {
                 let key_addr = self.memory_arena.allocate_space(num_bytes);
                 {
                     let data = self.memory_arena.slice_mut(key_addr, num_bytes);
-                    NativeEndian::write_u16(data, key.len() as u16);
+                    data[..2].copy_from_slice(&u16::to_ne_bytes(key.len() as u16));
                     let stop = 2 + key.len();
                     data[2..stop].copy_from_slice(key);
                     store(&mut data[stop..], val);