pub fn new(filter: Filter, group: Option<GroupType>) -> Self {

        CountRequest { filter, group }

    }

    fn serialize(&self) -> String {

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

        if let Some(group) = self.group.as_ref() {

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

        }

        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 group = if let Some("group") = parts.next() {

            let group = parts

                .next()

                .ok_or(RequestParserError::MissingKeywordValue {

                    argument_index: 1,

                    keyword: "group",

                })?;

                group

                    .parse()

                    .map_err(|_| RequestParserError::SubtypeParserError {

                        raw_input: group.to_owned(),

                    })?,

            None

        Self::throw_if_too_many_arguments(parts)?;

        Ok(CountRequest { filter, group })

    }

    pub fn new(songs: usize, playtime: u64) -> Self {

        CountResponse { songs, playtime }

    }

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

        let parts: HashMap<_, _> = parts.into_map()?;

        let songs = get_and_parse_property!(parts, "songs", Text);

        let playtime = get_and_parse_property!(parts, "playtime", Text);

        Ok(CountResponse { songs, playtime })

    }

    fn serialize(&self) -> Vec<u8> {

        unimplemented!("response serialization is not yet implemented for CountResponse")