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

        Self { uri, position }

    }

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

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

    }

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

        match request {

            crate::Request::AddId(uri, position) => Some(AddIdRequest { uri, position }),

            _ => None,

    }

    fn serialize(&self) -> String {

        match self.position {

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

            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(AddIdRequest {

            uri: uri.to_string(),

            position,

        })

    }

    pub fn new(id: SongId) -> Self {

        Self { id }

    }

    fn into_response_enum(self) -> crate::Response {

        todo!()

    fn from_response_enum(_response: crate::Response) -> Option<Self> {

        todo!()

    fn parse(parts: ResponseAttributes<'_>) -> Result<Self, ResponseParserError> {

        let parts: Vec<_> = parts.into();

        let mut iter = parts.into_iter();

        let (key, id) = get_next_and_parse_property!(iter, Text);

        if key != "Id" {

            return Err(ResponseParserError::UnexpectedProperty(key.to_string()));

        }

        Ok(AddIdResponse { id })

    }