pub fn new(uri: Uri, position: Option<SongPosition>) -> Self {

        Self { uri, position }

    }

    fn into_request_enum(self) -> crate::Request {

        crate::Request::Add(self.uri, self.position)

    }

    fn from_request_enum(request: crate::Request) -> Option<Self> {

        match request {

            crate::Request::Add(uri, position) => Some(AddRequest { uri, position }),

            _ => None,

    }

    fn serialize(&self) -> String {

        match self.position {

            Some(position) => format!("{} {} {}\n", Self::COMMAND, self.uri, position),

            None => format!("{} {}\n", Self::COMMAND, self.uri),

    }

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

        let uri = match parts.next() {

            Some(s) => s,

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

        let position = match parts.next() {

            Some(s) => Some(s.parse::<SongPosition>().map_err(|_| {

                RequestParserError::SubtypeParserError {

                    argument_index: 1,

                    expected_type: "SongPosition",

                    raw_input: s.to_owned(),

                }

            })?),

            None => None,

        Self::throw_if_too_many_arguments(parts)?;

        Ok(AddRequest {

            uri: uri.to_string(),

            position,

        })

    }