rename classes to methods

amqp_transport/src/methods/parse_helper.rs

@@ -0,0 +1,254 @@
+use crate::error::{ConException, ProtocolError, TransError};
+use crate::methods::generated::parse::IResult;
+use crate::methods::generated::{
+    Bit, Long, Longlong, Longstr, Octet, Short, Shortstr, Table, Timestamp,
+};
+use nom::branch::alt;
+use nom::bytes::complete::{tag, take};
+use nom::error::ErrorKind;
+use nom::multi::{count, many0};
+use nom::number::complete::{f32, f64, i16, i32, i64, i8, u16, u32, u64, u8};
+use nom::number::Endianness::Big;
+use nom::Err;
+use std::collections::HashMap;
+
+// todo: remove the debug machinery or change it in a way that actually does what it should lmao
+// I'm probably misusing nom hard
+
+impl<T> nom::error::ParseError<T> for TransError {
+    fn from_error_kind(_input: T, _kind: ErrorKind) -> Self {
+        ConException::SyntaxError(vec![]).into_trans()
+    }
+
+    fn append(_input: T, _kind: ErrorKind, other: Self) -> Self {
+        other
+    }
+}
+
+pub fn fail_err<S: Into<String>>(msg: S) -> impl FnOnce(Err<TransError>) -> Err<TransError> {
+    move |err| {
+        let error_level = if matches!(err, nom::Err::Failure(_)) {
+            Err::Failure
+        } else {
+            Err::Error
+        };
+
+        let msg = msg.into();
+        let stack = match err {
+            Err::Error(e) | Err::Failure(e) => match e {
+                TransError::Invalid(ProtocolError::ConException(ConException::SyntaxError(
+                    mut stack,
+                ))) => {
+                    stack.push(msg);
+                    stack
+                }
+                _ => vec![msg],
+            },
+            _ => vec![msg],
+        };
+        error_level(ConException::SyntaxError(stack).into_trans())
+    }
+}
+pub fn err_other<E, S: Into<String>>(msg: S) -> impl FnOnce(E) -> Err<TransError> {
+    move |_| Err::Error(ConException::SyntaxError(vec![msg.into()]).into_trans())
+}
+
+pub fn failure<E>(err: Err<E>) -> Err<E> {
+    match err {
+        Err::Incomplete(needed) => Err::Incomplete(needed),
+        Err::Error(e) => Err::Failure(e),
+        Err::Failure(e) => Err::Failure(e),
+    }
+}
+
+#[macro_export]
+macro_rules! fail {
+    ($cause:expr) => {
+        return Err(nom::Err::Failure(
+            crate::error::ProtocolError::ConException(crate::error::ConException::SyntaxError(
+                vec![String::from($cause)],
+            ))
+            .into(),
+        ))
+    };
+}
+
+use crate::methods::{FieldValue, TableFieldName};
+pub use fail;
+
+pub fn octet(input: &[u8]) -> IResult<'_, Octet> {
+    u8(input)
+}
+
+pub fn short(input: &[u8]) -> IResult<'_, Short> {
+    u16(Big)(input)
+}
+
+pub fn long(input: &[u8]) -> IResult<'_, Long> {
+    u32(Big)(input)
+}
+
+pub fn longlong(input: &[u8]) -> IResult<'_, Longlong> {
+    u64(Big)(input)
+}
+
+pub fn bit(input: &[u8], amount: usize) -> IResult<'_, Vec<Bit>> {
+    let octets = (amount + 7) / 8;
+    let (input, bytes) = take(octets)(input)?;
+
+    let mut vec = Vec::new();
+    let mut byte_index = 0;
+    let mut total_index = 0;
+
+    for &byte in bytes {
+        while byte_index < 8 && total_index < amount {
+            let next_bit = 1 & (byte >> byte_index);
+            let bit_bool = match next_bit {
+                0 => false,
+                1 => true,
+                _ => unreachable!(),
+            };
+            vec.push(bit_bool);
+            byte_index += 1;
+            total_index += 1;
+        }
+        byte_index = 0;
+    }
+
+    Ok((input, vec))
+}
+
+pub fn shortstr(input: &[u8]) -> IResult<'_, Shortstr> {
+    let (input, len) = u8(input)?;
+    let (input, str_data) = take(usize::from(len))(input)?;
+    let data = String::from_utf8(str_data.into()).map_err(err_other("shortstr"))?;
+    Ok((input, data))
+}
+
+pub fn longstr(input: &[u8]) -> IResult<'_, Longstr> {
+    let (input, len) = u32(Big)(input)?;
+    let (input, str_data) = take(usize::try_from(len).unwrap())(input)?;
+    let data = str_data.into();
+    Ok((input, data))
+}
+
+pub fn timestamp(input: &[u8]) -> IResult<'_, Timestamp> {
+    u64(Big)(input)
+}
+
+pub fn table(input: &[u8]) -> IResult<'_, Table> {
+    let (input, size) = u32(Big)(input)?;
+    let (table_input, rest_input) = input.split_at(size.try_into().unwrap());
+
+    let (input, values) = many0(table_value_pair)(table_input)?;
+
+    if !input.is_empty() {
+        fail!(format!(
+            "table longer than expected, expected = {size}, remaining = {}",
+            input.len()
+        ));
+    }
+
+    let table = HashMap::from_iter(values.into_iter());
+    Ok((rest_input, table))
+}
+
+fn table_value_pair(input: &[u8]) -> IResult<'_, (TableFieldName, FieldValue)> {
+    let (input, field_name) = shortstr(input)?;
+    let (input, field_value) =
+        field_value(input).map_err(fail_err(format!("field {field_name}")))?;
+    Ok((input, (field_name, field_value)))
+}
+
+fn field_value(input: &[u8]) -> IResult<'_, FieldValue> {
+    type R<'a> = IResult<'a, FieldValue>;
+
+    fn boolean(input: &[u8]) -> R<'_> {
+        let (input, _) = tag(b"t")(input)?;
+        let (input, bool_byte) = u8(input)?;
+        match bool_byte {
+            0 => Ok((input, FieldValue::Boolean(false))),
+            1 => Ok((input, FieldValue::Boolean(true))),
+            value => fail!(format!("invalid bool value {value}")),
+        }
+    }
+
+    macro_rules! number {
+        ($tag:literal, $name:ident, $comb:expr, $value:ident, $r:path) => {
+            fn $name(input: &[u8]) -> $r {
+                let (input, _) = tag($tag)(input)?;
+                $comb(input).map(|(input, int)| (input, FieldValue::$value(int)))
+            }
+        };
+    }
+
+    number!(b"b", short_short_int, i8, ShortShortInt, R<'_>);
+    number!(b"B", short_short_uint, u8, ShortShortUInt, R<'_>);
+    number!(b"U", short_int, i16(Big), ShortInt, R<'_>);
+    number!(b"u", short_uint, u16(Big), ShortUInt, R<'_>);
+    number!(b"I", long_int, i32(Big), LongInt, R<'_>);
+    number!(b"i", long_uint, u32(Big), LongUInt, R<'_>);
+    number!(b"L", long_long_int, i64(Big), LongLongInt, R<'_>);
+    number!(b"l", long_long_uint, u64(Big), LongLongUInt, R<'_>);
+    number!(b"f", float, f32(Big), Float, R<'_>);
+    number!(b"d", double, f64(Big), Double, R<'_>);
+
+    fn decimal(input: &[u8]) -> R<'_> {
+        let (input, _) = tag("D")(input)?;
+        let (input, scale) = u8(input)?;
+        let (input, value) = u32(Big)(input)?;
+        Ok((input, FieldValue::DecimalValue(scale, value)))
+    }
+
+    fn short_str(input: &[u8]) -> R<'_> {
+        let (input, _) = tag("s")(input)?;
+        let (input, str) = shortstr(input)?;
+        Ok((input, FieldValue::ShortString(str)))
+    }
+
+    fn long_str(input: &[u8]) -> R<'_> {
+        let (input, _) = tag("S")(input)?;
+        let (input, str) = longstr(input)?;
+        Ok((input, FieldValue::LongString(str)))
+    }
+
+    fn field_array(input: &[u8]) -> R<'_> {
+        let (input, _) = tag("A")(input)?;
+        // todo is it i32?
+        let (input, len) = u32(Big)(input)?;
+        count(field_value, usize::try_from(len).unwrap())(input)
+            .map(|(input, value)| (input, FieldValue::FieldArray(value)))
+    }
+
+    number!(b"T", timestamp, u64(Big), Timestamp, R<'_>);
+
+    fn field_table(input: &[u8]) -> R<'_> {
+        let (input, _) = tag("F")(input)?;
+        table(input).map(|(input, value)| (input, FieldValue::FieldTable(value)))
+    }
+
+    fn void(input: &[u8]) -> R<'_> {
+        tag("V")(input).map(|(input, _)| (input, FieldValue::Void))
+    }
+
+    alt((
+        boolean,
+        short_short_int,
+        short_short_uint,
+        short_int,
+        short_uint,
+        long_int,
+        long_uint,
+        long_long_int,
+        long_long_uint,
+        float,
+        double,
+        decimal,
+        short_str,
+        long_str,
+        field_array,
+        timestamp,
+        field_table,
+        void,
+    ))(input)
+}