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
//! For implementations in other languages, and more detailed //! information on the types check out http://bitsparrow.io/. //! //! # BitSparrow in Rust //! //! ## Encoding //! //! ``` //! use bitsparrow::Encoder; //! //! let buffer = Encoder::new() //! .uint8(100) //! .string("Foo") //! .end(); //! //! assert_eq!(buffer, &[0x64,0x03,0x46,0x6f,0x6f]) //! ``` //! //! Each method on the `Encoder` will return a mutable borrow of //! the encoder. If you need to break the monad chain, store the //! owned encoder as a variable before writing to it, e.g.: //! //! ``` //! use bitsparrow::Encoder; //! //! let mut encoder = Encoder::new(); //! encoder.uint8(100); //! //! /* //! * Many codes here //! */ //! //! let buffer = encoder.string("Foo").end(); //! //! assert_eq!(buffer, &[0x64_u8,0x03,0x46,0x6f,0x6f]); //! ``` //! //! ## Decoding //! //! ``` //! use bitsparrow::Decoder; //! //! let buffer = &[0x64,0x03,0x46,0x6f,0x6f]; //! let mut decoder = Decoder::new(buffer); //! //! assert_eq!(100u8, decoder.uint8().unwrap()); //! assert_eq!("Foo", decoder.string().unwrap()); //! assert_eq!(true, decoder.end()); //! ``` //! //! Decoder allows you to retrieve the values in order they were //! encoded. Calling the `end` method is optional - it will return //! `true` if you have read the entire buffer, ensuring the entire //! buffer has been read. mod encode; mod decode; mod utils; pub use utils::Error; pub use encode::{Encoder, BitEncode}; pub use decode::{Decoder, BitDecode};