rapids 0.4.0

A WIP implementation of https://github.com/replit/river in rust
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
98
99
100
101
102
103
104
105
106
107

#![allow(missing_docs)] // TODO: finish documentation and remove this

//! # Built-in codecs
//! - JSON: [`NaiveCodec`]
//! - MessagePack: [`BinaryCodec`]
//!
//! ## What does a codec do?
//! Codecs are used to transform messages into and from their
//! over the wire representation.

use anyhow::Result;
use serde::{Deserialize, Serialize};

#[allow(clippy::missing_errors_doc)]
pub trait Codec: Send + Sync + Copy {
    fn decode_slice<'a, T>(&self, v: &'a [u8]) -> Result<T>
    where
        T: Deserialize<'a>;

    fn encode_to_vec<T>(&self, value: &T) -> Result<Vec<u8>>
    where
        T: ?Sized + Serialize;
}

/// Basic codec that encodes messages as JSON using [`serde_json`]
#[derive(Clone, Copy)]
pub struct NaiveCodec {}

impl Codec for NaiveCodec {
    fn decode_slice<'a, T>(&self, v: &'a [u8]) -> Result<T>
    where
        T: Deserialize<'a>,
    {
        Ok(serde_json::from_slice(v)?)
    }

    fn encode_to_vec<T>(&self, value: &T) -> Result<Vec<u8>>
    where
        T: ?Sized + Serialize,
    {
        Ok(serde_json::to_vec(value)?)
    }
}

/// Codec that encodes messages into MessagePack using [`rmp_serde`]
#[derive(Clone, Copy)]
pub struct BinaryCodec {}

impl Codec for BinaryCodec {
    fn decode_slice<'a, T>(&self, v: &'a [u8]) -> Result<T>
    where
        T: Deserialize<'a>,
    {
        Ok(rmp_serde::from_slice(v)?)
    }

    fn encode_to_vec<T>(&self, value: &T) -> Result<Vec<u8>>
    where
        T: ?Sized + Serialize,
    {
        // This is an awful solution but rmp_serde doesn't encode enum's correctly on its own.
        // TODO: better solution? report bug to rmp_serde devs?
        let val: serde_json::Value = serde_json::from_slice(&serde_json::to_vec(value)?)?;
        Ok(rmp_serde::to_vec(&val)?)
    }
}

/// An enum that represents any built-in codec
///
/// ⚠️ This enum will likely be deprecated and removed in the
/// future.
///
/// # Why does this exist?
/// The [`Codec`] trait does not supporting dyn boxing, so this
/// enum is provided as a convenience for codec-agnostic purposes
/// that cannot use a generic.
///
/// Use of this enum is not recommended for other libraries
/// because 3rd party codec implementations don't work with
/// DynCodec.
#[derive(Clone, Copy)]
pub enum DynCodec {
    Binary(BinaryCodec),
    Naive(NaiveCodec),
}

impl Codec for DynCodec {
    fn decode_slice<'a, T>(&self, v: &'a [u8]) -> Result<T>
    where
        T: Deserialize<'a>,
    {
        match self {
            DynCodec::Binary(binary_codec) => binary_codec.decode_slice(v),
            DynCodec::Naive(naive_codec) => naive_codec.decode_slice(v),
        }
    }

    fn encode_to_vec<T>(&self, value: &T) -> Result<Vec<u8>>
    where
        T: ?Sized + Serialize,
    {
        match self {
            DynCodec::Binary(binary_codec) => binary_codec.encode_to_vec(value),
            DynCodec::Naive(naive_codec) => naive_codec.encode_to_vec(value),
        }
    }
}