Question: Correct use of type alias?

[the-moog]

There are type alias for producers and consumbers, namely Prod and Cons that depend on the storage used.

If I try and put those type alises into a structure I need to define the type, but I have no idea what that type should be.

e.g.

use ringbuf::{traits::*, HeapRb, Prod, Cons};

pub struct SerialBuffer {
    fifo: HeapRb<u8>,
    prod: Prod<P>.
    cons: Cons<C>
}

impl Default for SerialBuffer {
    fn default() -> Self {
        let mut fifo = HeapRb::<u8>:new(100);
        let (mut prod, mut cons) = fifo.split();

        Self {
            fifo: fifo,
            prod: prod,
            cons: cons
        }
    }
}

What are the types for P and C?

I've tried the obvious u8 and Arc<u8> but neither are accepted. I've looked through the code and examples with no luck....

[the-moog]

Update:
Eventually worked out that I need HeapProd<u8> and HeapCons<u8> but that got me nowhere.

All the examples generate the producer and consumer in the same thread by calling split(), then create two more child threads.

1: Modifying the message.rs example I can contain the state in a structure, but I can't find a way to do that were access to fifo is retained. Is there a need for this ability or can I safely leave it behind within new()?

2: I seem to have to put the prod/cons into a temporary variable before moving it to the thread, (I am new to Rust) I can see that this is because the thread then owns it, but is there a way that does not introduce needless variables? I.e. somehow pass b?

use ringbuf::{traits::*, HeapRb, HeapProd, HeapCons};
use std::{io::Read, thread, time::Duration};

pub struct Buffer {
    // fifo: HeapRb<u8>,    // Can't seem to do this?
    prod: HeapProd<u8>,
    cons: HeapCons<u8>
}

impl Buffer {

    fn new() -> Self {
        let fifo = HeapRb::<u8>::new(10);
        let (prod, cons) = fifo.split();
        Self {
            prod: prod,
            cons: cons
        }
    }   
}

fn main() {
    let b = Buffer::new();

    let smsg = "The quick brown fox jumps over the lazy dog";

    let mut prod = b.prod;
    let pjh = thread::spawn(move || {
        println!("-> sending message: '{}'", smsg);

        let zero = [0];
        let mut bytes = smsg.as_bytes().chain(&zero[..]);
        loop {
            if prod.is_full() {
                println!("-> buffer is full, waiting");
                thread::sleep(Duration::from_millis(1));
            } else {
                match prod.read_from(&mut bytes, None).transpose().unwrap() {
                    None | Some(0) => break,
                    Some(n) => println!("-> {} bytes sent", n),
                }
            }
        }

        println!("-> message sent");
    });

    let mut cons = b.cons;
    let cjh = thread::spawn( move || {
        println!("<- receiving message");

        let mut bytes = Vec::<u8>::new();
        loop {
            if cons.is_empty() {
                if bytes.ends_with(&[0]) {
                    break;
                } else {
                    println!("<- buffer is empty, waiting");
                    thread::sleep(Duration::from_millis(1));
                }
            } else {
                let n = cons.write_into(&mut bytes, None).unwrap().unwrap();
                println!("<- {} bytes received", n);
            }
        }

        assert_eq!(bytes.pop().unwrap(), 0);
        let msg = String::from_utf8(bytes).unwrap();
        println!("<- message received: '{}'", msg);

        msg
    });

    pjh.join().unwrap();
    let rmsg = cjh.join().unwrap();

    assert_eq!(smsg, rmsg);
}

[agerasev]

You're right HeapProd and HeapCons are the right aliases for HeapRb's producer and consumer.

... but I can't find a way to do that were access to fifo is retained. Is there a need for this ability or can I safely leave it behind within new()?

You don't need to explicitly store fifo somewhere, HeapRb's storage is allocated on the heap, and HeapProd and HeapCons also hold references to this storage. Moreover, you can't retain HeapRb after .split() because it is allowed to split it only once.

I seem to have to put the prod/cons into a temporary variable before moving it to the thread, (I am new to Rust) I can see that this is because the thread then owns it, but is there a way that does not introduce needless variables? I.e. somehow pass b?

You may directly use b.prod and b.cons in your spawned threads. Rust is clever enough to understand that in this case b should be destructured, and one part of it should be moved to the first thread, while other part should be moved to the second thread.