pub fn new(

        filter: Filter,

        sort: Option<Sort>,

        window: Option<WindowRange>,

        position: Option<SongPosition>,

    ) -> Self {

        Self {

            filter,

            sort,

            window,

            position,

        }

    }

    fn serialize(&self) -> String {

        let mut cmd = format!("{} {}", Self::COMMAND, self.filter);

        if let Some(sort) = &self.sort {

            cmd.push_str(&format!(" sort {}", sort));

        }

        if let Some(window) = &self.window {

            cmd.push_str(&format!(" window {}", window));

        }

        if let Some(position) = &self.position {

            cmd.push_str(&format!(" position {}", position));

        }

        cmd.push('\n');

        cmd

    }

    fn parse(mut parts: RequestTokenizer<'_>) -> Result<Self, RequestParserError> {

        let filter = match parts.next() {

            Some(f) => {

                Filter::parse(f).map_err(|_| RequestParserError::SyntaxError(1, f.to_owned()))?

            None => return Err(Self::missing_arguments_error(0)),

        let mut argument_index_counter = 0;

        let mut sort_or_window_or_position = parts.next();

        let mut sort = None;

        if let Some("sort") = sort_or_window_or_position {

            argument_index_counter += 1;

            let s = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    keyword: "sort",

                    argument_index: argument_index_counter,

                })?;

            sort = Some(

                s.parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        argument_index: argument_index_counter,

                        raw_input: s.to_string(),

                    })?,

            sort_or_window_or_position = parts.next();

        }

        let mut window = None;

        if let Some("window") = sort_or_window_or_position {

            argument_index_counter += 1;

            let w = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    keyword: "window",

                    argument_index: argument_index_counter,

                })?;

                w.parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        argument_index: argument_index_counter,

                        raw_input: w.to_string(),

                    })?,

            sort_or_window_or_position = parts.next();

        }

        let mut position = None;

        if let Some("position") = sort_or_window_or_position {

            argument_index_counter += 1;

            let p = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    keyword: "position",

                    argument_index: argument_index_counter,

                })?;

                p.parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        argument_index: argument_index_counter,

                        raw_input: p.to_string(),

                    })?,

        }

        Self::throw_if_too_many_arguments(parts)?;

        Ok(FindAddRequest {

            filter,

            sort,

            window,

            position,

        })

    }