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

use crate::{
  asn1::{Asn1DecodeWrapper, Asn1EncodeWrapper, Len, SequenceBuffer},
  codec::{Decode, DecodeWrapper, Encode, EncodeWrapper, GenericCodec},
  collection::TryExtend,
  misc::{Lease, SingleTypeStorage},
};

/// Optional field helper that delegates operations to the inner element, if any.
#[derive(Debug, Default, PartialEq)]
pub struct Opt<T>(
  /// Optional element
  pub T,
);

impl<'de, T> Opt<Option<T>>
where
  T: Decode<'de, GenericCodec<Asn1DecodeWrapper, ()>>,
{
  /// The decoding of an optional object requires the injection of a tag.
  pub fn decode(dw: &mut DecodeWrapper<'de, Asn1DecodeWrapper>, tag: u8) -> crate::Result<Self> {
    if dw.bytes.first().copied() == Some(tag) {
      dw.decode_aux.tag = Some(tag);
      let rslt = T::decode(dw);
      dw.decode_aux.tag = None;
      Ok(Self(Some(rslt?)))
    } else {
      Ok(Self(None))
    }
  }
}

impl<'de, B, E> Opt<Option<B>>
where
  B: Default + SingleTypeStorage<Item = E> + TryExtend<[E; 1]>,
  E: Decode<'de, GenericCodec<Asn1DecodeWrapper, ()>>,
{
  /// The decoding of an optional collection requires the injection of a tag.
  pub fn decode_seq(
    dw: &mut DecodeWrapper<'de, Asn1DecodeWrapper>,
    tag: u8,
  ) -> crate::Result<Self> {
    if dw.bytes.first().copied() == Some(tag) {
      Ok(Self(Some(SequenceBuffer::<B>::decode(dw, tag)?.0)))
    } else {
      Ok(Self(None))
    }
  }
}

impl<E, T> Opt<T>
where
  T: Lease<Option<E>> + SingleTypeStorage<Item = E>,
  E: Encode<GenericCodec<(), Asn1EncodeWrapper>>,
{
  /// The encoding of an optional object requires the injection of a tag.
  pub fn encode(
    &self,
    ew: &mut EncodeWrapper<'_, Asn1EncodeWrapper>,
    tag: u8,
  ) -> crate::Result<()> {
    if let Some(elem) = self.0.lease() {
      ew.encode_aux.tag = Some(tag);
      let rslt = elem.encode(ew);
      ew.encode_aux.tag = None;
      rslt?;
    }
    Ok(())
  }
}

impl<B, E, T> Opt<T>
where
  T: Lease<Option<B>> + SingleTypeStorage<Item = B>,
  B: Lease<[E]> + SingleTypeStorage<Item = E>,
  E: Encode<GenericCodec<(), Asn1EncodeWrapper>>,
{
  /// The encoding of an optional object requires the injection of a tag and the guessing of
  /// its entire length for performance reasons.
  pub fn encode_seq(
    &self,
    ew: &mut EncodeWrapper<'_, Asn1EncodeWrapper>,
    len_guess: Len,
    tag: u8,
  ) -> crate::Result<()> {
    if let Some(elem) = self.0.lease() {
      SequenceBuffer(elem).encode(ew, len_guess, tag)?;
    }
    Ok(())
  }
}