#![allow(unused_assignments, unused_variables, unreachable_patterns)]
use super::*;
use crate::codec::{self, decode_format_code, decode_list_header, Decode, DecodeFormatted, Encode};
use crate::errors::AmqpParseError;
use bytes::{BufMut, Bytes, BytesMut};
use bytestring::ByteString;
use derive_more::From;
use std::u8;
use uuid::Uuid;
#[derive(Clone, Debug, PartialEq, From)]
pub enum Frame {
Open(Open),
Begin(Begin),
Attach(Attach),
Flow(Flow),
Transfer(Transfer),
Disposition(Disposition),
Detach(Detach),
End(End),
Close(Close),
Empty,
}
impl Frame {
pub fn name(&self) -> &'static str {
match self {
Frame::Open(_) => "Open",
Frame::Begin(_) => "Begin",
Frame::Attach(_) => "Attach",
Frame::Flow(_) => "Flow",
Frame::Transfer(_) => "Transfer",
Frame::Disposition(_) => "Disposition",
Frame::Detach(_) => "Detach",
Frame::End(_) => "End",
Frame::Close(_) => "Close",
Frame::Empty => "Empty",
}
}
}
impl Decode for Frame {
fn decode(input: &[u8]) -> Result<(&[u8], Self), AmqpParseError> {
if input.is_empty() {
Ok((input, Frame::Empty))
} else {
let (input, fmt) = decode_format_code(input)?;
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
match descriptor {
Descriptor::Ulong(16) => decode_open_inner(input).map(|(i, r)| (i, Frame::Open(r))),
Descriptor::Ulong(17) => {
decode_begin_inner(input).map(|(i, r)| (i, Frame::Begin(r)))
}
Descriptor::Ulong(18) => {
decode_attach_inner(input).map(|(i, r)| (i, Frame::Attach(r)))
}
Descriptor::Ulong(19) => decode_flow_inner(input).map(|(i, r)| (i, Frame::Flow(r))),
Descriptor::Ulong(20) => {
decode_transfer_inner(input).map(|(i, r)| (i, Frame::Transfer(r)))
}
Descriptor::Ulong(21) => {
decode_disposition_inner(input).map(|(i, r)| (i, Frame::Disposition(r)))
}
Descriptor::Ulong(22) => {
decode_detach_inner(input).map(|(i, r)| (i, Frame::Detach(r)))
}
Descriptor::Ulong(23) => decode_end_inner(input).map(|(i, r)| (i, Frame::End(r))),
Descriptor::Ulong(24) => {
decode_close_inner(input).map(|(i, r)| (i, Frame::Close(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:open:list" => {
decode_open_inner(input).map(|(i, r)| (i, Frame::Open(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:begin:list" => {
decode_begin_inner(input).map(|(i, r)| (i, Frame::Begin(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:attach:list" => {
decode_attach_inner(input).map(|(i, r)| (i, Frame::Attach(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:flow:list" => {
decode_flow_inner(input).map(|(i, r)| (i, Frame::Flow(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:transfer:list" => {
decode_transfer_inner(input).map(|(i, r)| (i, Frame::Transfer(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:disposition:list" => {
decode_disposition_inner(input).map(|(i, r)| (i, Frame::Disposition(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:detach:list" => {
decode_detach_inner(input).map(|(i, r)| (i, Frame::Detach(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:end:list" => {
decode_end_inner(input).map(|(i, r)| (i, Frame::End(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:close:list" => {
decode_close_inner(input).map(|(i, r)| (i, Frame::Close(r)))
}
_ => Err(AmqpParseError::InvalidDescriptor(descriptor)),
}
}
}
}
impl Encode for Frame {
fn encoded_size(&self) -> usize {
match *self {
Frame::Open(ref v) => encoded_size_open_inner(v),
Frame::Begin(ref v) => encoded_size_begin_inner(v),
Frame::Attach(ref v) => encoded_size_attach_inner(v),
Frame::Flow(ref v) => encoded_size_flow_inner(v),
Frame::Transfer(ref v) => encoded_size_transfer_inner(v),
Frame::Disposition(ref v) => encoded_size_disposition_inner(v),
Frame::Detach(ref v) => encoded_size_detach_inner(v),
Frame::End(ref v) => encoded_size_end_inner(v),
Frame::Close(ref v) => encoded_size_close_inner(v),
Frame::Empty => 0,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
Frame::Open(ref v) => encode_open_inner(v, buf),
Frame::Begin(ref v) => encode_begin_inner(v, buf),
Frame::Attach(ref v) => encode_attach_inner(v, buf),
Frame::Flow(ref v) => encode_flow_inner(v, buf),
Frame::Transfer(ref v) => encode_transfer_inner(v, buf),
Frame::Disposition(ref v) => encode_disposition_inner(v, buf),
Frame::Detach(ref v) => encode_detach_inner(v, buf),
Frame::End(ref v) => encode_end_inner(v, buf),
Frame::Close(ref v) => encode_close_inner(v, buf),
Frame::Empty => (),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum DeliveryState {
Received(Received),
Accepted(Accepted),
Rejected(Rejected),
Released(Released),
Modified(Modified),
}
impl DecodeFormatted for DeliveryState {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
match descriptor {
Descriptor::Ulong(35) => {
decode_received_inner(input).map(|(i, r)| (i, DeliveryState::Received(r)))
}
Descriptor::Ulong(36) => {
decode_accepted_inner(input).map(|(i, r)| (i, DeliveryState::Accepted(r)))
}
Descriptor::Ulong(37) => {
decode_rejected_inner(input).map(|(i, r)| (i, DeliveryState::Rejected(r)))
}
Descriptor::Ulong(38) => {
decode_released_inner(input).map(|(i, r)| (i, DeliveryState::Released(r)))
}
Descriptor::Ulong(39) => {
decode_modified_inner(input).map(|(i, r)| (i, DeliveryState::Modified(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:received:list" => {
decode_received_inner(input).map(|(i, r)| (i, DeliveryState::Received(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:accepted:list" => {
decode_accepted_inner(input).map(|(i, r)| (i, DeliveryState::Accepted(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:rejected:list" => {
decode_rejected_inner(input).map(|(i, r)| (i, DeliveryState::Rejected(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:released:list" => {
decode_released_inner(input).map(|(i, r)| (i, DeliveryState::Released(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:modified:list" => {
decode_modified_inner(input).map(|(i, r)| (i, DeliveryState::Modified(r)))
}
_ => Err(AmqpParseError::InvalidDescriptor(descriptor)),
}
}
}
impl Encode for DeliveryState {
fn encoded_size(&self) -> usize {
match *self {
DeliveryState::Received(ref v) => encoded_size_received_inner(v),
DeliveryState::Accepted(ref v) => encoded_size_accepted_inner(v),
DeliveryState::Rejected(ref v) => encoded_size_rejected_inner(v),
DeliveryState::Released(ref v) => encoded_size_released_inner(v),
DeliveryState::Modified(ref v) => encoded_size_modified_inner(v),
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
DeliveryState::Received(ref v) => encode_received_inner(v, buf),
DeliveryState::Accepted(ref v) => encode_accepted_inner(v, buf),
DeliveryState::Rejected(ref v) => encode_rejected_inner(v, buf),
DeliveryState::Released(ref v) => encode_released_inner(v, buf),
DeliveryState::Modified(ref v) => encode_modified_inner(v, buf),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum SaslFrameBody {
SaslMechanisms(SaslMechanisms),
SaslInit(SaslInit),
SaslChallenge(SaslChallenge),
SaslResponse(SaslResponse),
SaslOutcome(SaslOutcome),
}
impl DecodeFormatted for SaslFrameBody {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
match descriptor {
Descriptor::Ulong(64) => decode_sasl_mechanisms_inner(input)
.map(|(i, r)| (i, SaslFrameBody::SaslMechanisms(r))),
Descriptor::Ulong(65) => {
decode_sasl_init_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslInit(r)))
}
Descriptor::Ulong(66) => decode_sasl_challenge_inner(input)
.map(|(i, r)| (i, SaslFrameBody::SaslChallenge(r))),
Descriptor::Ulong(67) => {
decode_sasl_response_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslResponse(r)))
}
Descriptor::Ulong(68) => {
decode_sasl_outcome_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslOutcome(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:sasl-mechanisms:list" => {
decode_sasl_mechanisms_inner(input)
.map(|(i, r)| (i, SaslFrameBody::SaslMechanisms(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:sasl-init:list" => {
decode_sasl_init_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslInit(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:sasl-challenge:list" => {
decode_sasl_challenge_inner(input)
.map(|(i, r)| (i, SaslFrameBody::SaslChallenge(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:sasl-response:list" => {
decode_sasl_response_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslResponse(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:sasl-outcome:list" => {
decode_sasl_outcome_inner(input).map(|(i, r)| (i, SaslFrameBody::SaslOutcome(r)))
}
_ => Err(AmqpParseError::InvalidDescriptor(descriptor)),
}
}
}
impl Encode for SaslFrameBody {
fn encoded_size(&self) -> usize {
match *self {
SaslFrameBody::SaslMechanisms(ref v) => encoded_size_sasl_mechanisms_inner(v),
SaslFrameBody::SaslInit(ref v) => encoded_size_sasl_init_inner(v),
SaslFrameBody::SaslChallenge(ref v) => encoded_size_sasl_challenge_inner(v),
SaslFrameBody::SaslResponse(ref v) => encoded_size_sasl_response_inner(v),
SaslFrameBody::SaslOutcome(ref v) => encoded_size_sasl_outcome_inner(v),
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
SaslFrameBody::SaslMechanisms(ref v) => encode_sasl_mechanisms_inner(v, buf),
SaslFrameBody::SaslInit(ref v) => encode_sasl_init_inner(v, buf),
SaslFrameBody::SaslChallenge(ref v) => encode_sasl_challenge_inner(v, buf),
SaslFrameBody::SaslResponse(ref v) => encode_sasl_response_inner(v, buf),
SaslFrameBody::SaslOutcome(ref v) => encode_sasl_outcome_inner(v, buf),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Section {
Header(Header),
DeliveryAnnotations(DeliveryAnnotations),
MessageAnnotations(MessageAnnotations),
ApplicationProperties(ApplicationProperties),
Data(Data),
AmqpSequence(AmqpSequence),
AmqpValue(AmqpValue),
Footer(Footer),
Properties(Properties),
}
impl DecodeFormatted for Section {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
match descriptor {
Descriptor::Ulong(112) => {
decode_header_inner(input).map(|(i, r)| (i, Section::Header(r)))
}
Descriptor::Ulong(113) => decode_delivery_annotations_inner(input)
.map(|(i, r)| (i, Section::DeliveryAnnotations(r))),
Descriptor::Ulong(114) => decode_message_annotations_inner(input)
.map(|(i, r)| (i, Section::MessageAnnotations(r))),
Descriptor::Ulong(116) => decode_application_properties_inner(input)
.map(|(i, r)| (i, Section::ApplicationProperties(r))),
Descriptor::Ulong(117) => decode_data_inner(input).map(|(i, r)| (i, Section::Data(r))),
Descriptor::Ulong(118) => {
decode_amqp_sequence_inner(input).map(|(i, r)| (i, Section::AmqpSequence(r)))
}
Descriptor::Ulong(119) => {
decode_amqp_value_inner(input).map(|(i, r)| (i, Section::AmqpValue(r)))
}
Descriptor::Ulong(120) => {
decode_footer_inner(input).map(|(i, r)| (i, Section::Footer(r)))
}
Descriptor::Ulong(115) => {
decode_properties_inner(input).map(|(i, r)| (i, Section::Properties(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:header:list" => {
decode_header_inner(input).map(|(i, r)| (i, Section::Header(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:delivery-annotations:map" => {
decode_delivery_annotations_inner(input)
.map(|(i, r)| (i, Section::DeliveryAnnotations(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:message-annotations:map" => {
decode_message_annotations_inner(input)
.map(|(i, r)| (i, Section::MessageAnnotations(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:application-properties:map" => {
decode_application_properties_inner(input)
.map(|(i, r)| (i, Section::ApplicationProperties(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:data:binary" => {
decode_data_inner(input).map(|(i, r)| (i, Section::Data(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:amqp-sequence:list" => {
decode_amqp_sequence_inner(input).map(|(i, r)| (i, Section::AmqpSequence(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:amqp-value:*" => {
decode_amqp_value_inner(input).map(|(i, r)| (i, Section::AmqpValue(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:footer:map" => {
decode_footer_inner(input).map(|(i, r)| (i, Section::Footer(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:properties:list" => {
decode_properties_inner(input).map(|(i, r)| (i, Section::Properties(r)))
}
_ => Err(AmqpParseError::InvalidDescriptor(descriptor)),
}
}
}
impl Encode for Section {
fn encoded_size(&self) -> usize {
match *self {
Section::Header(ref v) => encoded_size_header_inner(v),
Section::DeliveryAnnotations(ref v) => encoded_size_delivery_annotations_inner(v),
Section::MessageAnnotations(ref v) => encoded_size_message_annotations_inner(v),
Section::ApplicationProperties(ref v) => encoded_size_application_properties_inner(v),
Section::Data(ref v) => encoded_size_data_inner(v),
Section::AmqpSequence(ref v) => encoded_size_amqp_sequence_inner(v),
Section::AmqpValue(ref v) => encoded_size_amqp_value_inner(v),
Section::Footer(ref v) => encoded_size_footer_inner(v),
Section::Properties(ref v) => encoded_size_properties_inner(v),
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
Section::Header(ref v) => encode_header_inner(v, buf),
Section::DeliveryAnnotations(ref v) => encode_delivery_annotations_inner(v, buf),
Section::MessageAnnotations(ref v) => encode_message_annotations_inner(v, buf),
Section::ApplicationProperties(ref v) => encode_application_properties_inner(v, buf),
Section::Data(ref v) => encode_data_inner(v, buf),
Section::AmqpSequence(ref v) => encode_amqp_sequence_inner(v, buf),
Section::AmqpValue(ref v) => encode_amqp_value_inner(v, buf),
Section::Footer(ref v) => encode_footer_inner(v, buf),
Section::Properties(ref v) => encode_properties_inner(v, buf),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum Outcome {
Accepted(Accepted),
Rejected(Rejected),
Released(Released),
Modified(Modified),
}
impl DecodeFormatted for Outcome {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
match descriptor {
Descriptor::Ulong(36) => {
decode_accepted_inner(input).map(|(i, r)| (i, Outcome::Accepted(r)))
}
Descriptor::Ulong(37) => {
decode_rejected_inner(input).map(|(i, r)| (i, Outcome::Rejected(r)))
}
Descriptor::Ulong(38) => {
decode_released_inner(input).map(|(i, r)| (i, Outcome::Released(r)))
}
Descriptor::Ulong(39) => {
decode_modified_inner(input).map(|(i, r)| (i, Outcome::Modified(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:accepted:list" => {
decode_accepted_inner(input).map(|(i, r)| (i, Outcome::Accepted(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:rejected:list" => {
decode_rejected_inner(input).map(|(i, r)| (i, Outcome::Rejected(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:released:list" => {
decode_released_inner(input).map(|(i, r)| (i, Outcome::Released(r)))
}
Descriptor::Symbol(ref a) if a.as_str() == "amqp:modified:list" => {
decode_modified_inner(input).map(|(i, r)| (i, Outcome::Modified(r)))
}
_ => Err(AmqpParseError::InvalidDescriptor(descriptor)),
}
}
}
impl Encode for Outcome {
fn encoded_size(&self) -> usize {
match *self {
Outcome::Accepted(ref v) => encoded_size_accepted_inner(v),
Outcome::Rejected(ref v) => encoded_size_rejected_inner(v),
Outcome::Released(ref v) => encoded_size_released_inner(v),
Outcome::Modified(ref v) => encoded_size_modified_inner(v),
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
Outcome::Accepted(ref v) => encode_accepted_inner(v, buf),
Outcome::Rejected(ref v) => encode_rejected_inner(v, buf),
Outcome::Released(ref v) => encode_released_inner(v, buf),
Outcome::Modified(ref v) => encode_modified_inner(v, buf),
}
}
}
pub type Handle = u32;
pub type Seconds = u32;
pub type Milliseconds = u32;
pub type DeliveryTag = Bytes;
pub type SequenceNo = u32;
pub type DeliveryNumber = SequenceNo;
pub type TransferNumber = SequenceNo;
pub type MessageFormat = u32;
pub type IetfLanguageTag = Symbol;
pub type NodeProperties = Fields;
pub type MessageIdUlong = u64;
pub type MessageIdUuid = Uuid;
pub type MessageIdBinary = Bytes;
pub type MessageIdString = ByteString;
pub type Address = ByteString;
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum Role {
Sender,
Receiver,
}
impl Role {
pub fn try_from(v: bool) -> Result<Self, AmqpParseError> {
match v {
false => Ok(Role::Sender),
true => Ok(Role::Receiver),
_ => Err(AmqpParseError::UnknownEnumOption("Role")),
}
}
}
impl DecodeFormatted for Role {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = bool::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(base)?))
}
}
impl Encode for Role {
fn encoded_size(&self) -> usize {
match *self {
Role::Sender => {
let v: bool = false;
v.encoded_size()
}
Role::Receiver => {
let v: bool = true;
v.encoded_size()
}
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
Role::Sender => {
let v: bool = false;
v.encode(buf);
}
Role::Receiver => {
let v: bool = true;
v.encode(buf);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SenderSettleMode {
Unsettled,
Settled,
Mixed,
}
impl SenderSettleMode {
pub fn try_from(v: u8) -> Result<Self, AmqpParseError> {
match v {
0 => Ok(SenderSettleMode::Unsettled),
1 => Ok(SenderSettleMode::Settled),
2 => Ok(SenderSettleMode::Mixed),
_ => Err(AmqpParseError::UnknownEnumOption("SenderSettleMode")),
}
}
}
impl DecodeFormatted for SenderSettleMode {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = u8::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(base)?))
}
}
impl Encode for SenderSettleMode {
fn encoded_size(&self) -> usize {
match *self {
SenderSettleMode::Unsettled => {
let v: u8 = 0;
v.encoded_size()
}
SenderSettleMode::Settled => {
let v: u8 = 1;
v.encoded_size()
}
SenderSettleMode::Mixed => {
let v: u8 = 2;
v.encoded_size()
}
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
SenderSettleMode::Unsettled => {
let v: u8 = 0;
v.encode(buf);
}
SenderSettleMode::Settled => {
let v: u8 = 1;
v.encode(buf);
}
SenderSettleMode::Mixed => {
let v: u8 = 2;
v.encode(buf);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ReceiverSettleMode {
First,
Second,
}
impl ReceiverSettleMode {
pub fn try_from(v: u8) -> Result<Self, AmqpParseError> {
match v {
0 => Ok(ReceiverSettleMode::First),
1 => Ok(ReceiverSettleMode::Second),
_ => Err(AmqpParseError::UnknownEnumOption("ReceiverSettleMode")),
}
}
}
impl DecodeFormatted for ReceiverSettleMode {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = u8::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(base)?))
}
}
impl Encode for ReceiverSettleMode {
fn encoded_size(&self) -> usize {
match *self {
ReceiverSettleMode::First => {
let v: u8 = 0;
v.encoded_size()
}
ReceiverSettleMode::Second => {
let v: u8 = 1;
v.encoded_size()
}
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
ReceiverSettleMode::First => {
let v: u8 = 0;
v.encode(buf);
}
ReceiverSettleMode::Second => {
let v: u8 = 1;
v.encode(buf);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum AmqpError {
InternalError,
NotFound,
UnauthorizedAccess,
DecodeError,
ResourceLimitExceeded,
NotAllowed,
InvalidField,
NotImplemented,
ResourceLocked,
PreconditionFailed,
ResourceDeleted,
IllegalState,
FrameSizeTooSmall,
}
impl AmqpError {
pub fn try_from(v: &Symbol) -> Result<Self, AmqpParseError> {
match v.as_str() {
"amqp:internal-error" => Ok(AmqpError::InternalError),
"amqp:not-found" => Ok(AmqpError::NotFound),
"amqp:unauthorized-access" => Ok(AmqpError::UnauthorizedAccess),
"amqp:decode-error" => Ok(AmqpError::DecodeError),
"amqp:resource-limit-exceeded" => Ok(AmqpError::ResourceLimitExceeded),
"amqp:not-allowed" => Ok(AmqpError::NotAllowed),
"amqp:invalid-field" => Ok(AmqpError::InvalidField),
"amqp:not-implemented" => Ok(AmqpError::NotImplemented),
"amqp:resource-locked" => Ok(AmqpError::ResourceLocked),
"amqp:precondition-failed" => Ok(AmqpError::PreconditionFailed),
"amqp:resource-deleted" => Ok(AmqpError::ResourceDeleted),
"amqp:illegal-state" => Ok(AmqpError::IllegalState),
"amqp:frame-size-too-small" => Ok(AmqpError::FrameSizeTooSmall),
_ => Err(AmqpParseError::UnknownEnumOption("AmqpError")),
}
}
}
impl DecodeFormatted for AmqpError {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = Symbol::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(&base)?))
}
}
impl Encode for AmqpError {
fn encoded_size(&self) -> usize {
match *self {
AmqpError::InternalError => 19 + 2,
AmqpError::NotFound => 14 + 2,
AmqpError::UnauthorizedAccess => 24 + 2,
AmqpError::DecodeError => 17 + 2,
AmqpError::ResourceLimitExceeded => 28 + 2,
AmqpError::NotAllowed => 16 + 2,
AmqpError::InvalidField => 18 + 2,
AmqpError::NotImplemented => 20 + 2,
AmqpError::ResourceLocked => 20 + 2,
AmqpError::PreconditionFailed => 24 + 2,
AmqpError::ResourceDeleted => 21 + 2,
AmqpError::IllegalState => 18 + 2,
AmqpError::FrameSizeTooSmall => 25 + 2,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
AmqpError::InternalError => StaticSymbol("amqp:internal-error").encode(buf),
AmqpError::NotFound => StaticSymbol("amqp:not-found").encode(buf),
AmqpError::UnauthorizedAccess => StaticSymbol("amqp:unauthorized-access").encode(buf),
AmqpError::DecodeError => StaticSymbol("amqp:decode-error").encode(buf),
AmqpError::ResourceLimitExceeded => {
StaticSymbol("amqp:resource-limit-exceeded").encode(buf)
}
AmqpError::NotAllowed => StaticSymbol("amqp:not-allowed").encode(buf),
AmqpError::InvalidField => StaticSymbol("amqp:invalid-field").encode(buf),
AmqpError::NotImplemented => StaticSymbol("amqp:not-implemented").encode(buf),
AmqpError::ResourceLocked => StaticSymbol("amqp:resource-locked").encode(buf),
AmqpError::PreconditionFailed => StaticSymbol("amqp:precondition-failed").encode(buf),
AmqpError::ResourceDeleted => StaticSymbol("amqp:resource-deleted").encode(buf),
AmqpError::IllegalState => StaticSymbol("amqp:illegal-state").encode(buf),
AmqpError::FrameSizeTooSmall => StaticSymbol("amqp:frame-size-too-small").encode(buf),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum ConnectionError {
ConnectionForced,
FramingError,
Redirect,
}
impl ConnectionError {
pub fn try_from(v: &Symbol) -> Result<Self, AmqpParseError> {
match v.as_str() {
"amqp:connection:forced" => Ok(ConnectionError::ConnectionForced),
"amqp:connection:framing-error" => Ok(ConnectionError::FramingError),
"amqp:connection:redirect" => Ok(ConnectionError::Redirect),
_ => Err(AmqpParseError::UnknownEnumOption("ConnectionError")),
}
}
}
impl DecodeFormatted for ConnectionError {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = Symbol::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(&base)?))
}
}
impl Encode for ConnectionError {
fn encoded_size(&self) -> usize {
match *self {
ConnectionError::ConnectionForced => 22 + 2,
ConnectionError::FramingError => 29 + 2,
ConnectionError::Redirect => 24 + 2,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
ConnectionError::ConnectionForced => StaticSymbol("amqp:connection:forced").encode(buf),
ConnectionError::FramingError => {
StaticSymbol("amqp:connection:framing-error").encode(buf)
}
ConnectionError::Redirect => StaticSymbol("amqp:connection:redirect").encode(buf),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SessionError {
WindowViolation,
ErrantLink,
HandleInUse,
UnattachedHandle,
}
impl SessionError {
pub fn try_from(v: &Symbol) -> Result<Self, AmqpParseError> {
match v.as_str() {
"amqp:session:window-violation" => Ok(SessionError::WindowViolation),
"amqp:session:errant-link" => Ok(SessionError::ErrantLink),
"amqp:session:handle-in-use" => Ok(SessionError::HandleInUse),
"amqp:session:unattached-handle" => Ok(SessionError::UnattachedHandle),
_ => Err(AmqpParseError::UnknownEnumOption("SessionError")),
}
}
}
impl DecodeFormatted for SessionError {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = Symbol::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(&base)?))
}
}
impl Encode for SessionError {
fn encoded_size(&self) -> usize {
match *self {
SessionError::WindowViolation => 29 + 2,
SessionError::ErrantLink => 24 + 2,
SessionError::HandleInUse => 26 + 2,
SessionError::UnattachedHandle => 30 + 2,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
SessionError::WindowViolation => {
StaticSymbol("amqp:session:window-violation").encode(buf)
}
SessionError::ErrantLink => StaticSymbol("amqp:session:errant-link").encode(buf),
SessionError::HandleInUse => StaticSymbol("amqp:session:handle-in-use").encode(buf),
SessionError::UnattachedHandle => {
StaticSymbol("amqp:session:unattached-handle").encode(buf)
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum LinkError {
DetachForced,
TransferLimitExceeded,
MessageSizeExceeded,
Redirect,
Stolen,
}
impl LinkError {
pub fn try_from(v: &Symbol) -> Result<Self, AmqpParseError> {
match v.as_str() {
"amqp:link:detach-forced" => Ok(LinkError::DetachForced),
"amqp:link:transfer-limit-exceeded" => Ok(LinkError::TransferLimitExceeded),
"amqp:link:message-size-exceeded" => Ok(LinkError::MessageSizeExceeded),
"amqp:link:redirect" => Ok(LinkError::Redirect),
"amqp:link:stolen" => Ok(LinkError::Stolen),
_ => Err(AmqpParseError::UnknownEnumOption("LinkError")),
}
}
}
impl DecodeFormatted for LinkError {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = Symbol::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(&base)?))
}
}
impl Encode for LinkError {
fn encoded_size(&self) -> usize {
match *self {
LinkError::DetachForced => 23 + 2,
LinkError::TransferLimitExceeded => 33 + 2,
LinkError::MessageSizeExceeded => 31 + 2,
LinkError::Redirect => 18 + 2,
LinkError::Stolen => 16 + 2,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
LinkError::DetachForced => StaticSymbol("amqp:link:detach-forced").encode(buf),
LinkError::TransferLimitExceeded => {
StaticSymbol("amqp:link:transfer-limit-exceeded").encode(buf)
}
LinkError::MessageSizeExceeded => {
StaticSymbol("amqp:link:message-size-exceeded").encode(buf)
}
LinkError::Redirect => StaticSymbol("amqp:link:redirect").encode(buf),
LinkError::Stolen => StaticSymbol("amqp:link:stolen").encode(buf),
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum SaslCode {
Ok,
Auth,
Sys,
SysPerm,
SysTemp,
}
impl SaslCode {
pub fn try_from(v: u8) -> Result<Self, AmqpParseError> {
match v {
0 => Ok(SaslCode::Ok),
1 => Ok(SaslCode::Auth),
2 => Ok(SaslCode::Sys),
3 => Ok(SaslCode::SysPerm),
4 => Ok(SaslCode::SysTemp),
_ => Err(AmqpParseError::UnknownEnumOption("SaslCode")),
}
}
}
impl DecodeFormatted for SaslCode {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = u8::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(base)?))
}
}
impl Encode for SaslCode {
fn encoded_size(&self) -> usize {
match *self {
SaslCode::Ok => {
let v: u8 = 0;
v.encoded_size()
}
SaslCode::Auth => {
let v: u8 = 1;
v.encoded_size()
}
SaslCode::Sys => {
let v: u8 = 2;
v.encoded_size()
}
SaslCode::SysPerm => {
let v: u8 = 3;
v.encoded_size()
}
SaslCode::SysTemp => {
let v: u8 = 4;
v.encoded_size()
}
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
SaslCode::Ok => {
let v: u8 = 0;
v.encode(buf);
}
SaslCode::Auth => {
let v: u8 = 1;
v.encode(buf);
}
SaslCode::Sys => {
let v: u8 = 2;
v.encode(buf);
}
SaslCode::SysPerm => {
let v: u8 = 3;
v.encode(buf);
}
SaslCode::SysTemp => {
let v: u8 = 4;
v.encode(buf);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TerminusDurability {
None,
Configuration,
UnsettledState,
}
impl TerminusDurability {
pub fn try_from(v: u32) -> Result<Self, AmqpParseError> {
match v {
0 => Ok(TerminusDurability::None),
1 => Ok(TerminusDurability::Configuration),
2 => Ok(TerminusDurability::UnsettledState),
_ => Err(AmqpParseError::UnknownEnumOption("TerminusDurability")),
}
}
}
impl DecodeFormatted for TerminusDurability {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = u32::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(base)?))
}
}
impl Encode for TerminusDurability {
fn encoded_size(&self) -> usize {
match *self {
TerminusDurability::None => {
let v: u32 = 0;
v.encoded_size()
}
TerminusDurability::Configuration => {
let v: u32 = 1;
v.encoded_size()
}
TerminusDurability::UnsettledState => {
let v: u32 = 2;
v.encoded_size()
}
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
TerminusDurability::None => {
let v: u32 = 0;
v.encode(buf);
}
TerminusDurability::Configuration => {
let v: u32 = 1;
v.encode(buf);
}
TerminusDurability::UnsettledState => {
let v: u32 = 2;
v.encode(buf);
}
}
}
}
#[derive(Clone, Copy, Debug, PartialEq)]
pub enum TerminusExpiryPolicy {
LinkDetach,
SessionEnd,
ConnectionClose,
Never,
}
impl TerminusExpiryPolicy {
pub fn try_from(v: &Symbol) -> Result<Self, AmqpParseError> {
match v.as_str() {
"link-detach" => Ok(TerminusExpiryPolicy::LinkDetach),
"session-end" => Ok(TerminusExpiryPolicy::SessionEnd),
"connection-close" => Ok(TerminusExpiryPolicy::ConnectionClose),
"never" => Ok(TerminusExpiryPolicy::Never),
_ => Err(AmqpParseError::UnknownEnumOption("TerminusExpiryPolicy")),
}
}
}
impl DecodeFormatted for TerminusExpiryPolicy {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
let (input, base) = Symbol::decode_with_format(input, fmt)?;
Ok((input, Self::try_from(&base)?))
}
}
impl Encode for TerminusExpiryPolicy {
fn encoded_size(&self) -> usize {
match *self {
TerminusExpiryPolicy::LinkDetach => 11 + 2,
TerminusExpiryPolicy::SessionEnd => 11 + 2,
TerminusExpiryPolicy::ConnectionClose => 16 + 2,
TerminusExpiryPolicy::Never => 5 + 2,
}
}
fn encode(&self, buf: &mut BytesMut) {
match *self {
TerminusExpiryPolicy::LinkDetach => StaticSymbol("link-detach").encode(buf),
TerminusExpiryPolicy::SessionEnd => StaticSymbol("session-end").encode(buf),
TerminusExpiryPolicy::ConnectionClose => StaticSymbol("connection-close").encode(buf),
TerminusExpiryPolicy::Never => StaticSymbol("never").encode(buf),
}
}
}
type DeliveryAnnotations = Annotations;
fn decode_delivery_annotations_inner(
input: &[u8],
) -> Result<(&[u8], DeliveryAnnotations), AmqpParseError> {
DeliveryAnnotations::decode(input)
}
fn encoded_size_delivery_annotations_inner(dr: &DeliveryAnnotations) -> usize {
3 + dr.encoded_size()
}
fn encode_delivery_annotations_inner(dr: &DeliveryAnnotations, buf: &mut BytesMut) {
Descriptor::Ulong(113).encode(buf);
dr.encode(buf);
}
type MessageAnnotations = Annotations;
fn decode_message_annotations_inner(
input: &[u8],
) -> Result<(&[u8], MessageAnnotations), AmqpParseError> {
MessageAnnotations::decode(input)
}
fn encoded_size_message_annotations_inner(dr: &MessageAnnotations) -> usize {
3 + dr.encoded_size()
}
fn encode_message_annotations_inner(dr: &MessageAnnotations, buf: &mut BytesMut) {
Descriptor::Ulong(114).encode(buf);
dr.encode(buf);
}
type ApplicationProperties = StringVariantMap;
fn decode_application_properties_inner(
input: &[u8],
) -> Result<(&[u8], ApplicationProperties), AmqpParseError> {
ApplicationProperties::decode(input)
}
fn encoded_size_application_properties_inner(dr: &ApplicationProperties) -> usize {
3 + dr.encoded_size()
}
fn encode_application_properties_inner(dr: &ApplicationProperties, buf: &mut BytesMut) {
Descriptor::Ulong(116).encode(buf);
dr.encode(buf);
}
type Data = Bytes;
fn decode_data_inner(input: &[u8]) -> Result<(&[u8], Data), AmqpParseError> {
Data::decode(input)
}
fn encoded_size_data_inner(dr: &Data) -> usize {
3 + dr.encoded_size()
}
fn encode_data_inner(dr: &Data, buf: &mut BytesMut) {
Descriptor::Ulong(117).encode(buf);
dr.encode(buf);
}
type AmqpSequence = List;
fn decode_amqp_sequence_inner(input: &[u8]) -> Result<(&[u8], AmqpSequence), AmqpParseError> {
AmqpSequence::decode(input)
}
fn encoded_size_amqp_sequence_inner(dr: &AmqpSequence) -> usize {
3 + dr.encoded_size()
}
fn encode_amqp_sequence_inner(dr: &AmqpSequence, buf: &mut BytesMut) {
Descriptor::Ulong(118).encode(buf);
dr.encode(buf);
}
type AmqpValue = Variant;
fn decode_amqp_value_inner(input: &[u8]) -> Result<(&[u8], AmqpValue), AmqpParseError> {
AmqpValue::decode(input)
}
fn encoded_size_amqp_value_inner(dr: &AmqpValue) -> usize {
3 + dr.encoded_size()
}
fn encode_amqp_value_inner(dr: &AmqpValue, buf: &mut BytesMut) {
Descriptor::Ulong(119).encode(buf);
dr.encode(buf);
}
type Footer = Annotations;
fn decode_footer_inner(input: &[u8]) -> Result<(&[u8], Footer), AmqpParseError> {
Footer::decode(input)
}
fn encoded_size_footer_inner(dr: &Footer) -> usize {
3 + dr.encoded_size()
}
fn encode_footer_inner(dr: &Footer, buf: &mut BytesMut) {
Descriptor::Ulong(120).encode(buf);
dr.encode(buf);
}
#[derive(Clone, Debug, PartialEq)]
pub struct Error {
pub condition: ErrorCondition,
pub description: Option<ByteString>,
pub info: Option<Fields>,
}
impl Error {
pub fn condition(&self) -> &ErrorCondition {
&self.condition
}
pub fn description(&self) -> Option<&ByteString> {
self.description.as_ref()
}
pub fn info(&self) -> Option<&Fields> {
self.info.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_error_inner(input: &[u8]) -> Result<(&[u8], Error), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let condition: ErrorCondition;
if count > 0 {
let (in1, decoded) = ErrorCondition::decode(input)?;
condition = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("condition"));
}
let description: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
description = decoded.1;
count -= 1;
} else {
description = None;
}
let info: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
info = decoded.1;
count -= 1;
} else {
info = None;
}
Ok((
remainder,
Error {
condition,
description,
info,
},
))
}
fn encoded_size_error_inner(list: &Error) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.condition.encoded_size()
+ list.description.encoded_size()
+ list.info.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_error_inner(list: &Error, buf: &mut BytesMut) {
Descriptor::Ulong(29).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.condition.encoded_size()
+ list.description.encoded_size()
+ list.info.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Error::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Error::FIELD_COUNT as u8);
}
list.condition.encode(buf);
list.description.encode(buf);
list.info.encode(buf);
}
impl DecodeFormatted for Error {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 29,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:error:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_error_inner(input)
}
}
}
impl Encode for Error {
fn encoded_size(&self) -> usize {
encoded_size_error_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_error_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Open {
pub container_id: ByteString,
pub hostname: Option<ByteString>,
pub max_frame_size: u32,
pub channel_max: u16,
pub idle_time_out: Option<Milliseconds>,
pub outgoing_locales: Option<IetfLanguageTags>,
pub incoming_locales: Option<IetfLanguageTags>,
pub offered_capabilities: Option<Symbols>,
pub desired_capabilities: Option<Symbols>,
pub properties: Option<Fields>,
}
impl Open {
pub fn container_id(&self) -> &ByteString {
&self.container_id
}
pub fn hostname(&self) -> Option<&ByteString> {
self.hostname.as_ref()
}
pub fn max_frame_size(&self) -> u32 {
self.max_frame_size
}
pub fn channel_max(&self) -> u16 {
self.channel_max
}
pub fn idle_time_out(&self) -> Option<Milliseconds> {
self.idle_time_out
}
pub fn outgoing_locales(&self) -> Option<&IetfLanguageTags> {
self.outgoing_locales.as_ref()
}
pub fn incoming_locales(&self) -> Option<&IetfLanguageTags> {
self.incoming_locales.as_ref()
}
pub fn offered_capabilities(&self) -> Option<&Symbols> {
self.offered_capabilities.as_ref()
}
pub fn desired_capabilities(&self) -> Option<&Symbols> {
self.desired_capabilities.as_ref()
}
pub fn properties(&self) -> Option<&Fields> {
self.properties.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_open_inner(input: &[u8]) -> Result<(&[u8], Open), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let container_id: ByteString;
if count > 0 {
let (in1, decoded) = ByteString::decode(input)?;
container_id = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("container_id"));
}
let hostname: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
hostname = decoded.1;
count -= 1;
} else {
hostname = None;
}
let max_frame_size: u32;
if count > 0 {
let (in1, decoded) = Option::<u32>::decode(input)?;
max_frame_size = decoded.unwrap_or(4294967295);
input = in1;
count -= 1;
} else {
max_frame_size = 4294967295;
}
let channel_max: u16;
if count > 0 {
let (in1, decoded) = Option::<u16>::decode(input)?;
channel_max = decoded.unwrap_or(65535);
input = in1;
count -= 1;
} else {
channel_max = 65535;
}
let idle_time_out: Option<Milliseconds>;
if count > 0 {
let decoded = Option::<Milliseconds>::decode(input)?;
input = decoded.0;
idle_time_out = decoded.1;
count -= 1;
} else {
idle_time_out = None;
}
let outgoing_locales: Option<IetfLanguageTags>;
if count > 0 {
let decoded = Option::<IetfLanguageTags>::decode(input)?;
input = decoded.0;
outgoing_locales = decoded.1;
count -= 1;
} else {
outgoing_locales = None;
}
let incoming_locales: Option<IetfLanguageTags>;
if count > 0 {
let decoded = Option::<IetfLanguageTags>::decode(input)?;
input = decoded.0;
incoming_locales = decoded.1;
count -= 1;
} else {
incoming_locales = None;
}
let offered_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
offered_capabilities = decoded.1;
count -= 1;
} else {
offered_capabilities = None;
}
let desired_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
desired_capabilities = decoded.1;
count -= 1;
} else {
desired_capabilities = None;
}
let properties: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
properties = decoded.1;
count -= 1;
} else {
properties = None;
}
Ok((
remainder,
Open {
container_id,
hostname,
max_frame_size,
channel_max,
idle_time_out,
outgoing_locales,
incoming_locales,
offered_capabilities,
desired_capabilities,
properties,
},
))
}
fn encoded_size_open_inner(list: &Open) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.container_id.encoded_size()
+ list.hostname.encoded_size()
+ list.max_frame_size.encoded_size()
+ list.channel_max.encoded_size()
+ list.idle_time_out.encoded_size()
+ list.outgoing_locales.encoded_size()
+ list.incoming_locales.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_open_inner(list: &Open, buf: &mut BytesMut) {
Descriptor::Ulong(16).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.container_id.encoded_size()
+ list.hostname.encoded_size()
+ list.max_frame_size.encoded_size()
+ list.channel_max.encoded_size()
+ list.idle_time_out.encoded_size()
+ list.outgoing_locales.encoded_size()
+ list.incoming_locales.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Open::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Open::FIELD_COUNT as u8);
}
list.container_id.encode(buf);
list.hostname.encode(buf);
list.max_frame_size.encode(buf);
list.channel_max.encode(buf);
list.idle_time_out.encode(buf);
list.outgoing_locales.encode(buf);
list.incoming_locales.encode(buf);
list.offered_capabilities.encode(buf);
list.desired_capabilities.encode(buf);
list.properties.encode(buf);
}
impl DecodeFormatted for Open {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 16,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:open:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_open_inner(input)
}
}
}
impl Encode for Open {
fn encoded_size(&self) -> usize {
encoded_size_open_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_open_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Begin {
pub remote_channel: Option<u16>,
pub next_outgoing_id: TransferNumber,
pub incoming_window: u32,
pub outgoing_window: u32,
pub handle_max: Handle,
pub offered_capabilities: Option<Symbols>,
pub desired_capabilities: Option<Symbols>,
pub properties: Option<Fields>,
}
impl Begin {
pub fn remote_channel(&self) -> Option<u16> {
self.remote_channel
}
pub fn next_outgoing_id(&self) -> TransferNumber {
self.next_outgoing_id
}
pub fn incoming_window(&self) -> u32 {
self.incoming_window
}
pub fn outgoing_window(&self) -> u32 {
self.outgoing_window
}
pub fn handle_max(&self) -> Handle {
self.handle_max
}
pub fn offered_capabilities(&self) -> Option<&Symbols> {
self.offered_capabilities.as_ref()
}
pub fn desired_capabilities(&self) -> Option<&Symbols> {
self.desired_capabilities.as_ref()
}
pub fn properties(&self) -> Option<&Fields> {
self.properties.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_begin_inner(input: &[u8]) -> Result<(&[u8], Begin), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let remote_channel: Option<u16>;
if count > 0 {
let decoded = Option::<u16>::decode(input)?;
input = decoded.0;
remote_channel = decoded.1;
count -= 1;
} else {
remote_channel = None;
}
let next_outgoing_id: TransferNumber;
if count > 0 {
let (in1, decoded) = TransferNumber::decode(input)?;
next_outgoing_id = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("next_outgoing_id"));
}
let incoming_window: u32;
if count > 0 {
let (in1, decoded) = u32::decode(input)?;
incoming_window = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("incoming_window"));
}
let outgoing_window: u32;
if count > 0 {
let (in1, decoded) = u32::decode(input)?;
outgoing_window = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("outgoing_window"));
}
let handle_max: Handle;
if count > 0 {
let (in1, decoded) = Option::<Handle>::decode(input)?;
handle_max = decoded.unwrap_or(4294967295);
input = in1;
count -= 1;
} else {
handle_max = 4294967295;
}
let offered_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
offered_capabilities = decoded.1;
count -= 1;
} else {
offered_capabilities = None;
}
let desired_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
desired_capabilities = decoded.1;
count -= 1;
} else {
desired_capabilities = None;
}
let properties: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
properties = decoded.1;
count -= 1;
} else {
properties = None;
}
Ok((
remainder,
Begin {
remote_channel,
next_outgoing_id,
incoming_window,
outgoing_window,
handle_max,
offered_capabilities,
desired_capabilities,
properties,
},
))
}
fn encoded_size_begin_inner(list: &Begin) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.remote_channel.encoded_size()
+ list.next_outgoing_id.encoded_size()
+ list.incoming_window.encoded_size()
+ list.outgoing_window.encoded_size()
+ list.handle_max.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_begin_inner(list: &Begin, buf: &mut BytesMut) {
Descriptor::Ulong(17).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.remote_channel.encoded_size()
+ list.next_outgoing_id.encoded_size()
+ list.incoming_window.encoded_size()
+ list.outgoing_window.encoded_size()
+ list.handle_max.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Begin::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Begin::FIELD_COUNT as u8);
}
list.remote_channel.encode(buf);
list.next_outgoing_id.encode(buf);
list.incoming_window.encode(buf);
list.outgoing_window.encode(buf);
list.handle_max.encode(buf);
list.offered_capabilities.encode(buf);
list.desired_capabilities.encode(buf);
list.properties.encode(buf);
}
impl DecodeFormatted for Begin {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 17,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:begin:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_begin_inner(input)
}
}
}
impl Encode for Begin {
fn encoded_size(&self) -> usize {
encoded_size_begin_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_begin_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Attach {
pub name: ByteString,
pub handle: Handle,
pub role: Role,
pub snd_settle_mode: SenderSettleMode,
pub rcv_settle_mode: ReceiverSettleMode,
pub source: Option<Source>,
pub target: Option<Target>,
pub unsettled: Option<Map>,
pub incomplete_unsettled: bool,
pub initial_delivery_count: Option<SequenceNo>,
pub max_message_size: Option<u64>,
pub offered_capabilities: Option<Symbols>,
pub desired_capabilities: Option<Symbols>,
pub properties: Option<Fields>,
}
impl Attach {
pub fn name(&self) -> &ByteString {
&self.name
}
pub fn handle(&self) -> Handle {
self.handle
}
pub fn role(&self) -> Role {
self.role
}
pub fn snd_settle_mode(&self) -> SenderSettleMode {
self.snd_settle_mode
}
pub fn rcv_settle_mode(&self) -> ReceiverSettleMode {
self.rcv_settle_mode
}
pub fn source(&self) -> Option<&Source> {
self.source.as_ref()
}
pub fn target(&self) -> Option<&Target> {
self.target.as_ref()
}
pub fn unsettled(&self) -> Option<&Map> {
self.unsettled.as_ref()
}
pub fn incomplete_unsettled(&self) -> bool {
self.incomplete_unsettled
}
pub fn initial_delivery_count(&self) -> Option<SequenceNo> {
self.initial_delivery_count
}
pub fn max_message_size(&self) -> Option<u64> {
self.max_message_size
}
pub fn offered_capabilities(&self) -> Option<&Symbols> {
self.offered_capabilities.as_ref()
}
pub fn desired_capabilities(&self) -> Option<&Symbols> {
self.desired_capabilities.as_ref()
}
pub fn properties(&self) -> Option<&Fields> {
self.properties.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_attach_inner(input: &[u8]) -> Result<(&[u8], Attach), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let name: ByteString;
if count > 0 {
let (in1, decoded) = ByteString::decode(input)?;
name = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("name"));
}
let handle: Handle;
if count > 0 {
let (in1, decoded) = Handle::decode(input)?;
handle = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("handle"));
}
let role: Role;
if count > 0 {
let (in1, decoded) = Role::decode(input)?;
role = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("role"));
}
let snd_settle_mode: SenderSettleMode;
if count > 0 {
let (in1, decoded) = Option::<SenderSettleMode>::decode(input)?;
snd_settle_mode = decoded.unwrap_or(SenderSettleMode::Mixed);
input = in1;
count -= 1;
} else {
snd_settle_mode = SenderSettleMode::Mixed;
}
let rcv_settle_mode: ReceiverSettleMode;
if count > 0 {
let (in1, decoded) = Option::<ReceiverSettleMode>::decode(input)?;
rcv_settle_mode = decoded.unwrap_or(ReceiverSettleMode::First);
input = in1;
count -= 1;
} else {
rcv_settle_mode = ReceiverSettleMode::First;
}
let source: Option<Source>;
if count > 0 {
let decoded = Option::<Source>::decode(input)?;
input = decoded.0;
source = decoded.1;
count -= 1;
} else {
source = None;
}
let target: Option<Target>;
if count > 0 {
let decoded = Option::<Target>::decode(input)?;
input = decoded.0;
target = decoded.1;
count -= 1;
} else {
target = None;
}
let unsettled: Option<Map>;
if count > 0 {
let decoded = Option::<Map>::decode(input)?;
input = decoded.0;
unsettled = decoded.1;
count -= 1;
} else {
unsettled = None;
}
let incomplete_unsettled: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
incomplete_unsettled = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
incomplete_unsettled = false;
}
let initial_delivery_count: Option<SequenceNo>;
if count > 0 {
let decoded = Option::<SequenceNo>::decode(input)?;
input = decoded.0;
initial_delivery_count = decoded.1;
count -= 1;
} else {
initial_delivery_count = None;
}
let max_message_size: Option<u64>;
if count > 0 {
let decoded = Option::<u64>::decode(input)?;
input = decoded.0;
max_message_size = decoded.1;
count -= 1;
} else {
max_message_size = None;
}
let offered_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
offered_capabilities = decoded.1;
count -= 1;
} else {
offered_capabilities = None;
}
let desired_capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
desired_capabilities = decoded.1;
count -= 1;
} else {
desired_capabilities = None;
}
let properties: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
properties = decoded.1;
count -= 1;
} else {
properties = None;
}
Ok((
remainder,
Attach {
name,
handle,
role,
snd_settle_mode,
rcv_settle_mode,
source,
target,
unsettled,
incomplete_unsettled,
initial_delivery_count,
max_message_size,
offered_capabilities,
desired_capabilities,
properties,
},
))
}
fn encoded_size_attach_inner(list: &Attach) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.name.encoded_size()
+ list.handle.encoded_size()
+ list.role.encoded_size()
+ list.snd_settle_mode.encoded_size()
+ list.rcv_settle_mode.encoded_size()
+ list.source.encoded_size()
+ list.target.encoded_size()
+ list.unsettled.encoded_size()
+ list.incomplete_unsettled.encoded_size()
+ list.initial_delivery_count.encoded_size()
+ list.max_message_size.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_attach_inner(list: &Attach, buf: &mut BytesMut) {
Descriptor::Ulong(18).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.name.encoded_size()
+ list.handle.encoded_size()
+ list.role.encoded_size()
+ list.snd_settle_mode.encoded_size()
+ list.rcv_settle_mode.encoded_size()
+ list.source.encoded_size()
+ list.target.encoded_size()
+ list.unsettled.encoded_size()
+ list.incomplete_unsettled.encoded_size()
+ list.initial_delivery_count.encoded_size()
+ list.max_message_size.encoded_size()
+ list.offered_capabilities.encoded_size()
+ list.desired_capabilities.encoded_size()
+ list.properties.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Attach::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Attach::FIELD_COUNT as u8);
}
list.name.encode(buf);
list.handle.encode(buf);
list.role.encode(buf);
list.snd_settle_mode.encode(buf);
list.rcv_settle_mode.encode(buf);
list.source.encode(buf);
list.target.encode(buf);
list.unsettled.encode(buf);
list.incomplete_unsettled.encode(buf);
list.initial_delivery_count.encode(buf);
list.max_message_size.encode(buf);
list.offered_capabilities.encode(buf);
list.desired_capabilities.encode(buf);
list.properties.encode(buf);
}
impl DecodeFormatted for Attach {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 18,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:attach:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_attach_inner(input)
}
}
}
impl Encode for Attach {
fn encoded_size(&self) -> usize {
encoded_size_attach_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_attach_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Flow {
pub next_incoming_id: Option<TransferNumber>,
pub incoming_window: u32,
pub next_outgoing_id: TransferNumber,
pub outgoing_window: u32,
pub handle: Option<Handle>,
pub delivery_count: Option<SequenceNo>,
pub link_credit: Option<u32>,
pub available: Option<u32>,
pub drain: bool,
pub echo: bool,
pub properties: Option<Fields>,
}
impl Flow {
pub fn next_incoming_id(&self) -> Option<TransferNumber> {
self.next_incoming_id
}
pub fn incoming_window(&self) -> u32 {
self.incoming_window
}
pub fn next_outgoing_id(&self) -> TransferNumber {
self.next_outgoing_id
}
pub fn outgoing_window(&self) -> u32 {
self.outgoing_window
}
pub fn handle(&self) -> Option<Handle> {
self.handle
}
pub fn delivery_count(&self) -> Option<SequenceNo> {
self.delivery_count
}
pub fn link_credit(&self) -> Option<u32> {
self.link_credit
}
pub fn available(&self) -> Option<u32> {
self.available
}
pub fn drain(&self) -> bool {
self.drain
}
pub fn echo(&self) -> bool {
self.echo
}
pub fn properties(&self) -> Option<&Fields> {
self.properties.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_flow_inner(input: &[u8]) -> Result<(&[u8], Flow), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let next_incoming_id: Option<TransferNumber>;
if count > 0 {
let decoded = Option::<TransferNumber>::decode(input)?;
input = decoded.0;
next_incoming_id = decoded.1;
count -= 1;
} else {
next_incoming_id = None;
}
let incoming_window: u32;
if count > 0 {
let (in1, decoded) = u32::decode(input)?;
incoming_window = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("incoming_window"));
}
let next_outgoing_id: TransferNumber;
if count > 0 {
let (in1, decoded) = TransferNumber::decode(input)?;
next_outgoing_id = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("next_outgoing_id"));
}
let outgoing_window: u32;
if count > 0 {
let (in1, decoded) = u32::decode(input)?;
outgoing_window = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("outgoing_window"));
}
let handle: Option<Handle>;
if count > 0 {
let decoded = Option::<Handle>::decode(input)?;
input = decoded.0;
handle = decoded.1;
count -= 1;
} else {
handle = None;
}
let delivery_count: Option<SequenceNo>;
if count > 0 {
let decoded = Option::<SequenceNo>::decode(input)?;
input = decoded.0;
delivery_count = decoded.1;
count -= 1;
} else {
delivery_count = None;
}
let link_credit: Option<u32>;
if count > 0 {
let decoded = Option::<u32>::decode(input)?;
input = decoded.0;
link_credit = decoded.1;
count -= 1;
} else {
link_credit = None;
}
let available: Option<u32>;
if count > 0 {
let decoded = Option::<u32>::decode(input)?;
input = decoded.0;
available = decoded.1;
count -= 1;
} else {
available = None;
}
let drain: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
drain = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
drain = false;
}
let echo: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
echo = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
echo = false;
}
let properties: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
properties = decoded.1;
count -= 1;
} else {
properties = None;
}
Ok((
remainder,
Flow {
next_incoming_id,
incoming_window,
next_outgoing_id,
outgoing_window,
handle,
delivery_count,
link_credit,
available,
drain,
echo,
properties,
},
))
}
fn encoded_size_flow_inner(list: &Flow) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.next_incoming_id.encoded_size()
+ list.incoming_window.encoded_size()
+ list.next_outgoing_id.encoded_size()
+ list.outgoing_window.encoded_size()
+ list.handle.encoded_size()
+ list.delivery_count.encoded_size()
+ list.link_credit.encoded_size()
+ list.available.encoded_size()
+ list.drain.encoded_size()
+ list.echo.encoded_size()
+ list.properties.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_flow_inner(list: &Flow, buf: &mut BytesMut) {
Descriptor::Ulong(19).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.next_incoming_id.encoded_size()
+ list.incoming_window.encoded_size()
+ list.next_outgoing_id.encoded_size()
+ list.outgoing_window.encoded_size()
+ list.handle.encoded_size()
+ list.delivery_count.encoded_size()
+ list.link_credit.encoded_size()
+ list.available.encoded_size()
+ list.drain.encoded_size()
+ list.echo.encoded_size()
+ list.properties.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Flow::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Flow::FIELD_COUNT as u8);
}
list.next_incoming_id.encode(buf);
list.incoming_window.encode(buf);
list.next_outgoing_id.encode(buf);
list.outgoing_window.encode(buf);
list.handle.encode(buf);
list.delivery_count.encode(buf);
list.link_credit.encode(buf);
list.available.encode(buf);
list.drain.encode(buf);
list.echo.encode(buf);
list.properties.encode(buf);
}
impl DecodeFormatted for Flow {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 19,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:flow:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_flow_inner(input)
}
}
}
impl Encode for Flow {
fn encoded_size(&self) -> usize {
encoded_size_flow_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_flow_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Transfer {
pub handle: Handle,
pub delivery_id: Option<DeliveryNumber>,
pub delivery_tag: Option<DeliveryTag>,
pub message_format: Option<MessageFormat>,
pub settled: Option<bool>,
pub more: bool,
pub rcv_settle_mode: Option<ReceiverSettleMode>,
pub state: Option<DeliveryState>,
pub resume: bool,
pub aborted: bool,
pub batchable: bool,
pub body: Option<TransferBody>,
}
impl Transfer {
pub fn handle(&self) -> Handle {
self.handle
}
pub fn delivery_id(&self) -> Option<DeliveryNumber> {
self.delivery_id
}
pub fn delivery_tag(&self) -> Option<&DeliveryTag> {
self.delivery_tag.as_ref()
}
pub fn message_format(&self) -> Option<MessageFormat> {
self.message_format
}
pub fn settled(&self) -> Option<bool> {
self.settled
}
pub fn more(&self) -> bool {
self.more
}
pub fn rcv_settle_mode(&self) -> Option<ReceiverSettleMode> {
self.rcv_settle_mode
}
pub fn state(&self) -> Option<&DeliveryState> {
self.state.as_ref()
}
pub fn resume(&self) -> bool {
self.resume
}
pub fn aborted(&self) -> bool {
self.aborted
}
pub fn batchable(&self) -> bool {
self.batchable
}
pub fn body(&self) -> Option<&TransferBody> {
self.body.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_transfer_inner(input: &[u8]) -> Result<(&[u8], Transfer), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let handle: Handle;
if count > 0 {
let (in1, decoded) = Handle::decode(input)?;
handle = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("handle"));
}
let delivery_id: Option<DeliveryNumber>;
if count > 0 {
let decoded = Option::<DeliveryNumber>::decode(input)?;
input = decoded.0;
delivery_id = decoded.1;
count -= 1;
} else {
delivery_id = None;
}
let delivery_tag: Option<DeliveryTag>;
if count > 0 {
let decoded = Option::<DeliveryTag>::decode(input)?;
input = decoded.0;
delivery_tag = decoded.1;
count -= 1;
} else {
delivery_tag = None;
}
let message_format: Option<MessageFormat>;
if count > 0 {
let decoded = Option::<MessageFormat>::decode(input)?;
input = decoded.0;
message_format = decoded.1;
count -= 1;
} else {
message_format = None;
}
let settled: Option<bool>;
if count > 0 {
let decoded = Option::<bool>::decode(input)?;
input = decoded.0;
settled = decoded.1;
count -= 1;
} else {
settled = None;
}
let more: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
more = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
more = false;
}
let rcv_settle_mode: Option<ReceiverSettleMode>;
if count > 0 {
let decoded = Option::<ReceiverSettleMode>::decode(input)?;
input = decoded.0;
rcv_settle_mode = decoded.1;
count -= 1;
} else {
rcv_settle_mode = None;
}
let state: Option<DeliveryState>;
if count > 0 {
let decoded = Option::<DeliveryState>::decode(input)?;
input = decoded.0;
state = decoded.1;
count -= 1;
} else {
state = None;
}
let resume: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
resume = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
resume = false;
}
let aborted: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
aborted = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
aborted = false;
}
let batchable: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
batchable = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
batchable = false;
}
let body = if remainder.is_empty() {
None
} else {
let b = Bytes::copy_from_slice(remainder);
remainder = &[];
Some(b.into())
};
Ok((
remainder,
Transfer {
handle,
delivery_id,
delivery_tag,
message_format,
settled,
more,
rcv_settle_mode,
state,
resume,
aborted,
batchable,
body,
},
))
}
fn encoded_size_transfer_inner(list: &Transfer) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.handle.encoded_size()
+ list.delivery_id.encoded_size()
+ list.delivery_tag.encoded_size()
+ list.message_format.encoded_size()
+ list.settled.encoded_size()
+ list.more.encoded_size()
+ list.rcv_settle_mode.encoded_size()
+ list.state.encoded_size()
+ list.resume.encoded_size()
+ list.aborted.encoded_size()
+ list.batchable.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
+ list.body.as_ref().map(|b| b.len()).unwrap_or(0)
}
fn encode_transfer_inner(list: &Transfer, buf: &mut BytesMut) {
Descriptor::Ulong(20).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.handle.encoded_size()
+ list.delivery_id.encoded_size()
+ list.delivery_tag.encoded_size()
+ list.message_format.encoded_size()
+ list.settled.encoded_size()
+ list.more.encoded_size()
+ list.rcv_settle_mode.encoded_size()
+ list.state.encoded_size()
+ list.resume.encoded_size()
+ list.aborted.encoded_size()
+ list.batchable.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Transfer::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Transfer::FIELD_COUNT as u8);
}
list.handle.encode(buf);
list.delivery_id.encode(buf);
list.delivery_tag.encode(buf);
list.message_format.encode(buf);
list.settled.encode(buf);
list.more.encode(buf);
list.rcv_settle_mode.encode(buf);
list.state.encode(buf);
list.resume.encode(buf);
list.aborted.encode(buf);
list.batchable.encode(buf);
if let Some(ref body) = list.body {
body.encode(buf)
}
}
impl DecodeFormatted for Transfer {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 20,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:transfer:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_transfer_inner(input)
}
}
}
impl Encode for Transfer {
fn encoded_size(&self) -> usize {
encoded_size_transfer_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_transfer_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Disposition {
pub role: Role,
pub first: DeliveryNumber,
pub last: Option<DeliveryNumber>,
pub settled: bool,
pub state: Option<DeliveryState>,
pub batchable: bool,
}
impl Disposition {
pub fn role(&self) -> Role {
self.role
}
pub fn first(&self) -> DeliveryNumber {
self.first
}
pub fn last(&self) -> Option<DeliveryNumber> {
self.last
}
pub fn settled(&self) -> bool {
self.settled
}
pub fn state(&self) -> Option<&DeliveryState> {
self.state.as_ref()
}
pub fn batchable(&self) -> bool {
self.batchable
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_disposition_inner(input: &[u8]) -> Result<(&[u8], Disposition), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let role: Role;
if count > 0 {
let (in1, decoded) = Role::decode(input)?;
role = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("role"));
}
let first: DeliveryNumber;
if count > 0 {
let (in1, decoded) = DeliveryNumber::decode(input)?;
first = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("first"));
}
let last: Option<DeliveryNumber>;
if count > 0 {
let decoded = Option::<DeliveryNumber>::decode(input)?;
input = decoded.0;
last = decoded.1;
count -= 1;
} else {
last = None;
}
let settled: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
settled = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
settled = false;
}
let state: Option<DeliveryState>;
if count > 0 {
let decoded = Option::<DeliveryState>::decode(input)?;
input = decoded.0;
state = decoded.1;
count -= 1;
} else {
state = None;
}
let batchable: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
batchable = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
batchable = false;
}
Ok((
remainder,
Disposition {
role,
first,
last,
settled,
state,
batchable,
},
))
}
fn encoded_size_disposition_inner(list: &Disposition) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.role.encoded_size()
+ list.first.encoded_size()
+ list.last.encoded_size()
+ list.settled.encoded_size()
+ list.state.encoded_size()
+ list.batchable.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_disposition_inner(list: &Disposition, buf: &mut BytesMut) {
Descriptor::Ulong(21).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.role.encoded_size()
+ list.first.encoded_size()
+ list.last.encoded_size()
+ list.settled.encoded_size()
+ list.state.encoded_size()
+ list.batchable.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Disposition::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Disposition::FIELD_COUNT as u8);
}
list.role.encode(buf);
list.first.encode(buf);
list.last.encode(buf);
list.settled.encode(buf);
list.state.encode(buf);
list.batchable.encode(buf);
}
impl DecodeFormatted for Disposition {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 21,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:disposition:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_disposition_inner(input)
}
}
}
impl Encode for Disposition {
fn encoded_size(&self) -> usize {
encoded_size_disposition_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_disposition_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Detach {
pub handle: Handle,
pub closed: bool,
pub error: Option<Error>,
}
impl Detach {
pub fn handle(&self) -> Handle {
self.handle
}
pub fn closed(&self) -> bool {
self.closed
}
pub fn error(&self) -> Option<&Error> {
self.error.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_detach_inner(input: &[u8]) -> Result<(&[u8], Detach), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let handle: Handle;
if count > 0 {
let (in1, decoded) = Handle::decode(input)?;
handle = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("handle"));
}
let closed: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
closed = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
closed = false;
}
let error: Option<Error>;
if count > 0 {
let decoded = Option::<Error>::decode(input)?;
input = decoded.0;
error = decoded.1;
count -= 1;
} else {
error = None;
}
Ok((
remainder,
Detach {
handle,
closed,
error,
},
))
}
fn encoded_size_detach_inner(list: &Detach) -> usize {
#[allow(clippy::identity_op)]
let content_size =
0 + list.handle.encoded_size() + list.closed.encoded_size() + list.error.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_detach_inner(list: &Detach, buf: &mut BytesMut) {
Descriptor::Ulong(22).encode(buf);
#[allow(clippy::identity_op)]
let content_size =
0 + list.handle.encoded_size() + list.closed.encoded_size() + list.error.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Detach::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Detach::FIELD_COUNT as u8);
}
list.handle.encode(buf);
list.closed.encode(buf);
list.error.encode(buf);
}
impl DecodeFormatted for Detach {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 22,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:detach:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_detach_inner(input)
}
}
}
impl Encode for Detach {
fn encoded_size(&self) -> usize {
encoded_size_detach_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_detach_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct End {
pub error: Option<Error>,
}
impl End {
pub fn error(&self) -> Option<&Error> {
self.error.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_end_inner(input: &[u8]) -> Result<(&[u8], End), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let error: Option<Error>;
if count > 0 {
let decoded = Option::<Error>::decode(input)?;
input = decoded.0;
error = decoded.1;
count -= 1;
} else {
error = None;
}
Ok((remainder, End { error }))
}
fn encoded_size_end_inner(list: &End) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_end_inner(list: &End, buf: &mut BytesMut) {
Descriptor::Ulong(23).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(End::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(End::FIELD_COUNT as u8);
}
list.error.encode(buf);
}
impl DecodeFormatted for End {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 23,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:end:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_end_inner(input)
}
}
}
impl Encode for End {
fn encoded_size(&self) -> usize {
encoded_size_end_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_end_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Close {
pub error: Option<Error>,
}
impl Close {
pub fn error(&self) -> Option<&Error> {
self.error.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_close_inner(input: &[u8]) -> Result<(&[u8], Close), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let error: Option<Error>;
if count > 0 {
let decoded = Option::<Error>::decode(input)?;
input = decoded.0;
error = decoded.1;
count -= 1;
} else {
error = None;
}
Ok((remainder, Close { error }))
}
fn encoded_size_close_inner(list: &Close) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_close_inner(list: &Close, buf: &mut BytesMut) {
Descriptor::Ulong(24).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Close::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Close::FIELD_COUNT as u8);
}
list.error.encode(buf);
}
impl DecodeFormatted for Close {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 24,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:close:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_close_inner(input)
}
}
}
impl Encode for Close {
fn encoded_size(&self) -> usize {
encoded_size_close_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_close_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SaslMechanisms {
pub sasl_server_mechanisms: Symbols,
}
impl SaslMechanisms {
pub fn sasl_server_mechanisms(&self) -> &Symbols {
&self.sasl_server_mechanisms
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_sasl_mechanisms_inner(input: &[u8]) -> Result<(&[u8], SaslMechanisms), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let sasl_server_mechanisms: Symbols;
if count > 0 {
let (in1, decoded) = Symbols::decode(input)?;
sasl_server_mechanisms = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted(
"sasl_server_mechanisms",
));
}
Ok((
remainder,
SaslMechanisms {
sasl_server_mechanisms,
},
))
}
fn encoded_size_sasl_mechanisms_inner(list: &SaslMechanisms) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.sasl_server_mechanisms.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_sasl_mechanisms_inner(list: &SaslMechanisms, buf: &mut BytesMut) {
Descriptor::Ulong(64).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.sasl_server_mechanisms.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(SaslMechanisms::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(SaslMechanisms::FIELD_COUNT as u8);
}
list.sasl_server_mechanisms.encode(buf);
}
impl DecodeFormatted for SaslMechanisms {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 64,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:sasl-mechanisms:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_sasl_mechanisms_inner(input)
}
}
}
impl Encode for SaslMechanisms {
fn encoded_size(&self) -> usize {
encoded_size_sasl_mechanisms_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_sasl_mechanisms_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SaslInit {
pub mechanism: Symbol,
pub initial_response: Option<Bytes>,
pub hostname: Option<ByteString>,
}
impl SaslInit {
pub fn mechanism(&self) -> &Symbol {
&self.mechanism
}
pub fn initial_response(&self) -> Option<&Bytes> {
self.initial_response.as_ref()
}
pub fn hostname(&self) -> Option<&ByteString> {
self.hostname.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_sasl_init_inner(input: &[u8]) -> Result<(&[u8], SaslInit), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let mechanism: Symbol;
if count > 0 {
let (in1, decoded) = Symbol::decode(input)?;
mechanism = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("mechanism"));
}
let initial_response: Option<Bytes>;
if count > 0 {
let decoded = Option::<Bytes>::decode(input)?;
input = decoded.0;
initial_response = decoded.1;
count -= 1;
} else {
initial_response = None;
}
let hostname: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
hostname = decoded.1;
count -= 1;
} else {
hostname = None;
}
Ok((
remainder,
SaslInit {
mechanism,
initial_response,
hostname,
},
))
}
fn encoded_size_sasl_init_inner(list: &SaslInit) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.mechanism.encoded_size()
+ list.initial_response.encoded_size()
+ list.hostname.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_sasl_init_inner(list: &SaslInit, buf: &mut BytesMut) {
Descriptor::Ulong(65).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.mechanism.encoded_size()
+ list.initial_response.encoded_size()
+ list.hostname.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(SaslInit::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(SaslInit::FIELD_COUNT as u8);
}
list.mechanism.encode(buf);
list.initial_response.encode(buf);
list.hostname.encode(buf);
}
impl DecodeFormatted for SaslInit {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 65,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:sasl-init:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_sasl_init_inner(input)
}
}
}
impl Encode for SaslInit {
fn encoded_size(&self) -> usize {
encoded_size_sasl_init_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_sasl_init_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SaslChallenge {
pub challenge: Bytes,
}
impl SaslChallenge {
pub fn challenge(&self) -> &Bytes {
&self.challenge
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_sasl_challenge_inner(input: &[u8]) -> Result<(&[u8], SaslChallenge), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let challenge: Bytes;
if count > 0 {
let (in1, decoded) = Bytes::decode(input)?;
challenge = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("challenge"));
}
Ok((remainder, SaslChallenge { challenge }))
}
fn encoded_size_sasl_challenge_inner(list: &SaslChallenge) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.challenge.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_sasl_challenge_inner(list: &SaslChallenge, buf: &mut BytesMut) {
Descriptor::Ulong(66).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.challenge.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(SaslChallenge::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(SaslChallenge::FIELD_COUNT as u8);
}
list.challenge.encode(buf);
}
impl DecodeFormatted for SaslChallenge {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 66,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:sasl-challenge:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_sasl_challenge_inner(input)
}
}
}
impl Encode for SaslChallenge {
fn encoded_size(&self) -> usize {
encoded_size_sasl_challenge_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_sasl_challenge_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SaslResponse {
pub response: Bytes,
}
impl SaslResponse {
pub fn response(&self) -> &Bytes {
&self.response
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_sasl_response_inner(input: &[u8]) -> Result<(&[u8], SaslResponse), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let response: Bytes;
if count > 0 {
let (in1, decoded) = Bytes::decode(input)?;
response = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("response"));
}
Ok((remainder, SaslResponse { response }))
}
fn encoded_size_sasl_response_inner(list: &SaslResponse) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.response.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_sasl_response_inner(list: &SaslResponse, buf: &mut BytesMut) {
Descriptor::Ulong(67).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.response.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(SaslResponse::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(SaslResponse::FIELD_COUNT as u8);
}
list.response.encode(buf);
}
impl DecodeFormatted for SaslResponse {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 67,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:sasl-response:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_sasl_response_inner(input)
}
}
}
impl Encode for SaslResponse {
fn encoded_size(&self) -> usize {
encoded_size_sasl_response_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_sasl_response_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct SaslOutcome {
pub code: SaslCode,
pub additional_data: Option<Bytes>,
}
impl SaslOutcome {
pub fn code(&self) -> SaslCode {
self.code
}
pub fn additional_data(&self) -> Option<&Bytes> {
self.additional_data.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_sasl_outcome_inner(input: &[u8]) -> Result<(&[u8], SaslOutcome), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let code: SaslCode;
if count > 0 {
let (in1, decoded) = SaslCode::decode(input)?;
code = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("code"));
}
let additional_data: Option<Bytes>;
if count > 0 {
let decoded = Option::<Bytes>::decode(input)?;
input = decoded.0;
additional_data = decoded.1;
count -= 1;
} else {
additional_data = None;
}
Ok((
remainder,
SaslOutcome {
code,
additional_data,
},
))
}
fn encoded_size_sasl_outcome_inner(list: &SaslOutcome) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.code.encoded_size() + list.additional_data.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_sasl_outcome_inner(list: &SaslOutcome, buf: &mut BytesMut) {
Descriptor::Ulong(68).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.code.encoded_size() + list.additional_data.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(SaslOutcome::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(SaslOutcome::FIELD_COUNT as u8);
}
list.code.encode(buf);
list.additional_data.encode(buf);
}
impl DecodeFormatted for SaslOutcome {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 68,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:sasl-outcome:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_sasl_outcome_inner(input)
}
}
}
impl Encode for SaslOutcome {
fn encoded_size(&self) -> usize {
encoded_size_sasl_outcome_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_sasl_outcome_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Source {
pub address: Option<Address>,
pub durable: TerminusDurability,
pub expiry_policy: TerminusExpiryPolicy,
pub timeout: Seconds,
pub dynamic: bool,
pub dynamic_node_properties: Option<NodeProperties>,
pub distribution_mode: Option<DistributionMode>,
pub filter: Option<FilterSet>,
pub default_outcome: Option<Outcome>,
pub outcomes: Option<Symbols>,
pub capabilities: Option<Symbols>,
}
impl Source {
pub fn address(&self) -> Option<&Address> {
self.address.as_ref()
}
pub fn durable(&self) -> TerminusDurability {
self.durable
}
pub fn expiry_policy(&self) -> TerminusExpiryPolicy {
self.expiry_policy
}
pub fn timeout(&self) -> Seconds {
self.timeout
}
pub fn dynamic(&self) -> bool {
self.dynamic
}
pub fn dynamic_node_properties(&self) -> Option<&NodeProperties> {
self.dynamic_node_properties.as_ref()
}
pub fn distribution_mode(&self) -> Option<&DistributionMode> {
self.distribution_mode.as_ref()
}
pub fn filter(&self) -> Option<&FilterSet> {
self.filter.as_ref()
}
pub fn default_outcome(&self) -> Option<&Outcome> {
self.default_outcome.as_ref()
}
pub fn outcomes(&self) -> Option<&Symbols> {
self.outcomes.as_ref()
}
pub fn capabilities(&self) -> Option<&Symbols> {
self.capabilities.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_source_inner(input: &[u8]) -> Result<(&[u8], Source), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let address: Option<Address>;
if count > 0 {
let decoded = Option::<Address>::decode(input)?;
input = decoded.0;
address = decoded.1;
count -= 1;
} else {
address = None;
}
let durable: TerminusDurability;
if count > 0 {
let (in1, decoded) = Option::<TerminusDurability>::decode(input)?;
durable = decoded.unwrap_or(TerminusDurability::None);
input = in1;
count -= 1;
} else {
durable = TerminusDurability::None;
}
let expiry_policy: TerminusExpiryPolicy;
if count > 0 {
let (in1, decoded) = Option::<TerminusExpiryPolicy>::decode(input)?;
expiry_policy = decoded.unwrap_or(TerminusExpiryPolicy::SessionEnd);
input = in1;
count -= 1;
} else {
expiry_policy = TerminusExpiryPolicy::SessionEnd;
}
let timeout: Seconds;
if count > 0 {
let (in1, decoded) = Option::<Seconds>::decode(input)?;
timeout = decoded.unwrap_or(0);
input = in1;
count -= 1;
} else {
timeout = 0;
}
let dynamic: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
dynamic = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
dynamic = false;
}
let dynamic_node_properties: Option<NodeProperties>;
if count > 0 {
let decoded = Option::<NodeProperties>::decode(input)?;
input = decoded.0;
dynamic_node_properties = decoded.1;
count -= 1;
} else {
dynamic_node_properties = None;
}
let distribution_mode: Option<DistributionMode>;
if count > 0 {
let decoded = Option::<DistributionMode>::decode(input)?;
input = decoded.0;
distribution_mode = decoded.1;
count -= 1;
} else {
distribution_mode = None;
}
let filter: Option<FilterSet>;
if count > 0 {
let decoded = Option::<FilterSet>::decode(input)?;
input = decoded.0;
filter = decoded.1;
count -= 1;
} else {
filter = None;
}
let default_outcome: Option<Outcome>;
if count > 0 {
let decoded = Option::<Outcome>::decode(input)?;
input = decoded.0;
default_outcome = decoded.1;
count -= 1;
} else {
default_outcome = None;
}
let outcomes: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
outcomes = decoded.1;
count -= 1;
} else {
outcomes = None;
}
let capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
capabilities = decoded.1;
count -= 1;
} else {
capabilities = None;
}
Ok((
remainder,
Source {
address,
durable,
expiry_policy,
timeout,
dynamic,
dynamic_node_properties,
distribution_mode,
filter,
default_outcome,
outcomes,
capabilities,
},
))
}
fn encoded_size_source_inner(list: &Source) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.address.encoded_size()
+ list.durable.encoded_size()
+ list.expiry_policy.encoded_size()
+ list.timeout.encoded_size()
+ list.dynamic.encoded_size()
+ list.dynamic_node_properties.encoded_size()
+ list.distribution_mode.encoded_size()
+ list.filter.encoded_size()
+ list.default_outcome.encoded_size()
+ list.outcomes.encoded_size()
+ list.capabilities.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_source_inner(list: &Source, buf: &mut BytesMut) {
Descriptor::Ulong(40).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.address.encoded_size()
+ list.durable.encoded_size()
+ list.expiry_policy.encoded_size()
+ list.timeout.encoded_size()
+ list.dynamic.encoded_size()
+ list.dynamic_node_properties.encoded_size()
+ list.distribution_mode.encoded_size()
+ list.filter.encoded_size()
+ list.default_outcome.encoded_size()
+ list.outcomes.encoded_size()
+ list.capabilities.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Source::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Source::FIELD_COUNT as u8);
}
list.address.encode(buf);
list.durable.encode(buf);
list.expiry_policy.encode(buf);
list.timeout.encode(buf);
list.dynamic.encode(buf);
list.dynamic_node_properties.encode(buf);
list.distribution_mode.encode(buf);
list.filter.encode(buf);
list.default_outcome.encode(buf);
list.outcomes.encode(buf);
list.capabilities.encode(buf);
}
impl DecodeFormatted for Source {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 40,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:source:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_source_inner(input)
}
}
}
impl Encode for Source {
fn encoded_size(&self) -> usize {
encoded_size_source_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_source_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Target {
pub address: Option<Address>,
pub durable: TerminusDurability,
pub expiry_policy: TerminusExpiryPolicy,
pub timeout: Seconds,
pub dynamic: bool,
pub dynamic_node_properties: Option<NodeProperties>,
pub capabilities: Option<Symbols>,
}
impl Target {
pub fn address(&self) -> Option<&Address> {
self.address.as_ref()
}
pub fn durable(&self) -> TerminusDurability {
self.durable
}
pub fn expiry_policy(&self) -> TerminusExpiryPolicy {
self.expiry_policy
}
pub fn timeout(&self) -> Seconds {
self.timeout
}
pub fn dynamic(&self) -> bool {
self.dynamic
}
pub fn dynamic_node_properties(&self) -> Option<&NodeProperties> {
self.dynamic_node_properties.as_ref()
}
pub fn capabilities(&self) -> Option<&Symbols> {
self.capabilities.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_target_inner(input: &[u8]) -> Result<(&[u8], Target), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let address: Option<Address>;
if count > 0 {
let decoded = Option::<Address>::decode(input)?;
input = decoded.0;
address = decoded.1;
count -= 1;
} else {
address = None;
}
let durable: TerminusDurability;
if count > 0 {
let (in1, decoded) = Option::<TerminusDurability>::decode(input)?;
durable = decoded.unwrap_or(TerminusDurability::None);
input = in1;
count -= 1;
} else {
durable = TerminusDurability::None;
}
let expiry_policy: TerminusExpiryPolicy;
if count > 0 {
let (in1, decoded) = Option::<TerminusExpiryPolicy>::decode(input)?;
expiry_policy = decoded.unwrap_or(TerminusExpiryPolicy::SessionEnd);
input = in1;
count -= 1;
} else {
expiry_policy = TerminusExpiryPolicy::SessionEnd;
}
let timeout: Seconds;
if count > 0 {
let (in1, decoded) = Option::<Seconds>::decode(input)?;
timeout = decoded.unwrap_or(0);
input = in1;
count -= 1;
} else {
timeout = 0;
}
let dynamic: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
dynamic = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
dynamic = false;
}
let dynamic_node_properties: Option<NodeProperties>;
if count > 0 {
let decoded = Option::<NodeProperties>::decode(input)?;
input = decoded.0;
dynamic_node_properties = decoded.1;
count -= 1;
} else {
dynamic_node_properties = None;
}
let capabilities: Option<Symbols>;
if count > 0 {
let decoded = Option::<Symbols>::decode(input)?;
input = decoded.0;
capabilities = decoded.1;
count -= 1;
} else {
capabilities = None;
}
Ok((
remainder,
Target {
address,
durable,
expiry_policy,
timeout,
dynamic,
dynamic_node_properties,
capabilities,
},
))
}
fn encoded_size_target_inner(list: &Target) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.address.encoded_size()
+ list.durable.encoded_size()
+ list.expiry_policy.encoded_size()
+ list.timeout.encoded_size()
+ list.dynamic.encoded_size()
+ list.dynamic_node_properties.encoded_size()
+ list.capabilities.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_target_inner(list: &Target, buf: &mut BytesMut) {
Descriptor::Ulong(41).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.address.encoded_size()
+ list.durable.encoded_size()
+ list.expiry_policy.encoded_size()
+ list.timeout.encoded_size()
+ list.dynamic.encoded_size()
+ list.dynamic_node_properties.encoded_size()
+ list.capabilities.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Target::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Target::FIELD_COUNT as u8);
}
list.address.encode(buf);
list.durable.encode(buf);
list.expiry_policy.encode(buf);
list.timeout.encode(buf);
list.dynamic.encode(buf);
list.dynamic_node_properties.encode(buf);
list.capabilities.encode(buf);
}
impl DecodeFormatted for Target {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 41,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:target:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_target_inner(input)
}
}
}
impl Encode for Target {
fn encoded_size(&self) -> usize {
encoded_size_target_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_target_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Header {
pub durable: bool,
pub priority: u8,
pub ttl: Option<Milliseconds>,
pub first_acquirer: bool,
pub delivery_count: u32,
}
impl Header {
pub fn durable(&self) -> bool {
self.durable
}
pub fn priority(&self) -> u8 {
self.priority
}
pub fn ttl(&self) -> Option<Milliseconds> {
self.ttl
}
pub fn first_acquirer(&self) -> bool {
self.first_acquirer
}
pub fn delivery_count(&self) -> u32 {
self.delivery_count
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_header_inner(input: &[u8]) -> Result<(&[u8], Header), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let durable: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
durable = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
durable = false;
}
let priority: u8;
if count > 0 {
let (in1, decoded) = Option::<u8>::decode(input)?;
priority = decoded.unwrap_or(4);
input = in1;
count -= 1;
} else {
priority = 4;
}
let ttl: Option<Milliseconds>;
if count > 0 {
let decoded = Option::<Milliseconds>::decode(input)?;
input = decoded.0;
ttl = decoded.1;
count -= 1;
} else {
ttl = None;
}
let first_acquirer: bool;
if count > 0 {
let (in1, decoded) = Option::<bool>::decode(input)?;
first_acquirer = decoded.unwrap_or(false);
input = in1;
count -= 1;
} else {
first_acquirer = false;
}
let delivery_count: u32;
if count > 0 {
let (in1, decoded) = Option::<u32>::decode(input)?;
delivery_count = decoded.unwrap_or(0);
input = in1;
count -= 1;
} else {
delivery_count = 0;
}
Ok((
remainder,
Header {
durable,
priority,
ttl,
first_acquirer,
delivery_count,
},
))
}
fn encoded_size_header_inner(list: &Header) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.durable.encoded_size()
+ list.priority.encoded_size()
+ list.ttl.encoded_size()
+ list.first_acquirer.encoded_size()
+ list.delivery_count.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_header_inner(list: &Header, buf: &mut BytesMut) {
Descriptor::Ulong(112).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.durable.encoded_size()
+ list.priority.encoded_size()
+ list.ttl.encoded_size()
+ list.first_acquirer.encoded_size()
+ list.delivery_count.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Header::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Header::FIELD_COUNT as u8);
}
list.durable.encode(buf);
list.priority.encode(buf);
list.ttl.encode(buf);
list.first_acquirer.encode(buf);
list.delivery_count.encode(buf);
}
impl DecodeFormatted for Header {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 112,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:header:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_header_inner(input)
}
}
}
impl Encode for Header {
fn encoded_size(&self) -> usize {
encoded_size_header_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_header_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Properties {
pub message_id: Option<MessageId>,
pub user_id: Option<Bytes>,
pub to: Option<Address>,
pub subject: Option<ByteString>,
pub reply_to: Option<Address>,
pub correlation_id: Option<MessageId>,
pub content_type: Option<Symbol>,
pub content_encoding: Option<Symbol>,
pub absolute_expiry_time: Option<Timestamp>,
pub creation_time: Option<Timestamp>,
pub group_id: Option<ByteString>,
pub group_sequence: Option<SequenceNo>,
pub reply_to_group_id: Option<ByteString>,
}
impl Properties {
pub fn message_id(&self) -> Option<&MessageId> {
self.message_id.as_ref()
}
pub fn user_id(&self) -> Option<&Bytes> {
self.user_id.as_ref()
}
pub fn to(&self) -> Option<&Address> {
self.to.as_ref()
}
pub fn subject(&self) -> Option<&ByteString> {
self.subject.as_ref()
}
pub fn reply_to(&self) -> Option<&Address> {
self.reply_to.as_ref()
}
pub fn correlation_id(&self) -> Option<&MessageId> {
self.correlation_id.as_ref()
}
pub fn content_type(&self) -> Option<&Symbol> {
self.content_type.as_ref()
}
pub fn content_encoding(&self) -> Option<&Symbol> {
self.content_encoding.as_ref()
}
pub fn absolute_expiry_time(&self) -> Option<Timestamp> {
self.absolute_expiry_time
}
pub fn creation_time(&self) -> Option<Timestamp> {
self.creation_time
}
pub fn group_id(&self) -> Option<&ByteString> {
self.group_id.as_ref()
}
pub fn group_sequence(&self) -> Option<SequenceNo> {
self.group_sequence
}
pub fn reply_to_group_id(&self) -> Option<&ByteString> {
self.reply_to_group_id.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_properties_inner(input: &[u8]) -> Result<(&[u8], Properties), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let message_id: Option<MessageId>;
if count > 0 {
let decoded = Option::<MessageId>::decode(input)?;
input = decoded.0;
message_id = decoded.1;
count -= 1;
} else {
message_id = None;
}
let user_id: Option<Bytes>;
if count > 0 {
let decoded = Option::<Bytes>::decode(input)?;
input = decoded.0;
user_id = decoded.1;
count -= 1;
} else {
user_id = None;
}
let to: Option<Address>;
if count > 0 {
let decoded = Option::<Address>::decode(input)?;
input = decoded.0;
to = decoded.1;
count -= 1;
} else {
to = None;
}
let subject: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
subject = decoded.1;
count -= 1;
} else {
subject = None;
}
let reply_to: Option<Address>;
if count > 0 {
let decoded = Option::<Address>::decode(input)?;
input = decoded.0;
reply_to = decoded.1;
count -= 1;
} else {
reply_to = None;
}
let correlation_id: Option<MessageId>;
if count > 0 {
let decoded = Option::<MessageId>::decode(input)?;
input = decoded.0;
correlation_id = decoded.1;
count -= 1;
} else {
correlation_id = None;
}
let content_type: Option<Symbol>;
if count > 0 {
let decoded = Option::<Symbol>::decode(input)?;
input = decoded.0;
content_type = decoded.1;
count -= 1;
} else {
content_type = None;
}
let content_encoding: Option<Symbol>;
if count > 0 {
let decoded = Option::<Symbol>::decode(input)?;
input = decoded.0;
content_encoding = decoded.1;
count -= 1;
} else {
content_encoding = None;
}
let absolute_expiry_time: Option<Timestamp>;
if count > 0 {
let decoded = Option::<Timestamp>::decode(input)?;
input = decoded.0;
absolute_expiry_time = decoded.1;
count -= 1;
} else {
absolute_expiry_time = None;
}
let creation_time: Option<Timestamp>;
if count > 0 {
let decoded = Option::<Timestamp>::decode(input)?;
input = decoded.0;
creation_time = decoded.1;
count -= 1;
} else {
creation_time = None;
}
let group_id: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
group_id = decoded.1;
count -= 1;
} else {
group_id = None;
}
let group_sequence: Option<SequenceNo>;
if count > 0 {
let decoded = Option::<SequenceNo>::decode(input)?;
input = decoded.0;
group_sequence = decoded.1;
count -= 1;
} else {
group_sequence = None;
}
let reply_to_group_id: Option<ByteString>;
if count > 0 {
let decoded = Option::<ByteString>::decode(input)?;
input = decoded.0;
reply_to_group_id = decoded.1;
count -= 1;
} else {
reply_to_group_id = None;
}
Ok((
remainder,
Properties {
message_id,
user_id,
to,
subject,
reply_to,
correlation_id,
content_type,
content_encoding,
absolute_expiry_time,
creation_time,
group_id,
group_sequence,
reply_to_group_id,
},
))
}
fn encoded_size_properties_inner(list: &Properties) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.message_id.encoded_size()
+ list.user_id.encoded_size()
+ list.to.encoded_size()
+ list.subject.encoded_size()
+ list.reply_to.encoded_size()
+ list.correlation_id.encoded_size()
+ list.content_type.encoded_size()
+ list.content_encoding.encoded_size()
+ list.absolute_expiry_time.encoded_size()
+ list.creation_time.encoded_size()
+ list.group_id.encoded_size()
+ list.group_sequence.encoded_size()
+ list.reply_to_group_id.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_properties_inner(list: &Properties, buf: &mut BytesMut) {
Descriptor::Ulong(115).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.message_id.encoded_size()
+ list.user_id.encoded_size()
+ list.to.encoded_size()
+ list.subject.encoded_size()
+ list.reply_to.encoded_size()
+ list.correlation_id.encoded_size()
+ list.content_type.encoded_size()
+ list.content_encoding.encoded_size()
+ list.absolute_expiry_time.encoded_size()
+ list.creation_time.encoded_size()
+ list.group_id.encoded_size()
+ list.group_sequence.encoded_size()
+ list.reply_to_group_id.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Properties::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Properties::FIELD_COUNT as u8);
}
list.message_id.encode(buf);
list.user_id.encode(buf);
list.to.encode(buf);
list.subject.encode(buf);
list.reply_to.encode(buf);
list.correlation_id.encode(buf);
list.content_type.encode(buf);
list.content_encoding.encode(buf);
list.absolute_expiry_time.encode(buf);
list.creation_time.encode(buf);
list.group_id.encode(buf);
list.group_sequence.encode(buf);
list.reply_to_group_id.encode(buf);
}
impl DecodeFormatted for Properties {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 115,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:properties:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_properties_inner(input)
}
}
}
impl Encode for Properties {
fn encoded_size(&self) -> usize {
encoded_size_properties_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_properties_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Received {
pub section_number: u32,
pub section_offset: u64,
}
impl Received {
pub fn section_number(&self) -> u32 {
self.section_number
}
pub fn section_offset(&self) -> u64 {
self.section_offset
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_received_inner(input: &[u8]) -> Result<(&[u8], Received), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let section_number: u32;
if count > 0 {
let (in1, decoded) = u32::decode(input)?;
section_number = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("section_number"));
}
let section_offset: u64;
if count > 0 {
let (in1, decoded) = u64::decode(input)?;
section_offset = decoded;
input = in1;
count -= 1;
} else {
return Err(AmqpParseError::RequiredFieldOmitted("section_offset"));
}
Ok((
remainder,
Received {
section_number,
section_offset,
},
))
}
fn encoded_size_received_inner(list: &Received) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.section_number.encoded_size() + list.section_offset.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_received_inner(list: &Received, buf: &mut BytesMut) {
Descriptor::Ulong(35).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.section_number.encoded_size() + list.section_offset.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Received::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Received::FIELD_COUNT as u8);
}
list.section_number.encode(buf);
list.section_offset.encode(buf);
}
impl DecodeFormatted for Received {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 35,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:received:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_received_inner(input)
}
}
}
impl Encode for Received {
fn encoded_size(&self) -> usize {
encoded_size_received_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_received_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Accepted {}
impl Accepted {
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0;
}
#[allow(unused_mut)]
fn decode_accepted_inner(input: &[u8]) -> Result<(&[u8], Accepted), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let mut remainder = &input[size..];
Ok((remainder, Accepted {}))
}
fn encoded_size_accepted_inner(list: &Accepted) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0;
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_accepted_inner(list: &Accepted, buf: &mut BytesMut) {
Descriptor::Ulong(36).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0;
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Accepted::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Accepted::FIELD_COUNT as u8);
}
}
impl DecodeFormatted for Accepted {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 36,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:accepted:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_accepted_inner(input)
}
}
}
impl Encode for Accepted {
fn encoded_size(&self) -> usize {
encoded_size_accepted_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_accepted_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Rejected {
pub error: Option<Error>,
}
impl Rejected {
pub fn error(&self) -> Option<&Error> {
self.error.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1;
}
#[allow(unused_mut)]
fn decode_rejected_inner(input: &[u8]) -> Result<(&[u8], Rejected), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let error: Option<Error>;
if count > 0 {
let decoded = Option::<Error>::decode(input)?;
input = decoded.0;
error = decoded.1;
count -= 1;
} else {
error = None;
}
Ok((remainder, Rejected { error }))
}
fn encoded_size_rejected_inner(list: &Rejected) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_rejected_inner(list: &Rejected, buf: &mut BytesMut) {
Descriptor::Ulong(37).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0 + list.error.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Rejected::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Rejected::FIELD_COUNT as u8);
}
list.error.encode(buf);
}
impl DecodeFormatted for Rejected {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 37,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:rejected:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_rejected_inner(input)
}
}
}
impl Encode for Rejected {
fn encoded_size(&self) -> usize {
encoded_size_rejected_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_rejected_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Released {}
impl Released {
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0;
}
#[allow(unused_mut)]
fn decode_released_inner(input: &[u8]) -> Result<(&[u8], Released), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let mut remainder = &input[size..];
Ok((remainder, Released {}))
}
fn encoded_size_released_inner(list: &Released) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0;
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_released_inner(list: &Released, buf: &mut BytesMut) {
Descriptor::Ulong(38).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0;
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Released::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Released::FIELD_COUNT as u8);
}
}
impl DecodeFormatted for Released {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 38,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:released:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_released_inner(input)
}
}
}
impl Encode for Released {
fn encoded_size(&self) -> usize {
encoded_size_released_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_released_inner(self, buf)
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Modified {
pub delivery_failed: Option<bool>,
pub undeliverable_here: Option<bool>,
pub message_annotations: Option<Fields>,
}
impl Modified {
pub fn delivery_failed(&self) -> Option<bool> {
self.delivery_failed
}
pub fn undeliverable_here(&self) -> Option<bool> {
self.undeliverable_here
}
pub fn message_annotations(&self) -> Option<&Fields> {
self.message_annotations.as_ref()
}
#[allow(clippy::identity_op)]
const FIELD_COUNT: usize = 0 + 1 + 1 + 1;
}
#[allow(unused_mut)]
fn decode_modified_inner(input: &[u8]) -> Result<(&[u8], Modified), AmqpParseError> {
let (input, format) = decode_format_code(input)?;
let (input, header) = decode_list_header(input, format)?;
let size = header.size as usize;
decode_check_len!(input, size);
let (mut input, mut remainder) = input.split_at(size);
let mut count = header.count;
let delivery_failed: Option<bool>;
if count > 0 {
let decoded = Option::<bool>::decode(input)?;
input = decoded.0;
delivery_failed = decoded.1;
count -= 1;
} else {
delivery_failed = None;
}
let undeliverable_here: Option<bool>;
if count > 0 {
let decoded = Option::<bool>::decode(input)?;
input = decoded.0;
undeliverable_here = decoded.1;
count -= 1;
} else {
undeliverable_here = None;
}
let message_annotations: Option<Fields>;
if count > 0 {
let decoded = Option::<Fields>::decode(input)?;
input = decoded.0;
message_annotations = decoded.1;
count -= 1;
} else {
message_annotations = None;
}
Ok((
remainder,
Modified {
delivery_failed,
undeliverable_here,
message_annotations,
},
))
}
fn encoded_size_modified_inner(list: &Modified) -> usize {
#[allow(clippy::identity_op)]
let content_size = 0
+ list.delivery_failed.encoded_size()
+ list.undeliverable_here.encoded_size()
+ list.message_annotations.encoded_size();
(if content_size + 1 > u8::MAX as usize {
12
} else {
6
}) + content_size
}
fn encode_modified_inner(list: &Modified, buf: &mut BytesMut) {
Descriptor::Ulong(39).encode(buf);
#[allow(clippy::identity_op)]
let content_size = 0
+ list.delivery_failed.encoded_size()
+ list.undeliverable_here.encoded_size()
+ list.message_annotations.encoded_size();
if content_size + 1 > u8::MAX as usize {
buf.put_u8(codec::FORMATCODE_LIST32);
buf.put_u32((content_size + 4) as u32); buf.put_u32(Modified::FIELD_COUNT as u32);
} else {
buf.put_u8(codec::FORMATCODE_LIST8);
buf.put_u8((content_size + 1) as u8);
buf.put_u8(Modified::FIELD_COUNT as u8);
}
list.delivery_failed.encode(buf);
list.undeliverable_here.encode(buf);
list.message_annotations.encode(buf);
}
impl DecodeFormatted for Modified {
fn decode_with_format(input: &[u8], fmt: u8) -> Result<(&[u8], Self), AmqpParseError> {
validate_code!(fmt, codec::FORMATCODE_DESCRIBED);
let (input, descriptor) = Descriptor::decode(input)?;
let is_match = match descriptor {
Descriptor::Ulong(val) => val == 39,
Descriptor::Symbol(ref sym) => sym.as_bytes() == b"amqp:modified:list",
};
if !is_match {
Err(AmqpParseError::InvalidDescriptor(descriptor))
} else {
decode_modified_inner(input)
}
}
}
impl Encode for Modified {
fn encoded_size(&self) -> usize {
encoded_size_modified_inner(self)
}
fn encode(&self, buf: &mut BytesMut) {
encode_modified_inner(self, buf)
}
}