pub struct UDV {
pub header: char,
pub message: char,
pub record: char,
pub unit: char,
pub escape: char,
pub end_message: char,
pub end_stream: char,
}
Fields§
§header: char
§message: char
§record: char
§unit: char
§escape: char
§end_message: char
§end_stream: char
Implementations§
Source§impl UDV
impl UDV
Sourcepub fn new_c0_text() -> Self
pub fn new_c0_text() -> Self
A text parser using c0 control sequences.
pub fn is_delimiter(self, c: char) -> bool
pub fn parse_garbage(self, input: &str) -> IResult<&str, &str>
Sourcepub fn parse_escape(self, input: &str) -> IResult<&str, char>
pub fn parse_escape(self, input: &str) -> IResult<&str, char>
use nom::{Err, Needed};
let parser = udv::text::UDV::default();
assert_eq!(parser.parse_escape(r#"\"#), Err(Err::Incomplete(Needed::new(1))));
assert_eq!(parser.parse_escape(r#"\\"#), Ok(("", '\\')));
assert_eq!(parser.parse_escape(r#"\n"#), Ok(("", 'n')));
assert_eq!(parser.parse_escape("\\\nxyz"), Ok(("xyz", '\n')));
Sourcepub fn parse_unit(self, input: &str) -> IResult<&str, Unit<'_>>
pub fn parse_unit(self, input: &str) -> IResult<&str, Unit<'_>>
use nom::{Err, Needed};
use std::borrow::Cow;
use udv::text::{Unit, UDV};
let parser = UDV::default();
assert_eq!(parser.parse_unit(r#",alpha,beta"#), Ok((",beta", Unit(Cow::Borrowed("alpha")))));
assert_eq!(parser.parse_unit(",al\\\\pha,beta"), Ok((",beta", Unit(Cow::Owned("al\\pha".to_string())))));
assert_eq!(parser.parse_unit(",al\npha,beta"), Ok(("\npha,beta", Unit(Cow::Borrowed("al")))));
assert_eq!(parser.parse_unit(r#",alpha"#), Err(Err::Incomplete(Needed::new(1))));
Sourcepub fn parse_record(self, input: &str) -> IResult<&str, Record<'_>>
pub fn parse_record(self, input: &str) -> IResult<&str, Record<'_>>
use nom::{Err, Needed};
use nom::error::{Error, ErrorKind};
use std::borrow::Cow;
use udv::text::{Unit, UDV, Record};
let parser = UDV::default();
assert_eq!(parser.parse_record("\n,alpha,beta"), Err(Err::Incomplete(Needed::new(1))));
assert_eq!(parser.parse_record("\n,alpha,beta\n"), Ok(("\n", Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]))));
assert_eq!(parser.parse_record("\n,alpha,be\\\\ta\nafter"), Ok(("\nafter", Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Owned("be\\ta".to_string()))]))));
assert!(matches!(parser.parse_record("#,alpha,be\\\\ta\nafter"), Err(Err::Error(Error {code: ErrorKind::Char, ..}))));
Sourcepub fn parse_header(self, input: &str) -> IResult<&str, Header<'_>>
pub fn parse_header(self, input: &str) -> IResult<&str, Header<'_>>
use nom::{Err, Needed};
use std::borrow::Cow;
use udv::text::{Unit, UDV, Header};
let parser = UDV::default();
assert_eq!(parser.parse_header("#,alpha,beta"), Err(Err::Incomplete(Needed::new(1))));
assert_eq!(parser.parse_header("#,alpha,beta\n"), Ok(("\n", Header(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]))));
assert_eq!(parser.parse_header("#,alpha,be\\\\ta\nafter"), Ok(("\nafter", Header(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Owned("be\\ta".to_string()))]))));
Sourcepub fn parse_message(self, input: &str) -> IResult<&str, Message<'_>>
pub fn parse_message(self, input: &str) -> IResult<&str, Message<'_>>
use nom::{Err, Needed};
use std::borrow::Cow;
use udv::text::{Unit, UDV, Header, Record, Message};
let parser = UDV::default();
assert_eq!(
parser.parse_message(">\n,alpha,beta\n,gamma,delta\n<"),
Ok(("", Message{
header: None,
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
}))
);
assert_eq!(
parser.parse_message("#,one,two>\n,alpha,beta\n,gamma,delta\n<"),
Ok(("", Message{
header: Some(Header(vec![Unit(Cow::Borrowed("one")), Unit(Cow::Borrowed("two"))])),
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
}))
);
assert_eq!(
parser.parse_message("#,one,two>\n,alpha,beta\n,gamma,delta\n"),
Err(Err::Incomplete(Needed::new(1)))
);
Sourcepub fn parse_stream(self, input: &str) -> IResult<&str, Stream<'_>>
pub fn parse_stream(self, input: &str) -> IResult<&str, Stream<'_>>
use nom::{Err, Needed};
use std::borrow::Cow;
use udv::text::{Unit, UDV, Header, Record, Message, Stream};
let parser = UDV::default();
assert_eq!(
parser.parse_stream(">\n,alpha,beta\n,gamma,delta\n<!"),
Ok(("", Stream(vec![
Message{
header: None,
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
}
])))
);
assert_eq!(
parser.parse_stream("#,one,two>\n,alpha,beta\n,gamma,delta\n<!"),
Ok(("", Stream(vec![
Message{
header: Some(Header(vec![Unit(Cow::Borrowed("one")), Unit(Cow::Borrowed("two"))])),
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
}
])))
);
assert_eq!(
parser.parse_stream(">\n,alpha,beta\n,gamma,delta\n<\ngarbage\n#,one,two>\n,alpha,beta\n,gamma,delta\n<!"),
Ok(("", Stream(vec![
Message{
header: None,
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
},
Message{
header: Some(Header(vec![Unit(Cow::Borrowed("one")), Unit(Cow::Borrowed("two"))])),
records: vec![
Record(vec![Unit(Cow::Borrowed("alpha")), Unit(Cow::Borrowed("beta"))]),
Record(vec![Unit(Cow::Borrowed("gamma")), Unit(Cow::Borrowed("delta"))]),
// Trailing empty record because of newline.
Record(vec![]),
]
},
])))
);
assert_eq!(
parser.parse_stream("#,one,two>\n,alpha,beta\n,gamma,delta\n<"),
Err(Err::Incomplete(Needed::new(1)))
);
Trait Implementations§
Source§impl Default for UDV
impl Default for UDV
Return a default reference parser for binary data, using C0 control codes. Return a default reference parser for text data.
impl Copy for UDV
impl Eq for UDV
impl StructuralPartialEq for UDV
Auto Trait Implementations§
impl Freeze for UDV
impl RefUnwindSafe for UDV
impl Send for UDV
impl Sync for UDV
impl Unpin for UDV
impl UnwindSafe for UDV
Blanket Implementations§
Source§impl<T> BorrowMut<T> for Twhere
T: ?Sized,
impl<T> BorrowMut<T> for Twhere
T: ?Sized,
Source§fn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more