Crate time

Pimalaya time management

Rust library to manange your time.

The core concept is the Timer, which gathers information about the cycle and the state. The Server runs the timer and accepts connection from Clients thanks to ServerBinders. The clients communicate with the server using Requests and Responses, which allow them to control the timer.

┌────────────────────────┐
│Server                  │
│             ┌────────┐ │ Request ┌────────┐
│             │        │◄├─────────┤        │
│    ┌────────┤Binder A│ │         │Client A│
│    │        │        ├─┼────────►│        │
│    │        └────────┘ │Response └────────┘
│    │                   │
│    ▼        ┌────────┐ │         ┌────────┐
│ ┌─────┐     │        │◄├─────────┤        │
│ │Timer│◄────┤Binder B│ │         │Client B│
│ └─────┘     │        ├─┼────────►│        │
│    ▲        └────────┘ │         └────────┘
│    │                   │
│    │        ┌────────┐ │         ┌────────┐
│    │        │        │◄├─────────┤        │
│    └────────┤Binder C│ │         │Client C│
│             │        ├─┼────────►│        │
│             └────────┘ │         └────────┘
│                        │
└────────────────────────┘

use std::{thread, time::Duration};
use time::{ServerBuilder, ServerEvent, TcpBind, TcpClient, TimerEvent};

const HOST: &str = "127.0.0.1";
const PORT: u16 = 3000;

pub fn main() {
    let server = ServerBuilder::new()
        .with_server_handler(|event: ServerEvent| {
            println!("server event: {:?}", event);
            Ok(())
        })
        .with_timer_handler(|event: TimerEvent| {
            println!("timer event: {:?}", event);
            Ok(())
        })
        .with_binder(TcpBind::new(HOST, PORT))
        .with_pomodoro_config()
        .build()
        .unwrap();

    server
        .bind_with(|| {
            let client = TcpClient::new(HOST, PORT);
            client.start().unwrap();
            thread::sleep(Duration::from_secs(1));
            client.pause().unwrap();
            thread::sleep(Duration::from_secs(1));
            let timer = client.get().unwrap();
            println!("current timer: {:?}", timer);
            Ok(())
        })
        .unwrap();
}

Structs

• Server
• ServerBuilder
  Convenient builder that helps you to build a Server.
• ServerConfig
• TcpBind
• TcpClient
• ThreadSafeState
  Thread safe version of the ServerState which allows the Server to mutate its state even from a std::thread::spawn).
• ThreadSafeTimer
  Thread safe version of the Timer.
• Timer
  The timer.
• TimerConfig
  The timer configuration.
• TimerCycle
  The timer cycle.
• TimerCycles
  The timer cycles list.

Enums

• Request
• Response
• ServerEvent
• ServerState
• TimerEvent
  The timer event.
• TimerLoop
  The timer loop.
• TimerState
  The timer state.

Traits

• Client
  Clients must implement this trait. Only the Client::send function needs to be implemented: it should describe how to connect and send requests to the server.
• ClientStream
  Clients may implement this trait, but it is not mandatory. It can be seen as a helper: by implementing the ClientStream::read and the ClientStream::write functions, the trait can deduce how to handle a request.
• ServerBind
  ServerBinders must implement this trait.
• ServerStream
  ServerBinders may implement this trait, but it is not mandatory. It can be seen as a helper: by implementing the ServerStream::read and the ServerStream::write functions, the trait can deduce how to handle a request.

Type Aliases

• ServerStateChangedHandler
• TimerChangedHandler
  The timer changed handler.