generated.rs

#![feature(prelude_import)]
#![no_std]
#![feature(plugin)]
#![plugin(slave_codegen)]
#[prelude_import]
use std::prelude::v1::*;
#[macro_use]
extern crate std as std;

extern crate slave;

#[cfg(test)]
mod codegen {
    use slave::Worker;
    use std::sync::mpsc::{Receiver, SyncSender, sync_channel};

    struct MyWorker {
        requests: u8,
        receiver: Receiver<handle::Command>,
        sender: SyncSender<handle::Command>,
    }

    impl MyWorker {
        pub fn new() -> Self {
            let (sender, receiver) = sync_channel::<handle::Command>(1000);
            MyWorker {
                requests: 0,
                receiver,
                sender,
            }
        }

        pub fn write(&mut self) {
            // Write some data to redis
        }

        pub fn increment_requests(&mut self, amount: u8) {
            self.requests += amount;
        }

        pub fn get_requests(&self) -> u8 {
            self.requests
        }
    }
    pub mod handle {
        use slave::Worker;
        use std::sync::mpsc::{Sender, SyncSender};
        use std::thread::{self, JoinHandle};
        use super::MyWorker;
        pub enum Command {
            Cmd_write(),
            Cmd_increment_requests(u8),
            Cmd_get_requests(SyncSender<u8>),
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::std::fmt::Debug for Command {
            fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                match (&*self,) {
                    (&Command::Cmd_write(),) => {
                        let mut builder = __arg_0.debug_tuple("Cmd_write");
                        builder.finish()
                    }
                    (&Command::Cmd_increment_requests(ref __self_0),) => {
                        let mut builder = __arg_0.debug_tuple("Cmd_increment_requests");
                        let _ = builder.field(&&(*__self_0));
                        builder.finish()
                    }
                    (&Command::Cmd_get_requests(ref __self_0),) => {
                        let mut builder = __arg_0.debug_tuple("Cmd_get_requests");
                        let _ = builder.field(&&(*__self_0));
                        builder.finish()
                    }
                }
            }
        }
        pub enum Message {
            Msg_get_requests(u8),
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::std::fmt::Debug for Message {
            fn fmt(&self, __arg_0: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
                match (&*self,) {
                    (&Message::Msg_get_requests(ref __self_0),) => {
                        let mut builder = __arg_0.debug_tuple("Msg_get_requests");
                        let _ = builder.field(&&(*__self_0));
                        builder.finish()
                    }
                }
            }
        }
        pub struct Handle {
            sender: SyncSender<Command>,
        }
        #[automatically_derived]
        #[allow(unused_qualifications)]
        impl ::std::clone::Clone for Handle {
            #[inline]
            fn clone(&self) -> Handle {
                match *self {
                    Handle { sender: ref __self_0_0 } => {
                        Handle { sender: ::std::clone::Clone::clone(&(*__self_0_0)) }
                    }
                }
            }
        }
        impl Handle {
            pub fn write(&self) {
                self.sender.send(Command::Cmd_write());
            }
            pub fn increment_requests(&self, amount: u8) {
                self.sender.send(Command::Cmd_increment_requests(amount));
            }
            pub fn get_requests(&self) -> Result<u8, ()> {
                use std::sync::mpsc;
                let (sender, receiver) = mpsc::sync_channel::<u8>(1000);
                self.sender
                    .send(Command::Cmd_get_requests(sender.clone()));
                match receiver.recv() {
                    Ok(res) => Ok(res),
                    _ => Err(()),
                }
            }
        }
        impl Worker for MyWorker {
            type Handle = Handle;
            fn name(&self) -> &str {
                "type(MyWorker)"
            }
            fn run(mut self: Self) -> JoinHandle<()> {
                thread::spawn(move || loop {
                                  match self.receiver.recv() {
                                      Ok(Command::Cmd_write()) => self.write(),
                                      Ok(Command::Cmd_increment_requests(amount)) => {
                                          self.increment_requests(amount)
                                      }
                                      Ok(Command::Cmd_get_requests(sender)) => {
                        let res = self.get_requests();
                        sender.send(res);
                    }
                                      _ => (),
                                  }
                              })
            }
            fn get_handle(&self) -> Self::Handle {
                Handle { sender: self.sender.clone() }
            }
        }
    }

    #[test]
    pub fn it_works() {
        use std::thread;
        use std::time::Duration;

        let mut worker = MyWorker::new();
        let h = worker.get_handle();

        worker.run();

        h.increment_requests(10);
        if !(h.get_requests() == Ok(10)) {
            {
                ::rt::begin_panic("assertion failed: h.get_requests() == Ok(10)", {
                    static _FILE_LINE: (&'static str, u32) = ("tests/codegen.rs", 55u32);
                    &_FILE_LINE
                })
            }
        }
    }
    pub mod __test_reexports {
        pub use super::it_works;
    }
}
pub mod __test_reexports {
    pub use super::codegen::__test_reexports as codegen;
}
pub mod __test {
    extern crate test;
    #[main]
    pub fn main() -> () {
        test::test_main_static(TESTS)
    }
    const TESTS: &'static [self::test::TestDescAndFn] =
        &[self::test::TestDescAndFn {
              desc: self::test::TestDesc {
                  name: self::test::StaticTestName("codegen::it_works"),
                  ignore: false,
                  should_panic: self::test::ShouldPanic::No,
              },
              testfn: self::test::StaticTestFn(::__test_reexports::codegen::it_works),
          }];
}