Buffering message handler

help
1

I'm teaching myself some Rust by writing a WebSocket client application. The app is continuously processing messages, but sometimes I want to pause the processing. While on pause I want to buffer incoming messages. Then once the app is resumed the buffered messages will be processed in order. I managed to build this solution:

Could you please make code review on this? Maybe I should rewrite this using different approach/types?

2

The strange thing about ProcessBuffer is that it takes a reference to a message, and then clones it. Unless for some reason the incoming messages are delivered by reference (in which case accepting the reference saves cloning all non-buffered messages) you should take and return the messages by value. Then you don’t need the clone(), the T: Clone bound, the to_discard field and code, or any lifetime annotations.

pub struct ProcessBuffer<T> {
    is_buffering: bool,
    queue: VecDeque<T>,
}

impl<T> ProcessBuffer<T> {
    fn new() -> ProcessBuffer<T> {
        ProcessBuffer {
            is_buffering: false,
            queue: VecDeque::new(),
        }
    }

    fn process(&mut self, message: T) -> Vec<T> {
        if self.is_buffering {
            self.queue.push_back(message);
            Vec::new()
        } else {
            let mut result: Vec<T> = Vec::with_capacity(self.queue.len() + 1);
            result.extend(self.queue.drain(..));
            result.push(message);
            result
        }
    }
}

It would also be possible to avoid the Vec<T> allocation if you design this to return an iterator, but that may not be worth doing.