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
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
pub mod buffer;
pub mod prost;
pub mod serde_codec;
use std::io;
pub use self::buffer::{DecodeBuf, EncodeBuf};
use crate::status::Status;
pub trait Codec {
/// The encodable message.
type Encode: Send + 'static;
/// The decodable message.
type Decode: Send + 'static;
/// The encoder that can encode a message.
type Encoder: Encoder<Item = Self::Encode, Error = Status> + Send + 'static;
/// The encoder that can decode a message.
type Decoder: Decoder<Item = Self::Decode, Error = Status> + Send + 'static;
/// Fetch the encoder.
fn encoder(&mut self) -> Self::Encoder;
/// Fetch the decoder.
fn decoder(&mut self) -> Self::Decoder;
}
/// Encodes gRPC message types
pub trait Encoder {
/// The type that is encoded.
type Item;
/// The type of encoding errors.
///
/// The type of unrecoverable frame encoding errors.
type Error: From<io::Error>;
/// Encodes a message into the provided buffer.
fn encode(&mut self, item: Self::Item, dst: &mut EncodeBuf<'_>) -> Result<(), Self::Error>;
}
/// Decodes gRPC message types
pub trait Decoder {
/// The type that is decoded.
type Item;
/// The type of unrecoverable frame decoding errors.
type Error: From<io::Error>;
/// Decode a message from the buffer.
///
/// The buffer will contain exactly the bytes of a full message. There
/// is no need to get the length from the bytes, gRPC framing is handled
/// for you.
fn decode(&mut self, src: &mut DecodeBuf<'_>) -> Result<Option<Self::Item>, Self::Error>;
}