pub use decoder::PingResponseDecoder;
pub use encoder::PingResponseEncoder;
use super::*;
pub use super::{SBE_SCHEMA_ID, SBE_SCHEMA_VERSION, SBE_SEMANTIC_VERSION};
pub const SBE_BLOCK_LENGTH: u16 = 0;
pub const SBE_TEMPLATE_ID: u16 = 101;
pub mod encoder {
use message_header_codec::*;
use super::*;
#[derive(Debug, Default)]
pub struct PingResponseEncoder<'a> {
buf: WriteBuf<'a>,
initial_offset: usize,
offset: usize,
limit: usize,
}
impl<'a> Writer<'a> for PingResponseEncoder<'a> {
#[inline]
fn get_buf_mut(&mut self) -> &mut WriteBuf<'a> {
&mut self.buf
}
}
impl<'a> Encoder<'a> for PingResponseEncoder<'a> {
#[inline]
fn get_limit(&self) -> usize {
self.limit
}
#[inline]
fn set_limit(&mut self, limit: usize) {
self.limit = limit;
}
}
impl<'a> PingResponseEncoder<'a> {
pub fn wrap(mut self, buf: WriteBuf<'a>, offset: usize) -> Self {
let limit = offset + SBE_BLOCK_LENGTH as usize;
self.buf = buf;
self.initial_offset = offset;
self.offset = offset;
self.limit = limit;
self
}
#[inline]
pub fn encoded_length(&self) -> usize {
self.limit - self.offset
}
pub fn header(self, offset: usize) -> MessageHeaderEncoder<Self> {
let mut header = MessageHeaderEncoder::default().wrap(self, offset);
header.block_length(SBE_BLOCK_LENGTH);
header.template_id(SBE_TEMPLATE_ID);
header.schema_id(SBE_SCHEMA_ID);
header.version(SBE_SCHEMA_VERSION);
header
}
}
}
pub mod decoder {
use message_header_codec::*;
use super::*;
#[derive(Clone, Copy, Debug, Default)]
pub struct PingResponseDecoder<'a> {
buf: ReadBuf<'a>,
initial_offset: usize,
offset: usize,
limit: usize,
pub acting_block_length: u16,
pub acting_version: u16,
}
impl ActingVersion for PingResponseDecoder<'_> {
#[inline]
fn acting_version(&self) -> u16 {
self.acting_version
}
}
impl<'a> Reader<'a> for PingResponseDecoder<'a> {
#[inline]
fn get_buf(&self) -> &ReadBuf<'a> {
&self.buf
}
}
impl<'a> Decoder<'a> for PingResponseDecoder<'a> {
#[inline]
fn get_limit(&self) -> usize {
self.limit
}
#[inline]
fn set_limit(&mut self, limit: usize) {
self.limit = limit;
}
}
impl<'a> PingResponseDecoder<'a> {
pub fn wrap(
mut self,
buf: ReadBuf<'a>,
offset: usize,
acting_block_length: u16,
acting_version: u16,
) -> Self {
let limit = offset + acting_block_length as usize;
self.buf = buf;
self.initial_offset = offset;
self.offset = offset;
self.limit = limit;
self.acting_block_length = acting_block_length;
self.acting_version = acting_version;
self
}
#[inline]
pub fn encoded_length(&self) -> usize {
self.limit - self.offset
}
pub fn header(self, mut header: MessageHeaderDecoder<ReadBuf<'a>>, offset: usize) -> Self {
debug_assert_eq!(SBE_TEMPLATE_ID, header.template_id());
let acting_block_length = header.block_length();
let acting_version = header.version();
self.wrap(
header.parent().unwrap(),
offset + message_header_codec::ENCODED_LENGTH,
acting_block_length,
acting_version,
)
}
}
}