625 lines
19 KiB
Rust
625 lines
19 KiB
Rust
/// Generated code for SBE package marketdata_sbe
|
|
|
|
/// Imports core rather than std to broaden usable environments.
|
|
extern crate core;
|
|
|
|
/// Result types for error handling
|
|
|
|
/// Errors that may occur during the course of encoding or decoding.
|
|
#[derive(Debug)]
|
|
pub enum CodecErr {
|
|
/// Too few bytes in the byte-slice to read or write the data structure relevant
|
|
/// to the current state of the codec
|
|
NotEnoughBytes,
|
|
|
|
/// Groups and vardata are constrained by the numeric type chosen to represent their
|
|
/// length as well as optional maxima imposed by the schema
|
|
SliceIsLongerThanAllowedBySchema,
|
|
}
|
|
|
|
pub type CodecResult<T> = core::result::Result<T, CodecErr>;
|
|
|
|
/// Scratch Decoder Data Wrapper - codec internal use only
|
|
#[derive(Debug)]
|
|
pub struct ScratchDecoderData<'d> {
|
|
data: &'d [u8],
|
|
pos: usize,
|
|
}
|
|
|
|
impl<'d> ScratchDecoderData<'d> {
|
|
/// Create a struct reference overlaid atop the data buffer
|
|
/// such that the struct's contents directly reflect the buffer.
|
|
/// Advances the `pos` index by the size of the struct in bytes.
|
|
#[inline]
|
|
fn read_type<T>(&mut self, num_bytes: usize) -> CodecResult<&'d T> {
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
let s = self.data[self.pos..end].as_ptr() as *mut T;
|
|
let v: &'d T = unsafe { &*s };
|
|
self.pos = end;
|
|
Ok(v)
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Advances the `pos` index by a set number of bytes.
|
|
#[inline]
|
|
fn skip_bytes(&mut self, num_bytes: usize) -> CodecResult<()> {
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
self.pos = end;
|
|
Ok(())
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Create a slice reference overlaid atop the data buffer
|
|
/// such that the slice's members' contents directly reflect the buffer.
|
|
/// Advances the `pos` index by the size of the slice contents in bytes.
|
|
#[inline]
|
|
fn read_slice<T>(&mut self, count: usize, bytes_per_item: usize) -> CodecResult<&'d [T]> {
|
|
let num_bytes = bytes_per_item * count;
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
let v: &'d [T] = unsafe {
|
|
core::slice::from_raw_parts(self.data[self.pos..end].as_ptr() as *const T, count)
|
|
};
|
|
self.pos = end;
|
|
Ok(v)
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Scratch Encoder Data Wrapper - codec internal use only
|
|
#[derive(Debug)]
|
|
pub struct ScratchEncoderData<'d> {
|
|
data: &'d mut [u8],
|
|
pos: usize,
|
|
}
|
|
|
|
impl<'d> ScratchEncoderData<'d> {
|
|
/// Copy the bytes of a value into the data buffer
|
|
/// Advances the `pos` index to after the newly-written bytes.
|
|
#[inline]
|
|
fn write_type<T>(&mut self, t: &T, num_bytes: usize) -> CodecResult<()> {
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
let source_bytes: &[u8] =
|
|
unsafe { core::slice::from_raw_parts(t as *const T as *const u8, num_bytes) };
|
|
(&mut self.data[self.pos..end]).copy_from_slice(source_bytes);
|
|
self.pos = end;
|
|
Ok(())
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Advances the `pos` index by a set number of bytes.
|
|
#[inline]
|
|
fn skip_bytes(&mut self, num_bytes: usize) -> CodecResult<()> {
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
self.pos = end;
|
|
Ok(())
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Create a struct reference overlaid atop the data buffer
|
|
/// such that changes to the struct directly edit the buffer.
|
|
/// Note that the initial content of the struct's fields may be garbage.
|
|
/// Advances the `pos` index to after the newly-written bytes.
|
|
#[inline]
|
|
fn writable_overlay<T>(&mut self, num_bytes: usize) -> CodecResult<&'d mut T> {
|
|
let end = self.pos + num_bytes;
|
|
if end <= self.data.len() {
|
|
let v: &'d mut T = unsafe {
|
|
let s = self.data.as_ptr().offset(self.pos as isize) as *mut T;
|
|
&mut *s
|
|
};
|
|
self.pos = end;
|
|
Ok(v)
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Copy the bytes of a value into the data buffer at a specific position
|
|
/// Does **not** alter the `pos` index.
|
|
#[inline]
|
|
fn write_at_position<T>(
|
|
&mut self,
|
|
position: usize,
|
|
t: &T,
|
|
num_bytes: usize,
|
|
) -> CodecResult<()> {
|
|
let end = position + num_bytes;
|
|
if end <= self.data.len() {
|
|
let source_bytes: &[u8] =
|
|
unsafe { core::slice::from_raw_parts(t as *const T as *const u8, num_bytes) };
|
|
(&mut self.data[position..end]).copy_from_slice(source_bytes);
|
|
Ok(())
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
/// Create a mutable slice overlaid atop the data buffer directly
|
|
/// such that changes to the slice contents directly edit the buffer
|
|
/// Note that the initial content of the slice's members' fields may be garbage.
|
|
/// Advances the `pos` index to after the region representing the slice.
|
|
#[inline]
|
|
fn writable_slice<T>(
|
|
&mut self,
|
|
count: usize,
|
|
bytes_per_item: usize,
|
|
) -> CodecResult<&'d mut [T]> {
|
|
let end = self.pos + (count * bytes_per_item);
|
|
if end <= self.data.len() {
|
|
let v: &'d mut [T] = unsafe {
|
|
core::slice::from_raw_parts_mut(
|
|
self.data[self.pos..end].as_mut_ptr() as *mut T,
|
|
count,
|
|
)
|
|
};
|
|
self.pos = end;
|
|
Ok(v)
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
|
|
/// Copy the raw bytes of a slice's contents into the data buffer
|
|
/// Does **not** encode the length of the slice explicitly into the buffer.
|
|
/// Advances the `pos` index to after the newly-written slice bytes.
|
|
#[inline]
|
|
fn write_slice_without_count<T>(&mut self, t: &[T], bytes_per_item: usize) -> CodecResult<()> {
|
|
let content_bytes_size = bytes_per_item * t.len();
|
|
let end = self.pos + content_bytes_size;
|
|
if end <= self.data.len() {
|
|
let source_bytes: &[u8] =
|
|
unsafe { core::slice::from_raw_parts(t.as_ptr() as *const u8, content_bytes_size) };
|
|
(&mut self.data[self.pos..end]).copy_from_slice(source_bytes);
|
|
self.pos = end;
|
|
Ok(())
|
|
} else {
|
|
Err(CodecErr::NotEnoughBytes)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Convenience Either enum
|
|
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
|
|
pub enum Either<L, R> {
|
|
Left(L),
|
|
Right(R),
|
|
}
|
|
|
|
/// Enum Side
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[repr(u8)]
|
|
pub enum Side {
|
|
Buy = 0u8,
|
|
Sell = 1u8,
|
|
NullVal = 255u8,
|
|
}
|
|
impl Default for Side {
|
|
fn default() -> Self {
|
|
Side::NullVal
|
|
}
|
|
}
|
|
|
|
/// Enum MsgType
|
|
#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
|
#[repr(u8)]
|
|
pub enum MsgType {
|
|
Trade = 0u8,
|
|
Quote = 1u8,
|
|
NullVal = 255u8,
|
|
}
|
|
impl Default for MsgType {
|
|
fn default() -> Self {
|
|
MsgType::NullVal
|
|
}
|
|
}
|
|
|
|
/// Quote
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct Quote {
|
|
pub price: u64,
|
|
pub size: u32,
|
|
pub flags: u8,
|
|
pub side: Side,
|
|
}
|
|
|
|
impl Quote {}
|
|
|
|
/// Trade
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct Trade {
|
|
pub price: u64,
|
|
pub size: u32,
|
|
}
|
|
|
|
impl Trade {}
|
|
|
|
/// MessageHeader
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct MessageHeader {
|
|
pub block_length: u16,
|
|
pub template_id: u16,
|
|
pub schema_id: u16,
|
|
pub version: u16,
|
|
}
|
|
|
|
impl MessageHeader {}
|
|
|
|
/// GroupSizeEncoding
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct GroupSizeEncoding {
|
|
pub block_length: u16,
|
|
pub num_in_group: u16,
|
|
}
|
|
|
|
impl GroupSizeEncoding {}
|
|
|
|
/// VarAsciiEncoding
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct VarAsciiEncoding {
|
|
pub length: u32,
|
|
pub var_data: u8,
|
|
}
|
|
|
|
impl VarAsciiEncoding {}
|
|
|
|
/// MessageHeader Decoder entry point
|
|
pub fn start_decoding_message_header<'d>(
|
|
data: &'d [u8],
|
|
) -> CodecResult<(&'d MessageHeader, ScratchDecoderData<'d>)> {
|
|
let mut scratch = ScratchDecoderData { data: data, pos: 0 };
|
|
let v = scratch.read_type::<MessageHeader>(8)?;
|
|
Ok((v, scratch))
|
|
}
|
|
|
|
/// MultiMessage Fixed-size Fields (8 bytes)
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct MultiMessageFields {
|
|
pub sequence_number: u64,
|
|
}
|
|
|
|
impl MultiMessageFields {}
|
|
|
|
/// MultiMessage specific Message Header
|
|
#[repr(C, packed)]
|
|
pub struct MultiMessageMessageHeader {
|
|
pub message_header: MessageHeader,
|
|
}
|
|
impl MultiMessageMessageHeader {
|
|
pub const BLOCK_LENGTH: u16 = 8;
|
|
pub const TEMPLATE_ID: u16 = 1;
|
|
pub const SCHEMA_ID: u16 = 1;
|
|
pub const VERSION: u16 = 0;
|
|
}
|
|
impl Default for MultiMessageMessageHeader {
|
|
fn default() -> MultiMessageMessageHeader {
|
|
MultiMessageMessageHeader {
|
|
message_header: MessageHeader {
|
|
block_length: 8u16,
|
|
template_id: 1u16,
|
|
schema_id: 1u16,
|
|
version: 0u16,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Group fixed-field member representations
|
|
#[repr(C, packed)]
|
|
#[derive(Default)]
|
|
pub struct MultiMessageMessagesMember {
|
|
pub timestamp: i64,
|
|
pub msg_type: MsgType,
|
|
pub trade: Trade,
|
|
pub quote: Quote,
|
|
}
|
|
|
|
impl MultiMessageMessagesMember {}
|
|
|
|
/// MultiMessageDecoderDone
|
|
pub struct MultiMessageDecoderDone<'d> {
|
|
scratch: ScratchDecoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageDecoderDone<'d> {
|
|
/// Returns the number of bytes decoded
|
|
pub fn unwrap(self) -> usize {
|
|
self.scratch.pos
|
|
}
|
|
|
|
pub fn wrap(scratch: ScratchDecoderData<'d>) -> MultiMessageDecoderDone<'d> {
|
|
MultiMessageDecoderDone { scratch: scratch }
|
|
}
|
|
}
|
|
|
|
/// symbol variable-length data
|
|
pub struct MultiMessageMessagesSymbolDecoder<'d> {
|
|
parent: MultiMessageMessagesMemberDecoder<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessagesSymbolDecoder<'d> {
|
|
fn wrap(parent: MultiMessageMessagesMemberDecoder<'d>) -> Self {
|
|
MultiMessageMessagesSymbolDecoder { parent: parent }
|
|
}
|
|
pub fn symbol(
|
|
mut self,
|
|
) -> CodecResult<(
|
|
&'d [u8],
|
|
Either<MultiMessageMessagesMemberDecoder<'d>, MultiMessageDecoderDone<'d>>,
|
|
)> {
|
|
let count = *self.parent.scratch.read_type::<u32>(4)?;
|
|
Ok((
|
|
self.parent.scratch.read_slice::<u8>(count as usize, 1)?,
|
|
self.parent.after_member(),
|
|
))
|
|
}
|
|
}
|
|
|
|
/// MultiMessageMessages Decoder for fields and header
|
|
pub struct MultiMessageMessagesMemberDecoder<'d> {
|
|
scratch: ScratchDecoderData<'d>,
|
|
max_index: u16,
|
|
index: u16,
|
|
}
|
|
|
|
impl<'d> MultiMessageMessagesMemberDecoder<'d> {
|
|
fn new(scratch: ScratchDecoderData<'d>, count: u16) -> Self {
|
|
assert!(count > 0u16);
|
|
MultiMessageMessagesMemberDecoder {
|
|
scratch: scratch,
|
|
max_index: count - 1,
|
|
index: 0,
|
|
}
|
|
}
|
|
|
|
pub fn next_messages_member(
|
|
mut self,
|
|
) -> CodecResult<(
|
|
&'d MultiMessageMessagesMember,
|
|
MultiMessageMessagesSymbolDecoder<'d>,
|
|
)> {
|
|
let v = self.scratch.read_type::<MultiMessageMessagesMember>(35)?;
|
|
self.index += 1;
|
|
Ok((v, MultiMessageMessagesSymbolDecoder::wrap(self)))
|
|
}
|
|
#[inline]
|
|
fn after_member(
|
|
self,
|
|
) -> Either<MultiMessageMessagesMemberDecoder<'d>, MultiMessageDecoderDone<'d>> {
|
|
if self.index <= self.max_index {
|
|
Either::Left(self)
|
|
} else {
|
|
Either::Right(MultiMessageDecoderDone::wrap(self.scratch))
|
|
}
|
|
}
|
|
}
|
|
pub struct MultiMessageMessagesHeaderDecoder<'d> {
|
|
scratch: ScratchDecoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessagesHeaderDecoder<'d> {
|
|
fn wrap(scratch: ScratchDecoderData<'d>) -> Self {
|
|
MultiMessageMessagesHeaderDecoder { scratch: scratch }
|
|
}
|
|
pub fn messages_individually(
|
|
mut self,
|
|
) -> CodecResult<Either<MultiMessageMessagesMemberDecoder<'d>, MultiMessageDecoderDone<'d>>>
|
|
{
|
|
let dim = self.scratch.read_type::<GroupSizeEncoding>(4)?;
|
|
if dim.num_in_group > 0 {
|
|
Ok(Either::Left(MultiMessageMessagesMemberDecoder::new(
|
|
self.scratch,
|
|
dim.num_in_group,
|
|
)))
|
|
} else {
|
|
Ok(Either::Right(MultiMessageDecoderDone::wrap(self.scratch)))
|
|
}
|
|
}
|
|
}
|
|
|
|
/// MultiMessage Fixed fields Decoder
|
|
pub struct MultiMessageFieldsDecoder<'d> {
|
|
scratch: ScratchDecoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageFieldsDecoder<'d> {
|
|
pub fn wrap(scratch: ScratchDecoderData<'d>) -> MultiMessageFieldsDecoder<'d> {
|
|
MultiMessageFieldsDecoder { scratch: scratch }
|
|
}
|
|
pub fn multi_message_fields(
|
|
mut self,
|
|
) -> CodecResult<(
|
|
&'d MultiMessageFields,
|
|
MultiMessageMessagesHeaderDecoder<'d>,
|
|
)> {
|
|
let v = self.scratch.read_type::<MultiMessageFields>(8)?;
|
|
Ok((v, MultiMessageMessagesHeaderDecoder::wrap(self.scratch)))
|
|
}
|
|
}
|
|
|
|
/// MultiMessageMessageHeaderDecoder
|
|
pub struct MultiMessageMessageHeaderDecoder<'d> {
|
|
scratch: ScratchDecoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessageHeaderDecoder<'d> {
|
|
pub fn wrap(scratch: ScratchDecoderData<'d>) -> MultiMessageMessageHeaderDecoder<'d> {
|
|
MultiMessageMessageHeaderDecoder { scratch: scratch }
|
|
}
|
|
pub fn header(mut self) -> CodecResult<(&'d MessageHeader, MultiMessageFieldsDecoder<'d>)> {
|
|
let v = self.scratch.read_type::<MessageHeader>(8)?;
|
|
Ok((v, MultiMessageFieldsDecoder::wrap(self.scratch)))
|
|
}
|
|
}
|
|
|
|
/// MultiMessage Decoder entry point
|
|
pub fn start_decoding_multi_message<'d>(data: &'d [u8]) -> MultiMessageMessageHeaderDecoder<'d> {
|
|
MultiMessageMessageHeaderDecoder::wrap(ScratchDecoderData { data: data, pos: 0 })
|
|
}
|
|
|
|
/// MultiMessageEncoderDone
|
|
pub struct MultiMessageEncoderDone<'d> {
|
|
scratch: ScratchEncoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageEncoderDone<'d> {
|
|
/// Returns the number of bytes encoded
|
|
pub fn unwrap(self) -> usize {
|
|
self.scratch.pos
|
|
}
|
|
|
|
pub fn wrap(scratch: ScratchEncoderData<'d>) -> MultiMessageEncoderDone<'d> {
|
|
MultiMessageEncoderDone { scratch: scratch }
|
|
}
|
|
}
|
|
|
|
/// symbol variable-length data
|
|
pub struct MultiMessageMessagesSymbolEncoder<'d> {
|
|
parent: MultiMessageMessagesMemberEncoder<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessagesSymbolEncoder<'d> {
|
|
fn wrap(parent: MultiMessageMessagesMemberEncoder<'d>) -> Self {
|
|
MultiMessageMessagesSymbolEncoder { parent: parent }
|
|
}
|
|
pub fn symbol(mut self, s: &'d [u8]) -> CodecResult<MultiMessageMessagesMemberEncoder> {
|
|
let l = s.len();
|
|
if l > 4294967294 {
|
|
return Err(CodecErr::SliceIsLongerThanAllowedBySchema);
|
|
}
|
|
// Write data length
|
|
self.parent.scratch.write_type::<u32>(&(l as u32), 4)?; // group length
|
|
self.parent.scratch.write_slice_without_count::<u8>(s, 1)?;
|
|
Ok(self.parent)
|
|
}
|
|
}
|
|
|
|
/// MultiMessageMessages Encoder for fields and header
|
|
pub struct MultiMessageMessagesMemberEncoder<'d> {
|
|
scratch: ScratchEncoderData<'d>,
|
|
count_write_pos: usize,
|
|
count: u16,
|
|
}
|
|
|
|
impl<'d> MultiMessageMessagesMemberEncoder<'d> {
|
|
#[inline]
|
|
fn new(scratch: ScratchEncoderData<'d>, count_write_pos: usize) -> Self {
|
|
MultiMessageMessagesMemberEncoder {
|
|
scratch: scratch,
|
|
count_write_pos: count_write_pos,
|
|
count: 0,
|
|
}
|
|
}
|
|
|
|
#[inline]
|
|
pub fn next_messages_member(
|
|
mut self,
|
|
fields: &MultiMessageMessagesMember,
|
|
) -> CodecResult<MultiMessageMessagesSymbolEncoder<'d>> {
|
|
self.scratch
|
|
.write_type::<MultiMessageMessagesMember>(fields, 35)?; // block length
|
|
self.count += 1;
|
|
Ok(MultiMessageMessagesSymbolEncoder::wrap(self))
|
|
}
|
|
#[inline]
|
|
pub fn done_with_messages(mut self) -> CodecResult<MultiMessageEncoderDone<'d>> {
|
|
self.scratch
|
|
.write_at_position::<u16>(self.count_write_pos, &self.count, 2)?;
|
|
Ok(MultiMessageEncoderDone::wrap(self.scratch))
|
|
}
|
|
}
|
|
pub struct MultiMessageMessagesHeaderEncoder<'d> {
|
|
scratch: ScratchEncoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessagesHeaderEncoder<'d> {
|
|
#[inline]
|
|
fn wrap(scratch: ScratchEncoderData<'d>) -> Self {
|
|
MultiMessageMessagesHeaderEncoder { scratch: scratch }
|
|
}
|
|
#[inline]
|
|
pub fn messages_individually(mut self) -> CodecResult<MultiMessageMessagesMemberEncoder<'d>> {
|
|
self.scratch.write_type::<u16>(&35u16, 2)?; // block length
|
|
let count_pos = self.scratch.pos;
|
|
self.scratch.write_type::<u16>(&0, 2)?; // preliminary group member count
|
|
Ok(MultiMessageMessagesMemberEncoder::new(
|
|
self.scratch,
|
|
count_pos,
|
|
))
|
|
}
|
|
}
|
|
|
|
/// MultiMessage Fixed fields Encoder
|
|
pub struct MultiMessageFieldsEncoder<'d> {
|
|
scratch: ScratchEncoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageFieldsEncoder<'d> {
|
|
pub fn wrap(scratch: ScratchEncoderData<'d>) -> MultiMessageFieldsEncoder<'d> {
|
|
MultiMessageFieldsEncoder { scratch: scratch }
|
|
}
|
|
|
|
/// Create a mutable struct reference overlaid atop the data buffer
|
|
/// such that changes to the struct directly edit the buffer.
|
|
/// Note that the initial content of the struct's fields may be garbage.
|
|
pub fn multi_message_fields(
|
|
mut self,
|
|
) -> CodecResult<(
|
|
&'d mut MultiMessageFields,
|
|
MultiMessageMessagesHeaderEncoder<'d>,
|
|
)> {
|
|
let v = self.scratch.writable_overlay::<MultiMessageFields>(8 + 0)?;
|
|
Ok((v, MultiMessageMessagesHeaderEncoder::wrap(self.scratch)))
|
|
}
|
|
|
|
/// Copy the bytes of a value into the data buffer
|
|
pub fn multi_message_fields_copy(
|
|
mut self,
|
|
t: &MultiMessageFields,
|
|
) -> CodecResult<MultiMessageMessagesHeaderEncoder<'d>> {
|
|
self.scratch.write_type::<MultiMessageFields>(t, 8)?;
|
|
Ok(MultiMessageMessagesHeaderEncoder::wrap(self.scratch))
|
|
}
|
|
}
|
|
|
|
/// MultiMessageMessageHeaderEncoder
|
|
pub struct MultiMessageMessageHeaderEncoder<'d> {
|
|
scratch: ScratchEncoderData<'d>,
|
|
}
|
|
impl<'d> MultiMessageMessageHeaderEncoder<'d> {
|
|
pub fn wrap(scratch: ScratchEncoderData<'d>) -> MultiMessageMessageHeaderEncoder<'d> {
|
|
MultiMessageMessageHeaderEncoder { scratch: scratch }
|
|
}
|
|
|
|
/// Create a mutable struct reference overlaid atop the data buffer
|
|
/// such that changes to the struct directly edit the buffer.
|
|
/// Note that the initial content of the struct's fields may be garbage.
|
|
pub fn header(mut self) -> CodecResult<(&'d mut MessageHeader, MultiMessageFieldsEncoder<'d>)> {
|
|
let v = self.scratch.writable_overlay::<MessageHeader>(8 + 0)?;
|
|
Ok((v, MultiMessageFieldsEncoder::wrap(self.scratch)))
|
|
}
|
|
|
|
/// Copy the bytes of a value into the data buffer
|
|
pub fn header_copy(mut self, t: &MessageHeader) -> CodecResult<MultiMessageFieldsEncoder<'d>> {
|
|
self.scratch.write_type::<MessageHeader>(t, 8)?;
|
|
Ok(MultiMessageFieldsEncoder::wrap(self.scratch))
|
|
}
|
|
}
|
|
|
|
/// MultiMessage Encoder entry point
|
|
pub fn start_encoding_multi_message<'d>(
|
|
data: &'d mut [u8],
|
|
) -> MultiMessageMessageHeaderEncoder<'d> {
|
|
MultiMessageMessageHeaderEncoder::wrap(ScratchEncoderData { data: data, pos: 0 })
|
|
}
|