notedeck

lib.rs (7148B)

---

 #[derive(Debug, Clone)]
 pub struct UnexpectedToken<'fnd, 'exp> {
     pub expected: &'exp str,
     pub found: &'fnd str,
 }
 
 #[derive(Debug, Clone)]
 pub struct UnexpectedTokenOwned {
     pub expected: String,
     pub found: String,
 }
 
 #[derive(Debug, Clone)]
 pub enum ParseError<'a> {
     /// Not done parsing yet
     Incomplete,
 
     /// All parsing options failed
     AltAllFailed,
 
     /// There was some issue decoding the data
     DecodeFailed,
 
     HexDecodeFailed,
 
     /// We encountered an unexpected token
     UnexpectedToken(UnexpectedToken<'a, 'static>),
 
     /// No more tokens
     EOF,
 }
 
 #[derive(Debug, Clone)]
 pub enum ParseErrorOwned {
     Incomplete,
     AltAllFailed,
     DecodeFailed,
     HexDecodeFailed,
     UnexpectedToken(UnexpectedTokenOwned),
     EOF,
 }
 
 impl From<ParseError<'_>> for ParseErrorOwned {
     fn from(value: ParseError) -> Self {
         match value {
             ParseError::Incomplete => Self::Incomplete,
             ParseError::AltAllFailed => Self::AltAllFailed,
             ParseError::DecodeFailed => Self::DecodeFailed,
             ParseError::HexDecodeFailed => Self::HexDecodeFailed,
             ParseError::UnexpectedToken(unexpected_token) => {
                 Self::UnexpectedToken(UnexpectedTokenOwned {
                     expected: unexpected_token.expected.to_owned(),
                     found: unexpected_token.found.to_owned(),
                 })
             }
             ParseError::EOF => Self::EOF,
         }
     }
 }
 
 pub struct TokenWriter {
     delim: &'static str,
     tokens_written: usize,
     buf: Vec<u8>,
 }
 
 impl Default for TokenWriter {
     fn default() -> Self {
         Self::new(":")
     }
 }
 
 impl TokenWriter {
     pub fn new(delim: &'static str) -> Self {
         let buf = vec![];
         let tokens_written = 0;
         Self {
             buf,
             tokens_written,
             delim,
         }
     }
 
     pub fn write_token(&mut self, token: &str) {
         if self.tokens_written > 0 {
             self.buf.extend_from_slice(self.delim.as_bytes())
         }
         self.buf.extend_from_slice(token.as_bytes());
         self.tokens_written += 1;
     }
 
     pub fn str(&self) -> &str {
         // SAFETY: only &strs are ever serialized, so its guaranteed to be
         // correct here
         unsafe { std::str::from_utf8_unchecked(self.buffer()) }
     }
 
     pub fn buffer(&self) -> &[u8] {
         &self.buf
     }
 }
 
 #[derive(Clone)]
 pub struct TokenParser<'a> {
     tokens: &'a [&'a str],
     index: usize,
 }
 
 impl<'a> TokenParser<'a> {
     /// alt tries each parser in `routes` until one succeeds.
     /// If all fail, returns `ParseError::AltAllFailed`.
     #[allow(clippy::type_complexity)]
     pub fn alt<R>(
         parser: &mut TokenParser<'a>,
         routes: &[fn(&mut TokenParser<'a>) -> Result<R, ParseError<'a>>],
     ) -> Result<R, ParseError<'a>> {
         let start = parser.index;
         for route in routes {
             match route(parser) {
                 Ok(r) => return Ok(r), // if success, stop trying more routes
                 Err(_) => {
                     // revert index & try next route
                     parser.index = start;
                 }
             }
         }
         // if we tried them all and none succeeded
         Err(ParseError::AltAllFailed)
     }
 
     pub fn new(tokens: &'a [&'a str]) -> Self {
         let index = 0;
         Self { tokens, index }
     }
 
     pub fn peek_parse_token(&mut self, expected: &'static str) -> Result<&'a str, ParseError<'a>> {
         let found = self.peek_token()?;
         if found == expected {
             Ok(found)
         } else {
             Err(ParseError::UnexpectedToken(UnexpectedToken {
                 expected,
                 found,
             }))
         }
     }
 
     /// Parse a list of alternative tokens, returning success if any match.
     pub fn parse_any_token(
         &mut self,
         expected: &[&'static str],
     ) -> Result<&'a str, ParseError<'a>> {
         for token in expected {
             let result = self.try_parse(|p| p.parse_token(token));
             if result.is_ok() {
                 return result;
             }
         }
 
         Err(ParseError::AltAllFailed)
     }
 
     pub fn parse_token(&mut self, expected: &'static str) -> Result<&'a str, ParseError<'a>> {
         let found = self.pull_token()?;
         if found == expected {
             Ok(found)
         } else {
             Err(ParseError::UnexpectedToken(UnexpectedToken {
                 expected,
                 found,
             }))
         }
     }
 
     /// Ensure that we have parsed all tokens. If not the parser backtracks
     /// and the parse does not succeed, returning [`ParseError::Incomplete`].
     pub fn parse_all<R>(
         &mut self,
         parse_fn: impl FnOnce(&mut Self) -> Result<R, ParseError<'a>>,
     ) -> Result<R, ParseError<'a>> {
         let start = self.index;
         let result = parse_fn(self);
 
         // If the parser closure fails, revert the index
         if result.is_err() {
             self.index = start;
             result
         } else if !self.is_eof() {
             Err(ParseError::Incomplete)
         } else {
             result
         }
     }
 
     /// Attempt to parse something, backtrack if we fail.
     pub fn try_parse<R>(
         &mut self,
         parse_fn: impl FnOnce(&mut Self) -> Result<R, ParseError<'a>>,
     ) -> Result<R, ParseError<'a>> {
         let start = self.index;
         let result = parse_fn(self);
 
         // If the parser closure fails, revert the index
         if result.is_err() {
             self.index = start;
             result
         } else {
             result
         }
     }
 
     pub fn pull_token(&mut self) -> Result<&'a str, ParseError<'a>> {
         let token = self
             .tokens
             .get(self.index)
             .copied()
             .ok_or(ParseError::EOF)?;
         self.index += 1;
         Ok(token)
     }
 
     pub fn unpop_token(&mut self) {
         if (self.index as isize) - 1 < 0 {
             return;
         }
 
         self.index -= 1;
     }
 
     pub fn peek_token(&self) -> Result<&'a str, ParseError<'a>> {
         self.tokens()
             .first()
             .ok_or(ParseError::DecodeFailed)
             .copied()
     }
 
     #[inline]
     pub fn tokens(&self) -> &'a [&'a str] {
         let min_index = self.index.min(self.tokens.len());
         &self.tokens[min_index..]
     }
 
     #[inline]
     pub fn is_eof(&self) -> bool {
         self.tokens().is_empty()
     }
 }
 
 pub trait TokenSerializable: Sized {
     /// Return a list of serialization plans for a type. We do this for
     /// type safety and assume constructing these types are lightweight
     fn parse_from_tokens<'a>(parser: &mut TokenParser<'a>) -> Result<Self, ParseError<'a>>;
     fn serialize_tokens(&self, writer: &mut TokenWriter);
 }
 
 /// Parse a 32 byte hex string
 pub fn parse_hex_id<'a>(parser: &mut TokenParser<'a>) -> Result<[u8; 32], ParseError<'a>> {
     use hex;
 
     let hexid = parser.pull_token()?;
     hex::decode(hexid)
         .map_err(|_| ParseError::HexDecodeFailed)?
         .as_slice()
         .try_into()
         .map_err(|_| ParseError::HexDecodeFailed)
 }