From 550d023a29fdee1057694de3c3385bc113372d1e Mon Sep 17 00:00:00 2001 From: zheng-anbin <2205623938@qq.com> Date: Wed, 14 Dec 2022 17:43:55 +0800 Subject: [PATCH] Implement a to_string method for Encoding enum --- src/encoding.rs | 19 +++++-- src/lib.rs | 3 +- src/parse.rs | 146 ------------------------------------------------ 3 files changed, 16 insertions(+), 152 deletions(-) delete mode 100644 src/parse.rs diff --git a/src/encoding.rs b/src/encoding.rs index 099ee8d..a92443e 100644 --- a/src/encoding.rs +++ b/src/encoding.rs @@ -1,6 +1,7 @@ use core::fmt; -use crate::parse; +extern crate alloc; +use alloc::string::String; /// An Objective-C type encoding. /// @@ -35,6 +36,17 @@ pub enum Encoding<'a> { Union(&'a str, &'a [Encoding<'a>]), } +impl Encoding<'_> { + fn to_string(&self) -> String { + let mut buf = String::new(); + let mut formatter = fmt::Formatter::new(&mut buf); + // Bypass format_args!() to avoid write_str with zero-length strs + fmt::Display::fmt(self, &mut formatter) + .expect("a Display implementation returned an error unexpectedly"); + buf + } +} + impl fmt::Display for Encoding<'_> { fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { use Encoding::*; @@ -89,19 +101,18 @@ impl fmt::Display for Encoding<'_> { impl PartialEq for Encoding<'_> { fn eq(&self, other: &str) -> bool { - parse::eq_enc(other, self) + self.to_string() == other } } impl PartialEq> for str { fn eq(&self, other: &Encoding) -> bool { - parse::eq_enc(self, other) + self == other.to_string() } } #[cfg(test)] mod tests { - use std::string::ToString; use super::Encoding; #[test] diff --git a/src/lib.rs b/src/lib.rs index 12052da..513aea9 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -42,13 +42,12 @@ assert_eq!(i32::ENCODING.to_string(), "i"); */ #![no_std] - +#![feature(fmt_internals)] #[cfg(test)] extern crate std; mod encoding; mod encode; -mod parse; pub use crate::encoding::Encoding; pub use crate::encode::Encode; diff --git a/src/parse.rs b/src/parse.rs deleted file mode 100644 index 645776f..0000000 --- a/src/parse.rs +++ /dev/null @@ -1,146 +0,0 @@ -//! Parsing encodings from their string representation. - -use crate::Encoding; - -const QUALIFIERS: &'static [char] = &[ - 'r', // const - 'n', // in - 'N', // inout - 'o', // out - 'O', // bycopy - 'R', // byref - 'V', // oneway -]; - -fn rm_enc_prefix<'a>(s: &'a str, enc: &Encoding) -> Option<&'a str> { - use Encoding::*; - let code = match *enc { - Char => "c", - Short => "s", - Int => "i", - Long => "l", - LongLong => "q", - UChar => "C", - UShort => "S", - UInt => "I", - ULong => "L", - ULongLong => "Q", - Float => "f", - Double => "d", - Bool => "B", - Void => "v", - String => "*", - Object => "@", - Block => "@?", - Class => "#", - Sel => ":", - Unknown => "?", - BitField(b) => { - let s = rm_prefix(s, "b")?; - return rm_int_prefix(s, b); - } - Pointer(t) => { - let s = rm_prefix(s, "^")?; - return rm_enc_prefix(s, t); - } - Array(len, item) => { - let mut s = s; - s = rm_prefix(s, "[")?; - s = rm_int_prefix(s, len)?; - s = rm_enc_prefix(s, item)?; - return rm_prefix(s, "]"); - } - Struct(name, fields) => { - let mut s = s; - s = rm_prefix(s, "{")?; - s = rm_prefix(s, name)?; - s = rm_prefix(s, "=")?; - for field in fields { - s = rm_enc_prefix(s, field)?; - } - return rm_prefix(s, "}"); - } - Union(name, members) => { - let mut s = s; - s = rm_prefix(s, "(")?; - s = rm_prefix(s, name)?; - s = rm_prefix(s, "=")?; - for member in members { - s = rm_enc_prefix(s, member)?; - } - return rm_prefix(s, ")"); - } - }; - - rm_prefix(s, code) -} - -fn chomp_int(s: &str) -> Option<(u32, &str)> { - // Chomp until we hit a non-digit - let (num, t) = match s.find(|c: char| !c.is_digit(10)) { - Some(i) => s.split_at(i), - None => (s, ""), - }; - num.parse().map(|n| (n, t)).ok() -} - -fn rm_int_prefix(s: &str, other: u32) -> Option<&str> { - chomp_int(s) - .and_then(|(n, t)| if other == n { Some(t) } else { None }) -} - -fn rm_prefix<'a>(s: &'a str, other: &str) -> Option<&'a str> { - if s.starts_with(other) { - Some(&s[other.len()..]) - } else { - None - } -} - -pub fn eq_enc(s: &str, enc: &Encoding) -> bool { - // strip qualifiers - let s = s.trim_start_matches(QUALIFIERS); - - // if the given encoding can be successfully removed from the start - // and an empty string remains, they were equal! - rm_enc_prefix(s, enc).map_or(false, str::is_empty) -} - -#[cfg(test)] -mod tests { - use super::*; - - #[test] - fn test_nested() { - let enc = Encoding::Struct("A", &[ - Encoding::Struct("B", &[ - Encoding::Char, - Encoding::Int, - ]), - Encoding::Char, - Encoding::Int, - ]); - assert!(eq_enc("{A={B=ci}ci}", &enc)); - assert!(!eq_enc("{A={B=ci}ci", &enc)); - - } - - #[test] - fn test_bitfield() { - assert!(eq_enc("b32", &Encoding::BitField(32))); - assert!(!eq_enc("b", &Encoding::BitField(32))); - assert!(!eq_enc("b-32", &Encoding::BitField(32))); - } - - #[test] - fn test_qualifiers() { - assert!(eq_enc("Vv", &Encoding::Void)); - assert!(eq_enc("r*", &Encoding::String)); - } - - #[test] - fn test_unicode() { - let fields = &[Encoding::Char, Encoding::Int]; - assert!(eq_enc("{☃=ci}", &Encoding::Struct("☃", fields))); - } -}