"serde_json",

]
[[package]]
name = "serde_json"
version = "1.0.57"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "164eacbdb13512ec2745fb09d51fd5b22b0d65ed294a1dcf7285a360c80a675c"
dependencies = [
 "itoa",
 "ryu",
 "serde",

serde_json = "1"

        "running" => {
            client::new().send(Message::Running)?;

            Ok(())
        }

            server::new().start()?;

            let xdg_dirs = xdg::BaseDirectories::with_prefix("histdb-rs")?;
            let server = match xdg_dirs.find_cache_file("server.json") {
                None => server::new(),
                Some(path) => {
                    let file = std::fs::File::open(path).unwrap();
                    let reader = std::io::BufReader::new(file);

                    serde_json::from_reader(reader).unwrap()
                }
            };
            let server = server.start()?;
            let path = xdg_dirs.place_cache_file("server.json").unwrap();
            let file = std::fs::File::create(path).unwrap();
            let writer = std::io::BufWriter::new(file);
            serde_json::to_writer(writer, &server).unwrap();

    Running,

};
use serde::{
    Deserialize,
    Serialize,

    #[error("server is stopping")]
    Stop,

impl Error {

#[derive(Debug)]
enum RunState {
    Stop,
    Continue,
}
impl RunState {

        matches!(self, Self::Stop)

        match self {
            RunState::Stop => true,
            RunState::Continue => false,
        }

#[derive(Debug, Serialize, Deserialize)]

    pub fn start(mut self) -> Result<(), Error> {

    pub fn start(mut self) -> Result<Self, Error> {

                Ok(message) => {
                    if let Err(err) = self.process(message) {
                        if err.is_stop() {

                Ok(message) => match self.process(message) {
                    Ok(state) => {
                        if state.is_stop() {

                        eprintln!("error encountered: {}", err)

                }

                    Err(err) => eprintln!("error encountered: {}", err),
                },

        Ok(())

        Ok(self)

    fn process(&mut self, message: Message) -> Result<(), Error> {

    fn process(&mut self, message: Message) -> Result<RunState, Error> {

            Message::Stop => Err(Error::Stop),

            Message::Stop => Ok(RunState::Stop),

            Message::Running => self.command_running(),

    fn command_start(&mut self, start: CommandStart) -> Result<(), Error> {

    fn command_start(&mut self, start: CommandStart) -> Result<RunState, Error> {

        Ok(())

        Ok(RunState::Continue)

    fn command_finished(&mut self, finish: CommandFinished) -> Result<(), Error> {

    fn command_finished(&mut self, finish: CommandFinished) -> Result<RunState, Error> {

        Ok(RunState::Continue)
    }

        Ok(())

    fn command_running(&self) -> Result<RunState, Error> {
        self.entries.iter().for_each(|(session_id, entry)| {
            println!(
                "session_id={session_id}, command={command}",
                session_id = session_id,
                command = entry.command
            )
        });
        Ok(RunState::Continue)