ih 0.1.15

interface proto for hpc
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78

use std::{borrow::Borrow, fmt};

use pb_jelly::Message;
use sonic_rs::{Serialize, to_string};

use crate::{Code, CodeBody, Json, State};

impl fmt::Display for Json {
  fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    writeln!(f, "Json {}", self.inner)?;
    Ok(())
  }
}

pub fn json() -> Json {
  Default::default()
}

impl std::error::Error for Json {}

impl Json {
  pub fn set<V: Serialize>(&mut self, key: impl AsRef<str>, val: impl Borrow<V>) {
    if let Ok(key) = xerr::ok!(to_string(key.as_ref())) {
      if let Ok(val) = xerr::ok!(to_string(val.borrow())) {
        let inner = &mut self.inner;
        inner.push(if inner.is_empty() { '{' } else { ',' });
        self.inner += &key;
        self.inner.push(':');
        self.inner += &val;
      }
    }
  }

  pub fn throw(&mut self) -> anyhow::Result<()> {
    if self.inner.is_empty() {
      return Ok(());
    }
    let mut err = Json {
      inner: std::mem::take(&mut self.inner),
    };
    err.inner.push('}');
    Err(err.into())
  }
}

// impl<K: AsRef<str>, V: Serialize> FnMut<(K, V)> for Json {
//   extern "rust-call" fn call_mut(&mut self, args: (K, V)) -> Self::Output {
//     self.set(args.0, args.1);
//   }
// }
//
// impl<K: AsRef<str>, V: Serialize> FnOnce<(K, V)> for Json {
//   type Output = ();
//   extern "rust-call" fn call_once(self, _args: (K, V)) -> Self::Output {
//     unimplemented!()
//   }
// }
//
//
// impl FnMut<()> for Json {
//   extern "rust-call" fn call_mut(&mut self, args: ()) -> Self::Output {
//     if self.inner.is_empty() {
//       return Ok(());
//     }
//     let mut err = Json {
//       inner: std::mem::take(&mut self.inner),
//     };
//     err.inner.push('}');
//     Err(err.into())
//   }
// }
//
// impl FnOnce<()> for Json {
//   type Output = anyhow::Result<()>;
//   extern "rust-call" fn call_once(self, _args: ()) -> Self::Output {
//     unimplemented!()
//   }
// }