wtx 0.45.0

A collection of different transport implementations and related tools focused primarily on web technologies.
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
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97

macro_rules! impl_primitive {
  ($instance:expr, [$($elem:ident),+], $pg_ty:expr, $ty0:ident $(, $ty1:ident)?) => {
    impl<E> Decode<'_, Postgres<E>> for $ty0
    where
      E: From<crate::Error>,
    {
      #[inline]
      fn decode(dw: &mut DecodeWrapper<'_, '_>) -> Result<Self, E> {
        if let &[$($elem,)+] = dw.bytes() {
          let array = [$($elem),+];
          #[allow(unused_assignments, unused_mut, reason = "depends on macro")]
          let mut num = <Self>::from_be_bytes(array);
          $({
            let signed = $ty1::from_be_bytes(array);
            num = signed.try_into().map_err(crate::Error::from)?;
          })?
          return Ok(num);
        }
        Err(E::from(DatabaseError::UnexpectedBufferSize {
          expected: Usize::from(size_of::<$ty0>()).into_u64().try_into().unwrap_or(u32::MAX),
          received: Usize::from(dw.bytes().len()).into_u64().try_into().unwrap_or(u32::MAX)
        }.into()))
      }
    }

    impl<E> Encode<Postgres<E>> for $ty0
    where
      E: From<crate::Error>,
    {
      #[inline]
      fn encode(&self, ew: &mut EncodeWrapper<'_, '_>) -> Result<(), E> {
        ew.buffer().extend_from_slice(&self.to_be_bytes())?;
        Ok(())
      }
    }

    impl<E> Typed<Postgres<E>> for $ty0
    where
      E: From<crate::Error>
    {
      #[inline]
      fn runtime_ty(&self) -> Option<Ty> {
        <Self as Typed<Postgres<E>>>::static_ty()
      }

      #[inline]
      fn static_ty() -> Option<Ty> {
        Some($pg_ty)
      }
    }

    test!($ty0, $ty0, $instance);
  }
}

macro_rules! kani {
  ($name:ident, $ty:ty) => {
    #[cfg(kani)]
    #[kani::proof]
    fn $name(instance: $ty) {
      let mut vec = &mut crate::misc::FilledBuffer::_new();
      {
        let mut sw = crate::misc::FilledBufferWriter::new(0, &mut vec);
        let mut ew = EncodeValue::new(&mut sw);
        Encode::<Postgres<crate::Error>>::encode(&instance, &mut ew).unwrap();
        let decoded: $ty = Decode::<Postgres<crate::Error>>::decode(&DecodeValue::new(
          ew.sw()._curr_bytes(),
          crate::database::client::postgres::Ty::Any,
        ))
        .unwrap();
        assert_eq!(instance, decoded);
      }
      vec._clear();
    }
  };
}

macro_rules! test {
  ($name:ident, $ty:ty, $instance:expr) => {
    #[cfg(test)]
    #[test]
    fn $name() {
      let vec = &mut crate::misc::FilledBuffer::default();
      let mut sw = crate::misc::SuffixWriter::new(0, vec.vector_mut());
      let mut ew = EncodeWrapper::new(&mut sw);
      let instance: $ty = $instance;
      Encode::<Postgres<crate::Error>>::encode(&instance, &mut ew).unwrap();
      let decoded: $ty = Decode::<Postgres<crate::Error>>::decode(&mut DecodeWrapper::new(
        ew.buffer().curr_bytes(),
        "",
        crate::database::client::postgres::Ty::Any,
      ))
      .unwrap();
      assert_eq!(instance, decoded);
    }
  };
}