foo.rs

pub struct MpscReceiverSet{
    select: mpsc::Select,
    handles: Vec<mpsc::Handle<mpsc::Receiver<MpscChannelMessage>>>,
    receivers: Vec<MpscReceiver>,
}

impl MpscReceiverSet {
    pub fn new() -> Result<MpscReceiverSet,MpscError> {
        Ok(MpscReceiverSet {
            select: mpsc::Select::new(),
            handles: vec![],
        })
    }

    pub fn add(&mut self, receiver: MpscReceiver) -> Result<i64,MpscError> {
        let receiver = receiver.consume();
        let handle = self.select.add(receiver.receiver.borrow().unwrap());
        let id = handle.id() as i64;
        unsafe {
            handle.add();
        }
        self.receivers.push(receiver);
        self.handles.push(handle);
        Ok(id);
    }

    pub fn select(&mut self) -> Result<Vec<MpscSelectionResult>,MpscError> {
        let id = self.select.wait();
        for (index,h) in &self.handles.iter().enumerate() {
            if h.id() == id {
                let receiver = &self.receivers[index];
                match receiver.recv() {
                    Ok((data, channels, shmems)) =>
                        return Ok(MpscSelectionResult::DataReceived(id as i64, data, channels, shmems)),
                    Err(err) => {
                        if (err == MpscError::ChannelClosedError) {
                            return Ok(MpscSelectionResult::ChannelClosed(id as i64));
                        }
                        return Err(err);
                    }
                }
            }
        }
        return Err(MpscError::UnknownError);
    }
}