Merge pull request #46 from hushmesh/no_std

add no_std support

Author: sile

.github/workflows/ci.yml

@@ -15,6 +15,18 @@ jobs:
       - run: rustup update ${{ matrix.toolchain }}
       - run: cargo check --all-features --all
 
+  nostd:
+    name: Check no_std
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        toolchain: [stable, beta, nightly]
+    steps:
+      - name: Checkout sources
+        uses: actions/checkout@v4
+      - run: rustup update ${{ matrix.toolchain }}
+      - run: cargo check --no-default-features --features=serde --all
+
   test:
     name: Test Suite
     runs-on: ubuntu-latest

Cargo.toml

@@ -6,21 +6,26 @@ description = "Memory-efficient data structures based on patricia tree"
 homepage = "https://github.com/sile/patricia_tree"
 repository = "https://github.com/sile/patricia_tree"
 readme = "README.md"
-keywords = ["patricia", "radix", "trie"]
+keywords = ["patricia", "radix", "trie", "no_std"]
 categories = ["data-structures"]
 license = "MIT"
 edition = "2021"
 rust-version = "1.82.0"
 
 [dependencies]
-bitflags = "2"
+bitflags = { version = "2", default-features = false }
 serde = { version = "1", optional = true }
 
 [dev-dependencies]
 clap = { version = "4", features = ["derive"] }
 rand = "0.8"
 serde_json = { version = "1" }
 
+[features]
+default = ["std"]
+std = []
+serde = ["dep:serde"]
+
 [package.metadata.docs.rs]
 all-features = true
 

src/lib.rs

@@ -24,13 +24,20 @@
 //! ```
 #![warn(missing_docs)]
 #![allow(clippy::cast_ptr_alignment)]
+#![cfg_attr(not(feature = "std"), no_std)]
 
 #[macro_use]
 extern crate bitflags;
 #[cfg(test)]
 extern crate rand;
 
-use std::cmp::Ordering;
+#[macro_use]
+extern crate alloc;
+
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::cmp::Ordering;
 
 pub use map::{GenericPatriciaMap, PatriciaMap, StringPatriciaMap};
 pub use set::{GenericPatriciaSet, PatriciaSet, StringPatriciaSet};
@@ -129,11 +136,11 @@ impl BorrowedBytes for str {
     }
 
     fn is_valid_bytes(bytes: &[u8]) -> bool {
-        std::str::from_utf8(bytes).is_ok()
+        core::str::from_utf8(bytes).is_ok()
     }
 
     fn from_bytes(bytes: &[u8]) -> &Self {
-        std::str::from_utf8(bytes).expect("unreachable")
+        core::str::from_utf8(bytes).expect("unreachable")
     }
 
     fn strip_common_prefix(&self, bytes: &[u8]) -> &Self {

src/map.rs

@@ -4,9 +4,12 @@ use crate::node;
 use crate::node::Node;
 use crate::tree::{self, PatriciaTree};
 use crate::{BorrowedBytes, Bytes};
-use std::fmt;
-use std::iter::FromIterator;
-use std::marker::PhantomData;
+use alloc::borrow::ToOwned;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+use core::iter::FromIterator;
+use core::marker::PhantomData;
 
 /// Patricia tree based map with [`Vec<u8>`] as key.
 pub type PatriciaMap<V> = GenericPatriciaMap<Vec<u8>, V>;

src/node.rs

@@ -1,10 +1,9 @@
 //! A node which represents a subtree of a patricia tree.
 use crate::BorrowedBytes;
-use std::alloc::{alloc, dealloc, handle_alloc_error, Layout};
-use std::marker::PhantomData;
-use std::mem;
-use std::ptr;
-use std::slice;
+use alloc::alloc::{alloc, dealloc, handle_alloc_error, Layout};
+use alloc::vec::Vec;
+use core::marker::PhantomData;
+use core::{mem, ptr, slice};
 
 macro_rules! assert_some {
     ($expr:expr) => {

src/serialization.rs

@@ -1,9 +1,11 @@
 use crate::node::{Flags, Node};
 use crate::{BorrowedBytes, GenericPatriciaMap, GenericPatriciaSet};
+use alloc::borrow::{Cow, ToOwned};
+use alloc::vec::Vec;
+use core::borrow::Borrow;
+use core::marker::PhantomData;
 use serde::de::{Error, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::borrow::{Borrow, Cow};
-use std::marker::PhantomData;
 
 impl<T> Serialize for GenericPatriciaSet<T> {
     /// In order to serialize a [PatriciaSet], make sure you installed the crate
@@ -217,7 +219,7 @@ struct BytesVisitor;
 impl<'de> Visitor<'de> for BytesVisitor {
     type Value = Bytes<'de>;
 
-    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+    fn expecting(&self, formatter: &mut core::fmt::Formatter) -> core::fmt::Result {
         write!(formatter, "a byte string")
     }
 

src/set.rs

@@ -3,8 +3,10 @@ use crate::map::{self, GenericPatriciaMap};
 #[cfg(any(feature = "serde", test))]
 use crate::node::Node;
 use crate::Bytes;
-use std::fmt;
-use std::iter::FromIterator;
+use alloc::string::String;
+use alloc::vec::Vec;
+use core::fmt;
+use core::iter::FromIterator;
 
 /// Patricia tree based set with [`Vec<u8>`] as key.
 pub type PatriciaSet = GenericPatriciaSet<Vec<u8>>;

src/tree.rs

@@ -1,3 +1,5 @@
+use alloc::vec::Vec;
+
 use crate::{
     node::{self, Node, NodeMut},
     BorrowedBytes,