1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
//! A library for working with binaries and strings. The library tries to avoid //! heap-allocations / memory-copy whenever possible by automatically choosing a reasonable //! strategy: stack for small binaries; static-lifetime-binary or reference-counting. It's //! easy to use (no lifetimes; the binary type is sized), `Send + Sync` is optional (thus //! no synchronization overhead), provides optional serde support and has a similar API for //! strings and binaries. Custom binary/string types can be implemented for fine-tuning. //! //! ```rust //! use std::iter::FromIterator; //! use std::ops::Deref; //! use abin::{AnyBin, AnyStr, Bin, BinFactory, NewBin, NewStr, Str, StrFactory}; //! //! // static binary / static string //! let static_bin: Bin = NewBin::from_static("I'm a static binary, hello!".as_bytes()); //! let static_str: Str = NewStr::from_static("I'm a static binary, hello!"); //! assert_eq!(&static_bin, static_str.as_bin()); //! assert_eq!(static_str.as_str(), "I'm a static binary, hello!"); //! // non-static (but small enough to be stored on the stack) //! let hello_bin: Bin = NewBin::from_iter([72u8, 101u8, 108u8, 108u8, 111u8].iter().copied()); //! let hello_str: Str = NewStr::copy_from_str("Hello"); //! assert_eq!(&hello_bin, hello_str.as_bin()); //! assert_eq!(hello_str.as_ref() as &str, "Hello"); //! //! // operations for binaries / strings //! //! // length (number of bytes / number of utf-8 bytes) //! assert_eq!(5, hello_bin.len()); //! assert_eq!(5, hello_str.len()); //! // is_empty //! assert_eq!(false, hello_bin.is_empty()); //! assert_eq!(false, hello_str.is_empty()); //! // as_slice / as_str / deref / as_bin //! assert_eq!(&[72u8, 101u8, 108u8, 108u8, 111u8], hello_bin.as_slice()); //! assert_eq!("Hello", hello_str.as_str()); //! assert_eq!("Hello", hello_str.deref()); //! assert_eq!(&hello_bin, hello_str.as_bin()); //! // slice //! assert_eq!( //! NewBin::from_static(&[72u8, 101u8]), //! hello_bin.slice(0..2).unwrap() //! ); //! assert_eq!(NewStr::from_static("He"), hello_str.slice(0..2).unwrap()); //! // clone //! assert_eq!(hello_bin.clone(), hello_bin); //! assert_eq!(hello_str.clone(), hello_str); //! // compare //! assert!(NewBin::from_static(&[255u8]) > hello_bin); //! assert!(NewStr::from_static("Z") > hello_str); //! // convert string into binary and binary into string //! let hello_bin_from_str: Bin = hello_str.clone().into_bin(); //! assert_eq!(hello_bin_from_str, hello_bin); //! let hello_str_from_bin: Str = AnyStr::from_utf8(hello_bin.clone()).expect("invalid utf8!"); //! assert_eq!(hello_str_from_bin, hello_str); //! // convert into Vec<u8> / String //! assert_eq!( //! Vec::from_iter([72u8, 101u8, 108u8, 108u8, 111u8].iter().copied()), //! hello_bin.into_vec() //! ); //! assert_eq!("Hello".to_owned(), hello_str.into_string()); //! ``` pub mod spi; #[cfg(any(test, feature = "serde"))] pub use serde_support::*; pub use {binary::*, boo::*, common::*, implementation::*, string::*}; mod binary; mod boo; mod common; mod implementation; mod string; #[cfg(any(test, feature = "serde"))] mod serde_support;