Implement a proper request tokenizer

src/commands/audio_output_devices/disableoutput.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for DisableOutput {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let output_id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         debug_assert!(parts.next().is_none());

src/commands/audio_output_devices/enableoutput.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for EnableOutput {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let output_id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         debug_assert!(parts.next().is_none());

src/commands/audio_output_devices/outputs.rs

@@ -2,9 +2,12 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-    expect_property_type,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+        expect_property_type,
+    },
 };
 
 pub struct Outputs;
@@ -29,7 +32,7 @@ impl Command for Outputs {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Outputs, ""))
     }

src/commands/audio_output_devices/outputset.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -32,7 +33,7 @@ impl Command for OutputSet {
         )
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let output_id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let attribute_name = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let attribute_value = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

src/commands/audio_output_devices/toggleoutput.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for ToggleOutput {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let output_id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         debug_assert!(parts.next().is_none());

src/commands/client_to_client/channels.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         expect_property_type,
@@ -24,7 +25,7 @@ impl Command for Channels {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::Channels, ""))

src/commands/client_to_client/readmessages.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         expect_property_type,
@@ -27,7 +28,7 @@ impl Command for ReadMessages {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::ReadMessages, ""))

src/commands/client_to_client/sendmessage.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -25,7 +26,7 @@ impl Command for SendMessage {
         format!("{} {} {}", Self::COMMAND, request.channel, request.message)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let channel = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         // TODO: SplitWhitespace::remainder() is unstable, use when stable

src/commands/client_to_client/subscribe.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for Subscribe {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let channel_name = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         debug_assert!(parts.next().is_none());

src/commands/client_to_client/unsubscribe.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for Unsubscribe {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let channel_name = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
 
         debug_assert!(parts.next().is_none());

src/commands/connection_settings/binary_limit.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct BinaryLimit;
@@ -14,7 +17,7 @@ impl Command for BinaryLimit {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let limit = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let limit = limit
             .parse()

src/commands/connection_settings/close.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Close;
@@ -13,7 +14,7 @@ impl Command for Close {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Close, ""))
     }

src/commands/connection_settings/kill.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Kill;
@@ -13,7 +14,7 @@ impl Command for Kill {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Kill, ""))
     }

src/commands/connection_settings/password.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct Password;
@@ -14,7 +17,7 @@ impl Command for Password {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let password = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/connection_settings/ping.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Ping;
@@ -13,7 +14,7 @@ impl Command for Ping {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Ping, ""))
     }

src/commands/connection_settings/protocol.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
     },
@@ -18,7 +19,7 @@ impl Command for Protocol {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Protocol, ""))
     }

src/commands/connection_settings/protocol_all.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
@@ -14,7 +15,7 @@ impl Command for ProtocolAll {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ProtocolAll, ""))
     }

src/commands/connection_settings/protocol_available.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
     },
@@ -18,7 +19,7 @@ impl Command for ProtocolAvailable {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ProtocolAvailable, ""))
     }

src/commands/connection_settings/protocol_clear.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
@@ -14,7 +15,7 @@ impl Command for ProtocolClear {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ProtocolClear, ""))
     }

src/commands/connection_settings/protocol_disable.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for ProtocolDisable {
         format!("{} {}", Self::COMMAND, request.join(" "))
     }
 
-    fn parse_request(parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mut parts = parts.peekable();
         if parts.peek().is_none() {
             return Err(RequestParserError::UnexpectedEOF);

src/commands/connection_settings/protocol_enable.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for ProtocolEnable {
         format!("{} {}", Self::COMMAND, request.join(" "))
     }
 
-    fn parse_request(parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mut parts = parts.peekable();
         if parts.peek().is_none() {
             return Err(RequestParserError::UnexpectedEOF);

src/commands/connection_settings/tag_types.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-    expect_property_type,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+        expect_property_type,
+    },
 };
 
 pub struct TagTypes;
@@ -16,7 +19,7 @@ impl Command for TagTypes {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::TagTypes, ""))
     }

src/commands/connection_settings/tag_types_all.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
@@ -14,7 +15,7 @@ impl Command for TagTypesAll {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::TagTypesAll, ""))
     }

src/commands/connection_settings/tag_types_available.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
     },
@@ -18,7 +19,7 @@ impl Command for TagTypesAvailable {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::TagTypesAvailable, ""))
     }

src/commands/connection_settings/tag_types_clear.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
@@ -14,7 +15,7 @@ impl Command for TagTypesClear {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::TagTypesClear, ""))
     }

src/commands/connection_settings/tag_types_disable.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for TagTypesDisable {
         format!("{} {}", Self::COMMAND, request.join(" "))
     }
 
-    fn parse_request(parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mut parts = parts.peekable();
         if parts.peek().is_none() {
             return Err(RequestParserError::UnexpectedEOF);

src/commands/connection_settings/tag_types_enable.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for TagTypesEnable {
         format!("{} {}", Self::COMMAND, request.join(" "))
     }
 
-    fn parse_request(parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mut parts = parts.peekable();
         if parts.peek().is_none() {
             return Err(RequestParserError::UnexpectedEOF);

src/commands/connection_settings/tag_types_reset.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for TagTypesReset {
         format!("{} {}", Self::COMMAND, request.join(" "))
     }
 
-    fn parse_request(parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mut parts = parts.peekable();
         if parts.peek().is_none() {
             return Err(RequestParserError::UnexpectedEOF);

src/commands/controlling_playback/next.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Next;
@@ -13,7 +14,7 @@ impl Command for Next {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Next, ""))
     }

src/commands/controlling_playback/pause.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct Pause;
@@ -18,7 +21,7 @@ impl Command for Pause {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let result = match parts.next() {
             Some("0") => Ok((Request::Pause(Some(false)), "")),
             Some("1") => Ok((Request::Pause(Some(true)), "")),

src/commands/controlling_playback/play.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for Play {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songpos = match parts.next() {
             Some(s) => s
                 .parse::<SongPosition>()

src/commands/controlling_playback/playid.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for PlayId {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songid = match parts.next() {
             Some(s) => s
                 .parse::<SongId>()

src/commands/controlling_playback/previous.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Previous;
@@ -13,7 +14,7 @@ impl Command for Previous {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Previous, ""))
     }

src/commands/controlling_playback/seek.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -25,7 +26,7 @@ impl Command for Seek {
         format!("{} {} {}", Self::COMMAND, request.songpos, request.time)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songpos = match parts.next() {
             Some(s) => s
                 .parse::<SongPosition>()

src/commands/controlling_playback/seekcur.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -32,7 +33,7 @@ impl Command for SeekCur {
         format!("{} {}", Self::COMMAND, time_str)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let time_raw = match parts.next() {
             Some(t) => t,
             None => return Err(RequestParserError::UnexpectedEOF),

src/commands/controlling_playback/seekid.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -25,7 +26,7 @@ impl Command for SeekId {
         format!("{} {} {}", Self::COMMAND, request.songid, request.time)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songid = match parts.next() {
             Some(s) => s
                 .parse::<SongId>()

src/commands/controlling_playback/stop.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Stop;
@@ -13,7 +14,7 @@ impl Command for Stop {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Stop, ""))
     }

src/commands/mounts_and_neighbors/listmounts.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
     },
@@ -16,7 +17,7 @@ impl Command for ListMounts {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ListMounts, ""))
     }

src/commands/mounts_and_neighbors/listneighbors.rs

@@ -2,6 +2,7 @@ use std::collections::HashMap;
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserResult, ResponseAttributes, ResponseParserError, expect_property_type,
     },
@@ -20,7 +21,7 @@ impl Command for ListNeighbors {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ListNeighbors, ""))
     }

src/commands/mounts_and_neighbors/mount.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -24,7 +25,7 @@ impl Command for Mount {
         format!("{} {} {}", Self::COMMAND, request.path, request.uri)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let path = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/mounts_and_neighbors/unmount.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -18,7 +19,7 @@ impl Command for Unmount {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let path = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/music_database/albumart.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_and_parse_property, get_property,
@@ -33,7 +34,7 @@ impl Command for AlbumArt {
         format!("{} {} {}", Self::COMMAND, request.uri, request.offset)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = match parts.next() {
             Some(s) => s,
             None => return Err(RequestParserError::UnexpectedEOF),

src/commands/music_database/count.rs

@@ -3,12 +3,13 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_and_parse_property,
     },
     common::GroupType,
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct Count;
@@ -38,8 +39,13 @@ impl Command for Count {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let group = if let Some("group") = parts.next() {
             let group = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

src/commands/music_database/find.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct Find;
@@ -37,8 +38,13 @@ impl Command for Find {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window = parts.next();
         let mut sort = None;

src/commands/music_database/findadd.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{SongPosition, Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct FindAdd;
@@ -38,8 +39,13 @@ impl Command for FindAdd {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window_or_position = parts.next();
         let mut sort = None;

src/commands/music_database/getfingerprint.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_and_parse_property,
@@ -26,7 +27,7 @@ impl Command for GetFingerprint {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let uri = uri
             .parse()

src/commands/music_database/list.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, expect_property_type,
     },
     common::{GroupType, TagName},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct List;
@@ -33,14 +34,19 @@ impl Command for List {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let tagname = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let tagname = tagname
             .parse()
             .map_err(|_| RequestParserError::SyntaxError(1, tagname.to_owned()))?;
 
         // TODO: This should be optional
-        let filter = parse_filter(&mut parts)?;
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let group = if let Some("group") = parts.next() {
             let group = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

src/commands/music_database/listall.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -24,7 +25,7 @@ impl Command for ListAll {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts
             .next()
             .map(|s| {

src/commands/music_database/listallinfo.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -25,7 +26,7 @@ impl Command for ListAllInfo {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts
             .next()
             .map(|s| {

src/commands/music_database/listfiles.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -24,7 +25,7 @@ impl Command for ListFiles {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts
             .next()
             .map(|s| {

src/commands/music_database/lsinfo.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, expect_property_type,
@@ -30,7 +31,7 @@ impl Command for LsInfo {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts
             .next()
             .map(|s| {

src/commands/music_database/readcomments.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, GenericResponseValue, Request, RequestParserError, RequestParserResult,
         ResponseAttributes, ResponseParserError,
@@ -21,7 +22,7 @@ impl Command for ReadComments {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let uri = uri
             .parse()

src/commands/music_database/readpicture.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_and_parse_property, get_optional_property, get_property,
@@ -34,7 +35,7 @@ impl Command for ReadPicture {
         format!("{} {} {}", Self::COMMAND, request.uri, request.offset)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = match parts.next() {
             Some(s) => s,
             None => return Err(RequestParserError::UnexpectedEOF),

src/commands/music_database/rescan.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         get_and_parse_property,
@@ -29,7 +30,7 @@ impl Command for Rescan {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts.next().map(|s| s.to_string());
 
         debug_assert!(parts.next().is_none());

src/commands/music_database/search.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct Search;
@@ -37,8 +38,13 @@ impl Command for Search {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window = parts.next();
         let mut sort = None;

src/commands/music_database/searchadd.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{SongPosition, Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct SearchAdd;
@@ -38,8 +39,13 @@ impl Command for SearchAdd {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window_or_position = parts.next();
         let mut sort = None;

src/commands/music_database/searchaddpl.rs

@@ -1,12 +1,13 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
     },
     common::{PlaylistName, SongPosition, Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct SearchAddPl;
@@ -44,13 +45,18 @@ impl Command for SearchAddPl {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let playlist_name = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?
             .to_string();
 
-        let filter = parse_filter(&mut parts)?;
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window_or_position = parts.next();
         let mut sort = None;

src/commands/music_database/searchcount.rs

@@ -3,12 +3,13 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_and_parse_property,
     },
     common::GroupType,
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct SearchCount;
@@ -38,8 +39,13 @@ impl Command for SearchCount {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let group = if let Some("group") = parts.next() {
             let group = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;

src/commands/music_database/update.rs

@@ -3,6 +3,7 @@ use std::collections::HashMap;
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         get_and_parse_property,
@@ -29,7 +30,7 @@ impl Command for Update {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = parts.next().map(|s| s.to_string());
 
         debug_assert!(parts.next().is_none());

src/commands/partition_commands/delpartition.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for DelPartition {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let partition = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/partition_commands/listpartitions.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         expect_property_type,
@@ -19,7 +20,7 @@ impl Command for ListPartitions {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ListPartitions, ""))
     }

src/commands/partition_commands/moveoutput.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct MoveOutput;
@@ -14,7 +17,7 @@ impl Command for MoveOutput {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let output_name = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/partition_commands/newpartition.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for NewPartition {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let partition = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/partition_commands/partition.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for Partition {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let partition = parts
             .next()
             .ok_or(RequestParserError::UnexpectedEOF)?

src/commands/playback_options/consume.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for Consume {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let state = match parts.next() {
             Some(s) => crate::common::BoolOrOneshot::from_str(s)
                 .map_err(|_| RequestParserError::SyntaxError(0, s.to_owned()))?,

src/commands/playback_options/crossfade.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for Crossfade {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let seconds = match parts.next() {
             Some(s) => s
                 .parse::<Seconds>()

src/commands/playback_options/getvol.rs

@@ -1,6 +1,7 @@
 use std::collections::HashMap;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         get_and_parse_property,
@@ -19,7 +20,7 @@ impl Command for GetVol {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::GetVol, ""))
     }

src/commands/playback_options/mixrampdb.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct MixRampDb;
@@ -14,7 +17,7 @@ impl Command for MixRampDb {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let db = match parts.next() {
             Some(s) => s
                 .parse::<f32>()

src/commands/playback_options/mixrampdelay.rs

@@ -1,4 +1,5 @@
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -17,7 +18,7 @@ impl Command for MixRampDelay {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let seconds = match parts.next() {
             Some(s) => s
                 .parse::<Seconds>()

src/commands/playback_options/random.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct Random;
@@ -15,7 +18,7 @@ impl Command for Random {
         format!("{} {}", Self::COMMAND, state)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let state = match parts.next() {
             Some("0") => false,
             Some("1") => true,

src/commands/playback_options/repeat.rs

@@ -1,6 +1,9 @@
-use crate::commands::{
-    Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
-    ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
+        ResponseParserError,
+    },
 };
 
 pub struct Repeat;
@@ -15,7 +18,7 @@ impl Command for Repeat {
         format!("{} {}", Self::COMMAND, state)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let state = match parts.next() {
             Some("0") => false,
             Some("1") => true,

src/commands/playback_options/replay_gain_mode.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for ReplayGainMode {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let mode = match parts.next() {
             Some(s) => ReplayGainModeMode::from_str(s)
                 .map_err(|_| RequestParserError::SyntaxError(0, s.to_owned()))?,

src/commands/playback_options/replay_gain_status.rs

@@ -3,6 +3,7 @@ use std::{collections::HashMap, str::FromStr};
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
         get_property,
@@ -26,7 +27,7 @@ impl Command for ReplayGainStatus {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::ReplayGainStatus, ""))
     }

src/commands/playback_options/setvol.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for SetVol {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let volume = match parts.next() {
             Some(s) => VolumeValue::from_str(s)
                 .map_err(|_| RequestParserError::SyntaxError(0, s.to_owned()))?,

src/commands/playback_options/single.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for Single {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let state = match parts.next() {
             Some(s) => crate::common::BoolOrOneshot::from_str(s)
                 .map_err(|_| RequestParserError::SyntaxError(0, s.to_owned()))?,

src/commands/playback_options/volume.rs

@@ -1,6 +1,7 @@
 use std::str::FromStr;
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -19,7 +20,7 @@ impl Command for Volume {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let change = match parts.next() {
             Some(s) => VolumeValue::from_str(s)
                 .map_err(|_| RequestParserError::SyntaxError(0, s.to_owned()))?,

src/commands/querying_mpd_status/clearerror.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 /// Clears the current error message in status (this is also accomplished by any command that starts playback)
@@ -14,7 +15,7 @@ impl Command for ClearError {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::ClearError, ""))

src/commands/querying_mpd_status/currentsong.rs

@@ -1,7 +1,8 @@
 use serde::{Deserialize, Serialize};
 
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 /// Displays the song info of the current song (same song that is identified in status)
@@ -19,7 +20,7 @@ impl Command for CurrentSong {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::CurrentSong, ""))

src/commands/querying_mpd_status/idle.rs

@@ -1,5 +1,6 @@
-use std::str::{FromStr, SplitWhitespace};
+use std::str::FromStr;
 
+use crate::request_tokenizer::RequestTokenizer;
 use crate::common::SubSystem;
 
 use crate::commands::{
@@ -29,7 +30,7 @@ impl Command for Idle {
         }
     }
 
-    fn parse_request(mut parts: SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let result = parts
             .next()
             .map_or(Ok((Request::Idle(None), "")), |subsystems| {

src/commands/querying_mpd_status/stats.rs

@@ -2,9 +2,12 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
-    get_and_parse_optional_property, get_and_parse_property,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{
+        Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+        get_and_parse_optional_property, get_and_parse_property,
+    },
 };
 
 pub struct Stats;
@@ -29,7 +32,7 @@ impl Command for Stats {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::Stats, ""))

src/commands/querying_mpd_status/status.rs

@@ -3,6 +3,7 @@ use std::str::FromStr;
 
 use serde::{Deserialize, Serialize};
 
+use crate::request_tokenizer::RequestTokenizer;
 use crate::common::{Audio, BoolOrOneshot, SongId, SongPosition};
 
 use crate::commands::{
@@ -167,7 +168,7 @@ impl Command for Status {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
 
         Ok((Request::Status, ""))

src/commands/queue/add.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError,
@@ -28,7 +29,7 @@ impl Command for Add {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = match parts.next() {
             Some(s) => s,
             None => return Err(RequestParserError::UnexpectedEOF),

src/commands/queue/addid.rs

@@ -1,6 +1,7 @@
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, Request, RequestParserError, RequestParserResult, ResponseAttributes,
         ResponseParserError, get_next_and_parse_property,
@@ -33,7 +34,7 @@ impl Command for AddId {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let uri = match parts.next() {
             Some(s) => s,
             None => return Err(RequestParserError::UnexpectedEOF),

src/commands/queue/addtagid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -32,7 +33,7 @@ impl Command for AddTagId {
         )
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songid = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let songid = songid
             .parse()

src/commands/queue/clear.rs

@@ -1,5 +1,6 @@
-use crate::commands::{
-    Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError,
+use crate::{
+    request_tokenizer::RequestTokenizer,
+    commands::{Command, Request, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
 pub struct Clear;
@@ -13,7 +14,7 @@ impl Command for Clear {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Clear, ""))
     }

src/commands/queue/cleartagid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -25,7 +26,7 @@ impl Command for ClearTagId {
         format!("{} {} {}", Self::COMMAND, request.songid, request.tag_name)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songid = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let songid = songid
             .parse()

src/commands/queue/delete.rs

@@ -2,6 +2,7 @@ use std::str::FromStr;
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -19,7 +20,7 @@ impl Command for Delete {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let pos_or_range = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let one_or_range = OneOrRange::from_str(pos_or_range)
             .map_err(|_| RequestParserError::SyntaxError(0, pos_or_range.to_string()))?;

src/commands/queue/deleteid.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -17,7 +18,7 @@ impl Command for DeleteId {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let id = id
             .parse()

src/commands/queue/move_.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -25,7 +26,7 @@ impl Command for Move {
         format!("{} {} {}", Self::COMMAND, request.from_or_range, request.to)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let from_or_range = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let from_or_range = from_or_range
             .parse()

src/commands/queue/moveid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -25,7 +26,7 @@ impl Command for MoveId {
         format!("{} {} {}", Self::COMMAND, request.id, request.to)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let id = id
             .parse()

src/commands/queue/playlist.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{Command, RequestParserResult, ResponseAttributes, ResponseParserError},
 };
 
@@ -14,7 +15,7 @@ impl Command for Playlist {
         Self::COMMAND.to_string()
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         debug_assert!(parts.next().is_none());
         Ok((Request::Playlist, ""))
     }

src/commands/queue/playlistfind.rs

@@ -2,11 +2,12 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
     common::{Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct PlaylistFind;
@@ -34,8 +35,13 @@ impl Command for PlaylistFind {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window = parts.next();
         let mut sort = None;

src/commands/queue/playlistid.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -17,7 +18,7 @@ impl Command for PlaylistId {
         format!("{} {}", Self::COMMAND, request)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let id = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let id = id
             .parse()

src/commands/queue/playlistinfo.rs

@@ -1,5 +1,6 @@
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -20,7 +21,7 @@ impl Command for PlaylistInfo {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let one_or_range = parts
             .next()
             .map(|s| {

src/commands/queue/playlistsearch.rs

@@ -2,11 +2,12 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
     common::{Sort, WindowRange},
-    filter::{Filter, parse_filter},
+    filter::Filter,
 };
 
 pub struct PlaylistSearch;
@@ -34,8 +35,13 @@ impl Command for PlaylistSearch {
         cmd
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
-        let filter = parse_filter(&mut parts)?;
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
+        let filter = match parts.next() {
+            Some(f) => {
+                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?
+            }
+            None => return Err(RequestParserError::UnexpectedEOF),
+        };
 
         let mut sort_or_window = parts.next();
         let mut sort = None;

src/commands/queue/plchanges.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -28,7 +29,7 @@ impl Command for PlChanges {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let version = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let version = version
             .parse()

src/commands/queue/plchangesposid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -28,7 +29,7 @@ impl Command for PlChangesPosId {
         }
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let version = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let version = version
             .parse()

src/commands/queue/prio.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -25,7 +26,7 @@ impl Command for Prio {
         format!("{} {} {}", Self::COMMAND, request.prio, request.window)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let prio = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let prio = prio
             .parse()

src/commands/queue/prioid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -31,7 +32,7 @@ impl Command for PrioId {
         format!("{} {} {}", Self::COMMAND, request.prio, songids)
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let prio = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let prio = prio
             .parse()

src/commands/queue/rangeid.rs

@@ -2,6 +2,7 @@ use serde::{Deserialize, Serialize};
 
 use crate::{
     Request,
+    request_tokenizer::RequestTokenizer,
     commands::{
         Command, RequestParserError, RequestParserResult, ResponseAttributes, ResponseParserError,
     },
@@ -30,7 +31,7 @@ impl Command for RangeId {
         )
     }
 
-    fn parse_request(mut parts: std::str::SplitWhitespace<'_>) -> RequestParserResult<'_> {
+    fn parse_request(mut parts: RequestTokenizer<'_>) -> RequestParserResult<'_> {
         let songid = parts.next().ok_or(RequestParserError::UnexpectedEOF)?;
         let songid = songid
             .parse()