impl<U: Send + 'static> CountLogger<U> {
    pub fn count(&mut self) {
        self.count += 1;
        println!("[COUNT] - {}", self.count);
    }
}
pub enum CountLoggerMessage {
    count {},
}
impl<U: Send + 'static> CountLogger<U> {
    pub fn route_message(&mut self, msg: CountLoggerMessage) {
        match msg {
            CountLoggerMessage::count {} => self.count(),
        };
    }
}
#[derive(Clone)]
pub struct CountLoggerActor {
    sender: Sender<CountLoggerMessage>,
}
impl CountLoggerActor {
    pub fn new<U: Send + 'static>(actor_impl: CountLogger<U>) -> Self {
        let (sender, receiver) = channel(0);
        let id = "random string".to_owned();
        tokio::spawn(CountLoggerRouter {
            receiver,
            id,
            actor_impl,
        });
        Self { sender }
    }
    pub fn count(&self) {
        let msg = CountLoggerMessage::count {};
        tokio::spawn(self.sender.clone().send(msg).map(|_| ()).map_err(|_| ()));
    }
}
pub struct CountLoggerRouter<U: Send + 'static> {
    receiver: Receiver<CountLoggerMessage>,
    id: String,
    actor_impl: CountLogger<U>,
}
impl<U: Send + 'static> Future for CountLoggerRouter<U> {
    type Item = ();
    type Error = ();
    fn poll(&mut self) -> Poll<Self::Item, Self::Error> {
        match self.receiver.poll() {
            Ok(Async::Ready(Some(msg))) => {
                task::current().notify();
                self.actor_impl.route_message(msg);
                Ok(Async::NotReady)
            }
            Ok(Async::Ready(None)) => {
                self.receiver.close();
                Ok(Async::Ready(()))
            }
            _ => Ok(Async::NotReady),
        }
    }
}