You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: pubsub.rs
    path of file: ./repos/rust-ipfs/http/src/v0
    
    the code of the file until where you have to start completion: //! /api/v0/pubsub module.
//!
//! /api/v0/pubsub/sub?arg=topic allows multiple clients to subscribe to the single topic, with
//! semantics of getting the messages received on that topic from request onwards. This is
//! implemented with [`tokio::sync::broadcast`] which supports these semantics.
//!
//! # Panics
//!
//! The subscription functionality *assumes* that there are no other users for
//! `ipfs::Ipfs::pubsub_subscribe` and thus will panic if an subscription was made outside of this
//! locking mechanism.

use futures::stream::{Stream, TryStream};
use serde::{Deserialize, Serialize};

use tokio::sync::{broadcast, Mutex};
us
    
    fn next(&mut self) -> Option<Self::Item> {
        loop {
            if self.input.is_empty() {
                return None;
            }

            let mut split2 = self.input.splitn(2, |&b| b == b'&');

            let sequence = split2.next().expect("splitn will always return first");
            self.input = split2.next().unwrap_or_default();

            if sequence.is_empty() {
                continue;
            }

            let mut split2 = sequence.splitn(2, |&b| b == b'=');
            let name = split2.next().expect("splitn will always return first");
            let value = split2.next().unwrap_or_default();
            // original implementation calls percent_decode for both arguments into lossy Cow<str>
            return Some((name, value));
        }
    }