use crate::types::{
*,
flags::*,
generation::*,
parsing::*,
};
use nom::combinator::{flat_map, map, map_opt};
pub mod metadata {
use super::*;
pub const NAME: &str = "AMQP";
pub const MAJOR_VERSION: ShortShortUInt = 0;
pub const MINOR_VERSION: ShortShortUInt = 9;
pub const REVISION: ShortShortUInt = 1;
pub const PORT: LongUInt = 5672;
pub const COPYRIGHT: &str = r#"Copyright (C) 2008-2016 Pivotal Software, Inc, Inc.
Permission is hereby granted, free of charge, to any person
obtaining a copy of this file (the "Software"), to deal in the
Software without restriction, including without limitation the
rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit
persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
OTHER DEALINGS IN THE SOFTWARE.
Class information entered from amqp_xml0-8.pdf and domain types from amqp-xml-doc0-9.pdf
Updated for 0-9-1 by Tony Garnock-Jones
b3cb053f15e7b98808c0ccc67f23cb3e amqp_xml0-8.pdf
http://twiststandards.org/?option=com_docman&task=cat_view&gid=28&Itemid=90
8444db91e2949dbecfb2585e9eef6d64 amqp-xml-doc0-9.pdf
https://jira.amqp.org/confluence/download/attachments/720900/amqp-xml-doc0-9.pdf?version=1
"#;
}
pub mod constants {
use super::*;
pub const FRAME_METHOD: ShortShortUInt = 1;
pub const FRAME_HEADER: ShortShortUInt = 2;
pub const FRAME_BODY: ShortShortUInt = 3;
pub const FRAME_HEARTBEAT: ShortShortUInt = 8;
pub const FRAME_MIN_SIZE: ShortUInt = 4096;
pub const FRAME_END: ShortShortUInt = 206;
pub const REPLY_SUCCESS: ShortShortUInt = 200;
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPError {
Soft(AMQPSoftError),
Hard(AMQPHardError),
}
impl AMQPError {
pub fn get_id(&self) -> ShortUInt {
match *self {
AMQPError::Soft(ref s) => s.get_id(),
AMQPError::Hard(ref h) => h.get_id(),
}
}
pub fn from_id(id: ShortUInt) -> Option<AMQPError> {
AMQPSoftError::from_id(id).map(AMQPError::Soft).or_else(|| AMQPHardError::from_id(id).map(AMQPError::Hard))
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPSoftError {
CONTENTTOOLARGE,
NOROUTE,
NOCONSUMERS,
ACCESSREFUSED,
NOTFOUND,
RESOURCELOCKED,
PRECONDITIONFAILED,
}
impl AMQPSoftError {
pub fn get_id(&self) -> ShortUInt {
match *self {
AMQPSoftError::CONTENTTOOLARGE => 311,
AMQPSoftError::NOROUTE => 312,
AMQPSoftError::NOCONSUMERS => 313,
AMQPSoftError::ACCESSREFUSED => 403,
AMQPSoftError::NOTFOUND => 404,
AMQPSoftError::RESOURCELOCKED => 405,
AMQPSoftError::PRECONDITIONFAILED => 406,
}
}
pub fn from_id(id: ShortUInt) -> Option<AMQPSoftError> {
match id {
311 => Some(AMQPSoftError::CONTENTTOOLARGE),
312 => Some(AMQPSoftError::NOROUTE),
313 => Some(AMQPSoftError::NOCONSUMERS),
403 => Some(AMQPSoftError::ACCESSREFUSED),
404 => Some(AMQPSoftError::NOTFOUND),
405 => Some(AMQPSoftError::RESOURCELOCKED),
406 => Some(AMQPSoftError::PRECONDITIONFAILED),
_ => None,
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPHardError {
CONNECTIONFORCED,
INVALIDPATH,
FRAMEERROR,
SYNTAXERROR,
COMMANDINVALID,
CHANNELERROR,
UNEXPECTEDFRAME,
RESOURCEERROR,
NOTALLOWED,
NOTIMPLEMENTED,
INTERNALERROR,
}
impl AMQPHardError {
pub fn get_id(&self) -> ShortUInt {
match *self {
AMQPHardError::CONNECTIONFORCED => 320,
AMQPHardError::INVALIDPATH => 402,
AMQPHardError::FRAMEERROR => 501,
AMQPHardError::SYNTAXERROR => 502,
AMQPHardError::COMMANDINVALID => 503,
AMQPHardError::CHANNELERROR => 504,
AMQPHardError::UNEXPECTEDFRAME => 505,
AMQPHardError::RESOURCEERROR => 506,
AMQPHardError::NOTALLOWED => 530,
AMQPHardError::NOTIMPLEMENTED => 540,
AMQPHardError::INTERNALERROR => 541,
}
}
pub fn from_id(id: ShortUInt) -> Option<AMQPHardError> {
match id {
320 => Some(AMQPHardError::CONNECTIONFORCED),
402 => Some(AMQPHardError::INVALIDPATH),
501 => Some(AMQPHardError::FRAMEERROR),
502 => Some(AMQPHardError::SYNTAXERROR),
503 => Some(AMQPHardError::COMMANDINVALID),
504 => Some(AMQPHardError::CHANNELERROR),
505 => Some(AMQPHardError::UNEXPECTEDFRAME),
506 => Some(AMQPHardError::RESOURCEERROR),
530 => Some(AMQPHardError::NOTALLOWED),
540 => Some(AMQPHardError::NOTIMPLEMENTED),
541 => Some(AMQPHardError::INTERNALERROR),
_ => None,
}
}
}
use self::connection::parse_connection;
use self::channel::parse_channel;
use self::access::parse_access;
use self::exchange::parse_exchange;
use self::queue::parse_queue;
use self::basic::parse_basic;
use self::tx::parse_tx;
use self::confirm::parse_confirm;
pub fn parse_class(i: &[u8]) -> ParserResult<'_, AMQPClass> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_connection, AMQPClass::Connection), Some)(i),
20 => map(map(parse_channel, AMQPClass::Channel), Some)(i),
30 => map(map(parse_access, AMQPClass::Access), Some)(i),
40 => map(map(parse_exchange, AMQPClass::Exchange), Some)(i),
50 => map(map(parse_queue, AMQPClass::Queue), Some)(i),
60 => map(map(parse_basic, AMQPClass::Basic), Some)(i),
90 => map(map(parse_tx, AMQPClass::Tx), Some)(i),
85 => map(map(parse_confirm, AMQPClass::Confirm), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_class<'a>(input: &'a mut [u8], class: &'a AMQPClass) -> GenResult<'a> {
match *class {
AMQPClass::Connection(ref connection) => connection::gen_connection(input, connection),
AMQPClass::Channel(ref channel) => channel::gen_channel(input, channel),
AMQPClass::Access(ref access) => access::gen_access(input, access),
AMQPClass::Exchange(ref exchange) => exchange::gen_exchange(input, exchange),
AMQPClass::Queue(ref queue) => queue::gen_queue(input, queue),
AMQPClass::Basic(ref basic) => basic::gen_basic(input, basic),
AMQPClass::Tx(ref tx) => tx::gen_tx(input, tx),
AMQPClass::Confirm(ref confirm) => confirm::gen_confirm(input, confirm),
}
}
impl GenSize for AMQPClass {
fn get_gen_size(&self) -> usize {
match self {
AMQPClass::Connection(m) => m.get_gen_size(),
AMQPClass::Channel(m) => m.get_gen_size(),
AMQPClass::Access(m) => m.get_gen_size(),
AMQPClass::Exchange(m) => m.get_gen_size(),
AMQPClass::Queue(m) => m.get_gen_size(),
AMQPClass::Basic(m) => m.get_gen_size(),
AMQPClass::Tx(m) => m.get_gen_size(),
AMQPClass::Confirm(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPClass {
Connection(connection::AMQPMethod),
Channel(channel::AMQPMethod),
Access(access::AMQPMethod),
Exchange(exchange::AMQPMethod),
Queue(queue::AMQPMethod),
Basic(basic::AMQPMethod),
Tx(tx::AMQPMethod),
Confirm(confirm::AMQPMethod),
}
impl AMQPClass {
pub fn get_amqp_class_id(&self) -> u16 {
match self {
AMQPClass::Connection(_) => 10,
AMQPClass::Channel(_) => 20,
AMQPClass::Access(_) => 30,
AMQPClass::Exchange(_) => 40,
AMQPClass::Queue(_) => 50,
AMQPClass::Basic(_) => 60,
AMQPClass::Tx(_) => 90,
AMQPClass::Confirm(_) => 85,
}
}
}
pub mod connection {
use super::*;
pub fn parse_connection(i: &[u8]) -> ParserResult<'_, connection::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_start, AMQPMethod::Start), Some)(i),
11 => map(map(parse_start_ok, AMQPMethod::StartOk), Some)(i),
20 => map(map(parse_secure, AMQPMethod::Secure), Some)(i),
21 => map(map(parse_secure_ok, AMQPMethod::SecureOk), Some)(i),
30 => map(map(parse_tune, AMQPMethod::Tune), Some)(i),
31 => map(map(parse_tune_ok, AMQPMethod::TuneOk), Some)(i),
40 => map(map(parse_open, AMQPMethod::Open), Some)(i),
41 => map(map(parse_open_ok, AMQPMethod::OpenOk), Some)(i),
50 => map(map(parse_close, AMQPMethod::Close), Some)(i),
51 => map(map(parse_close_ok, AMQPMethod::CloseOk), Some)(i),
60 => map(map(parse_blocked, AMQPMethod::Blocked), Some)(i),
61 => map(map(parse_unblocked, AMQPMethod::Unblocked), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_connection<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Start(ref start) => {
gen_start(gen_id(input, 10)?, start)
},
AMQPMethod::StartOk(ref start_ok) => {
gen_start_ok(gen_id(input, 10)?, start_ok)
},
AMQPMethod::Secure(ref secure) => {
gen_secure(gen_id(input, 10)?, secure)
},
AMQPMethod::SecureOk(ref secure_ok) => {
gen_secure_ok(gen_id(input, 10)?, secure_ok)
},
AMQPMethod::Tune(ref tune) => {
gen_tune(gen_id(input, 10)?, tune)
},
AMQPMethod::TuneOk(ref tune_ok) => {
gen_tune_ok(gen_id(input, 10)?, tune_ok)
},
AMQPMethod::Open(ref open) => {
gen_open(gen_id(input, 10)?, open)
},
AMQPMethod::OpenOk(ref open_ok) => {
gen_open_ok(gen_id(input, 10)?, open_ok)
},
AMQPMethod::Close(ref close) => {
gen_close(gen_id(input, 10)?, close)
},
AMQPMethod::CloseOk(ref close_ok) => {
gen_close_ok(gen_id(input, 10)?, close_ok)
},
AMQPMethod::Blocked(ref blocked) => {
gen_blocked(gen_id(input, 10)?, blocked)
},
AMQPMethod::Unblocked(ref unblocked) => {
gen_unblocked(gen_id(input, 10)?, unblocked)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Start(m) => m.get_gen_size(),
AMQPMethod::StartOk(m) => m.get_gen_size(),
AMQPMethod::Secure(m) => m.get_gen_size(),
AMQPMethod::SecureOk(m) => m.get_gen_size(),
AMQPMethod::Tune(m) => m.get_gen_size(),
AMQPMethod::TuneOk(m) => m.get_gen_size(),
AMQPMethod::Open(m) => m.get_gen_size(),
AMQPMethod::OpenOk(m) => m.get_gen_size(),
AMQPMethod::Close(m) => m.get_gen_size(),
AMQPMethod::CloseOk(m) => m.get_gen_size(),
AMQPMethod::Blocked(m) => m.get_gen_size(),
AMQPMethod::Unblocked(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Start(Start),
StartOk(StartOk),
Secure(Secure),
SecureOk(SecureOk),
Tune(Tune),
TuneOk(TuneOk),
Open(Open),
OpenOk(OpenOk),
Close(Close),
CloseOk(CloseOk),
Blocked(Blocked),
Unblocked(Unblocked),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Start {
pub version_major: ShortShortUInt,
pub version_minor: ShortShortUInt,
pub server_properties: FieldTable,
pub mechanisms: LongString,
pub locales: LongString,
}
impl Start {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_start(i: &[u8]) -> ParserResult<'_, Start> {
let (i, version_major) = parse_short_short_uint(i)?;
let (i, version_minor) = parse_short_short_uint(i)?;
let (i, server_properties) = parse_field_table(i)?;
let (i, mechanisms) = parse_long_string(i)?;
let (i, locales) = parse_long_string(i)?;
Ok((i, Start {
version_major,
version_minor,
server_properties,
mechanisms,
locales,
}))
}
pub fn gen_start<'a>(input: &'a mut [u8], method: &'a Start) -> GenResult<'a> {
let input = gen_id(input, 10)?;
let input = gen_short_short_uint(input, method.version_major)?;
let input = gen_short_short_uint(input, method.version_minor)?;
let input = gen_field_table(input, &method.server_properties)?;
let input = gen_long_string(input, method.mechanisms.as_ref())?;
let input = gen_long_string(input, method.locales.as_ref())?;
Ok(input)
}
impl GenSize for Start {
fn get_gen_size(&self) -> usize {
2
+ self.version_major.get_gen_size()
+ self.version_minor.get_gen_size()
+ self.server_properties.get_gen_size()
+ self.mechanisms.get_gen_size()
+ self.locales.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct StartOk {
pub client_properties: FieldTable,
pub mechanism: ShortString,
pub response: LongString,
pub locale: ShortString,
}
impl StartOk {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_start_ok(i: &[u8]) -> ParserResult<'_, StartOk> {
let (i, client_properties) = parse_field_table(i)?;
let (i, mechanism) = parse_short_string(i)?;
let (i, response) = parse_long_string(i)?;
let (i, locale) = parse_short_string(i)?;
Ok((i, StartOk {
client_properties,
mechanism,
response,
locale,
}))
}
pub fn gen_start_ok<'a>(input: &'a mut [u8], method: &'a StartOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
let input = gen_field_table(input, &method.client_properties)?;
let input = gen_short_string(input, method.mechanism.as_ref())?;
let input = gen_long_string(input, method.response.as_ref())?;
let input = gen_short_string(input, method.locale.as_ref())?;
Ok(input)
}
impl GenSize for StartOk {
fn get_gen_size(&self) -> usize {
2
+ self.client_properties.get_gen_size()
+ self.mechanism.get_gen_size()
+ self.response.get_gen_size()
+ self.locale.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Secure {
pub challenge: LongString,
}
impl Secure {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_secure(i: &[u8]) -> ParserResult<'_, Secure> {
let (i, challenge) = parse_long_string(i)?;
Ok((i, Secure {
challenge,
}))
}
pub fn gen_secure<'a>(input: &'a mut [u8], method: &'a Secure) -> GenResult<'a> {
let input = gen_id(input, 20)?;
let input = gen_long_string(input, method.challenge.as_ref())?;
Ok(input)
}
impl GenSize for Secure {
fn get_gen_size(&self) -> usize {
2
+ self.challenge.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SecureOk {
pub response: LongString,
}
impl SecureOk {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_secure_ok(i: &[u8]) -> ParserResult<'_, SecureOk> {
let (i, response) = parse_long_string(i)?;
Ok((i, SecureOk {
response,
}))
}
pub fn gen_secure_ok<'a>(input: &'a mut [u8], method: &'a SecureOk) -> GenResult<'a> {
let input = gen_id(input, 21)?;
let input = gen_long_string(input, method.response.as_ref())?;
Ok(input)
}
impl GenSize for SecureOk {
fn get_gen_size(&self) -> usize {
2
+ self.response.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Tune {
pub channel_max: ShortUInt,
pub frame_max: LongUInt,
pub heartbeat: ShortUInt,
}
impl Tune {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
30
}
}
pub fn parse_tune(i: &[u8]) -> ParserResult<'_, Tune> {
let (i, channel_max) = parse_short_uint(i)?;
let (i, frame_max) = parse_long_uint(i)?;
let (i, heartbeat) = parse_short_uint(i)?;
Ok((i, Tune {
channel_max,
frame_max,
heartbeat,
}))
}
pub fn gen_tune<'a>(input: &'a mut [u8], method: &'a Tune) -> GenResult<'a> {
let input = gen_id(input, 30)?;
let input = gen_short_uint(input, method.channel_max)?;
let input = gen_long_uint(input, method.frame_max)?;
let input = gen_short_uint(input, method.heartbeat)?;
Ok(input)
}
impl GenSize for Tune {
fn get_gen_size(&self) -> usize {
2
+ self.channel_max.get_gen_size()
+ self.frame_max.get_gen_size()
+ self.heartbeat.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct TuneOk {
pub channel_max: ShortUInt,
pub frame_max: LongUInt,
pub heartbeat: ShortUInt,
}
impl TuneOk {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
31
}
}
pub fn parse_tune_ok(i: &[u8]) -> ParserResult<'_, TuneOk> {
let (i, channel_max) = parse_short_uint(i)?;
let (i, frame_max) = parse_long_uint(i)?;
let (i, heartbeat) = parse_short_uint(i)?;
Ok((i, TuneOk {
channel_max,
frame_max,
heartbeat,
}))
}
pub fn gen_tune_ok<'a>(input: &'a mut [u8], method: &'a TuneOk) -> GenResult<'a> {
let input = gen_id(input, 31)?;
let input = gen_short_uint(input, method.channel_max)?;
let input = gen_long_uint(input, method.frame_max)?;
let input = gen_short_uint(input, method.heartbeat)?;
Ok(input)
}
impl GenSize for TuneOk {
fn get_gen_size(&self) -> usize {
2
+ self.channel_max.get_gen_size()
+ self.frame_max.get_gen_size()
+ self.heartbeat.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Open {
pub virtual_host: ShortString,
}
impl Open {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
40
}
}
pub fn parse_open(i: &[u8]) -> ParserResult<'_, Open> {
let (i, virtual_host) = parse_short_string(i)?;
let (i, _) = parse_short_string(i)?;
let (i, _) = parse_flags(i, &[
"insist",
])?;
Ok((i, Open {
virtual_host,
}))
}
pub fn gen_open<'a>(input: &'a mut [u8], method: &'a Open) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("insist".to_string(), false);
let input = gen_id(input, 40)?;
let input = gen_short_string(input, method.virtual_host.as_ref())?;
let input = gen_short_string(input, ShortStringRef(""))?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Open {
fn get_gen_size(&self) -> usize {
2
+ self.virtual_host.get_gen_size()
+ 1
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("insist".to_string(), false);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct OpenOk {
}
impl OpenOk {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
41
}
}
pub fn parse_open_ok(i: &[u8]) -> ParserResult<'_, OpenOk> {
let (i, _) = parse_short_string(i)?;
Ok((i, OpenOk {
}))
}
pub fn gen_open_ok<'a>(input: &'a mut [u8], _method: &'a OpenOk) -> GenResult<'a> {
let input = gen_id(input, 41)?;
let input = gen_short_string(input, ShortStringRef(""))?;
Ok(input)
}
impl GenSize for OpenOk {
fn get_gen_size(&self) -> usize {
2
+ 1
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Close {
pub reply_code: ShortUInt,
pub reply_text: ShortString,
pub class_id: ShortUInt,
pub method_id: ShortUInt,
}
impl Close {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
50
}
}
pub fn parse_close(i: &[u8]) -> ParserResult<'_, Close> {
let (i, reply_code) = parse_short_uint(i)?;
let (i, reply_text) = parse_short_string(i)?;
let (i, class_id) = parse_short_uint(i)?;
let (i, method_id) = parse_short_uint(i)?;
Ok((i, Close {
reply_code,
reply_text,
class_id,
method_id,
}))
}
pub fn gen_close<'a>(input: &'a mut [u8], method: &'a Close) -> GenResult<'a> {
let input = gen_id(input, 50)?;
let input = gen_short_uint(input, method.reply_code)?;
let input = gen_short_string(input, method.reply_text.as_ref())?;
let input = gen_short_uint(input, method.class_id)?;
let input = gen_short_uint(input, method.method_id)?;
Ok(input)
}
impl GenSize for Close {
fn get_gen_size(&self) -> usize {
2
+ self.reply_code.get_gen_size()
+ self.reply_text.get_gen_size()
+ self.class_id.get_gen_size()
+ self.method_id.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CloseOk {
}
impl CloseOk {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
51
}
}
pub fn parse_close_ok(i: &[u8]) -> ParserResult<'_, CloseOk> {
Ok((i, CloseOk {
}))
}
pub fn gen_close_ok<'a>(input: &'a mut [u8], _: &'a CloseOk) -> GenResult<'a> {
let input = gen_id(input, 51)?;
Ok(input)
}
impl GenSize for CloseOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Blocked {
pub reason: ShortString,
}
impl Blocked {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
60
}
}
pub fn parse_blocked(i: &[u8]) -> ParserResult<'_, Blocked> {
let (i, reason) = parse_short_string(i)?;
Ok((i, Blocked {
reason,
}))
}
pub fn gen_blocked<'a>(input: &'a mut [u8], method: &'a Blocked) -> GenResult<'a> {
let input = gen_id(input, 60)?;
let input = gen_short_string(input, method.reason.as_ref())?;
Ok(input)
}
impl GenSize for Blocked {
fn get_gen_size(&self) -> usize {
2
+ self.reason.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Unblocked {
}
impl Unblocked {
pub fn get_amqp_class_id(&self) -> u16 {
10
}
pub fn get_amqp_method_id(&self) -> u16 {
61
}
}
pub fn parse_unblocked(i: &[u8]) -> ParserResult<'_, Unblocked> {
Ok((i, Unblocked {
}))
}
pub fn gen_unblocked<'a>(input: &'a mut [u8], _: &'a Unblocked) -> GenResult<'a> {
let input = gen_id(input, 61)?;
Ok(input)
}
impl GenSize for Unblocked {
fn get_gen_size(&self) -> usize {
2
}
}
}
pub mod channel {
use super::*;
pub fn parse_channel(i: &[u8]) -> ParserResult<'_, channel::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_open, AMQPMethod::Open), Some)(i),
11 => map(map(parse_open_ok, AMQPMethod::OpenOk), Some)(i),
20 => map(map(parse_flow, AMQPMethod::Flow), Some)(i),
21 => map(map(parse_flow_ok, AMQPMethod::FlowOk), Some)(i),
40 => map(map(parse_close, AMQPMethod::Close), Some)(i),
41 => map(map(parse_close_ok, AMQPMethod::CloseOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_channel<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Open(ref open) => {
gen_open(gen_id(input, 20)?, open)
},
AMQPMethod::OpenOk(ref open_ok) => {
gen_open_ok(gen_id(input, 20)?, open_ok)
},
AMQPMethod::Flow(ref flow) => {
gen_flow(gen_id(input, 20)?, flow)
},
AMQPMethod::FlowOk(ref flow_ok) => {
gen_flow_ok(gen_id(input, 20)?, flow_ok)
},
AMQPMethod::Close(ref close) => {
gen_close(gen_id(input, 20)?, close)
},
AMQPMethod::CloseOk(ref close_ok) => {
gen_close_ok(gen_id(input, 20)?, close_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Open(m) => m.get_gen_size(),
AMQPMethod::OpenOk(m) => m.get_gen_size(),
AMQPMethod::Flow(m) => m.get_gen_size(),
AMQPMethod::FlowOk(m) => m.get_gen_size(),
AMQPMethod::Close(m) => m.get_gen_size(),
AMQPMethod::CloseOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Open(Open),
OpenOk(OpenOk),
Flow(Flow),
FlowOk(FlowOk),
Close(Close),
CloseOk(CloseOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Open {
}
impl Open {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_open(i: &[u8]) -> ParserResult<'_, Open> {
let (i, _) = parse_short_string(i)?;
Ok((i, Open {
}))
}
pub fn gen_open<'a>(input: &'a mut [u8], _method: &'a Open) -> GenResult<'a> {
let input = gen_id(input, 10)?;
let input = gen_short_string(input, ShortStringRef(""))?;
Ok(input)
}
impl GenSize for Open {
fn get_gen_size(&self) -> usize {
2
+ 1
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct OpenOk {
}
impl OpenOk {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_open_ok(i: &[u8]) -> ParserResult<'_, OpenOk> {
let (i, _) = parse_long_string(i)?;
Ok((i, OpenOk {
}))
}
pub fn gen_open_ok<'a>(input: &'a mut [u8], _method: &'a OpenOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
let input = gen_long_string(input, LongStringRef(""))?;
Ok(input)
}
impl GenSize for OpenOk {
fn get_gen_size(&self) -> usize {
2
+ 4
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Flow {
pub active: Boolean,
}
impl Flow {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_flow(i: &[u8]) -> ParserResult<'_, Flow> {
let (i, flags) = parse_flags(i, &[
"active",
])?;
Ok((i, Flow {
active: flags.get_flag("active").unwrap_or(false),
}))
}
pub fn gen_flow<'a>(input: &'a mut [u8], method: &'a Flow) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("active".to_string(), method.active);
let input = gen_id(input, 20)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Flow {
fn get_gen_size(&self) -> usize {
2
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("active".to_string(), self.active);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct FlowOk {
pub active: Boolean,
}
impl FlowOk {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_flow_ok(i: &[u8]) -> ParserResult<'_, FlowOk> {
let (i, flags) = parse_flags(i, &[
"active",
])?;
Ok((i, FlowOk {
active: flags.get_flag("active").unwrap_or(false),
}))
}
pub fn gen_flow_ok<'a>(input: &'a mut [u8], method: &'a FlowOk) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("active".to_string(), method.active);
let input = gen_id(input, 21)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for FlowOk {
fn get_gen_size(&self) -> usize {
2
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("active".to_string(), self.active);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Close {
pub reply_code: ShortUInt,
pub reply_text: ShortString,
pub class_id: ShortUInt,
pub method_id: ShortUInt,
}
impl Close {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
40
}
}
pub fn parse_close(i: &[u8]) -> ParserResult<'_, Close> {
let (i, reply_code) = parse_short_uint(i)?;
let (i, reply_text) = parse_short_string(i)?;
let (i, class_id) = parse_short_uint(i)?;
let (i, method_id) = parse_short_uint(i)?;
Ok((i, Close {
reply_code,
reply_text,
class_id,
method_id,
}))
}
pub fn gen_close<'a>(input: &'a mut [u8], method: &'a Close) -> GenResult<'a> {
let input = gen_id(input, 40)?;
let input = gen_short_uint(input, method.reply_code)?;
let input = gen_short_string(input, method.reply_text.as_ref())?;
let input = gen_short_uint(input, method.class_id)?;
let input = gen_short_uint(input, method.method_id)?;
Ok(input)
}
impl GenSize for Close {
fn get_gen_size(&self) -> usize {
2
+ self.reply_code.get_gen_size()
+ self.reply_text.get_gen_size()
+ self.class_id.get_gen_size()
+ self.method_id.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CloseOk {
}
impl CloseOk {
pub fn get_amqp_class_id(&self) -> u16 {
20
}
pub fn get_amqp_method_id(&self) -> u16 {
41
}
}
pub fn parse_close_ok(i: &[u8]) -> ParserResult<'_, CloseOk> {
Ok((i, CloseOk {
}))
}
pub fn gen_close_ok<'a>(input: &'a mut [u8], _: &'a CloseOk) -> GenResult<'a> {
let input = gen_id(input, 41)?;
Ok(input)
}
impl GenSize for CloseOk {
fn get_gen_size(&self) -> usize {
2
}
}
}
pub mod access {
use super::*;
pub fn parse_access(i: &[u8]) -> ParserResult<'_, access::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_request, AMQPMethod::Request), Some)(i),
11 => map(map(parse_request_ok, AMQPMethod::RequestOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_access<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Request(ref request) => {
gen_request(gen_id(input, 30)?, request)
},
AMQPMethod::RequestOk(ref request_ok) => {
gen_request_ok(gen_id(input, 30)?, request_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Request(m) => m.get_gen_size(),
AMQPMethod::RequestOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Request(Request),
RequestOk(RequestOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Request {
pub realm: ShortString,
pub exclusive: Boolean,
pub passive: Boolean,
pub active: Boolean,
pub write: Boolean,
pub read: Boolean,
}
impl Request {
pub fn get_amqp_class_id(&self) -> u16 {
30
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_request(i: &[u8]) -> ParserResult<'_, Request> {
let (i, realm) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"exclusive",
"passive",
"active",
"write",
"read",
])?;
Ok((i, Request {
realm,
exclusive: flags.get_flag("exclusive").unwrap_or(false),
passive: flags.get_flag("passive").unwrap_or(false),
active: flags.get_flag("active").unwrap_or(false),
write: flags.get_flag("write").unwrap_or(false),
read: flags.get_flag("read").unwrap_or(false),
}))
}
pub fn gen_request<'a>(input: &'a mut [u8], method: &'a Request) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("exclusive".to_string(), method.exclusive);
flags.add_flag("passive".to_string(), method.passive);
flags.add_flag("active".to_string(), method.active);
flags.add_flag("write".to_string(), method.write);
flags.add_flag("read".to_string(), method.read);
let input = gen_id(input, 10)?;
let input = gen_short_string(input, method.realm.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Request {
fn get_gen_size(&self) -> usize {
2
+ self.realm.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("exclusive".to_string(), self.exclusive);
flags.add_flag("passive".to_string(), self.passive);
flags.add_flag("active".to_string(), self.active);
flags.add_flag("write".to_string(), self.write);
flags.add_flag("read".to_string(), self.read);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RequestOk {
}
impl RequestOk {
pub fn get_amqp_class_id(&self) -> u16 {
30
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_request_ok(i: &[u8]) -> ParserResult<'_, RequestOk> {
let (i, _) = parse_short_uint(i)?;
Ok((i, RequestOk {
}))
}
pub fn gen_request_ok<'a>(input: &'a mut [u8], _method: &'a RequestOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
let input = gen_short_uint(input, 1)?;
Ok(input)
}
impl GenSize for RequestOk {
fn get_gen_size(&self) -> usize {
2
+ 2
}
}
}
pub mod exchange {
use super::*;
pub fn parse_exchange(i: &[u8]) -> ParserResult<'_, exchange::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_declare, AMQPMethod::Declare), Some)(i),
11 => map(map(parse_declare_ok, AMQPMethod::DeclareOk), Some)(i),
20 => map(map(parse_delete, AMQPMethod::Delete), Some)(i),
21 => map(map(parse_delete_ok, AMQPMethod::DeleteOk), Some)(i),
30 => map(map(parse_bind, AMQPMethod::Bind), Some)(i),
31 => map(map(parse_bind_ok, AMQPMethod::BindOk), Some)(i),
40 => map(map(parse_unbind, AMQPMethod::Unbind), Some)(i),
51 => map(map(parse_unbind_ok, AMQPMethod::UnbindOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_exchange<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Declare(ref declare) => {
gen_declare(gen_id(input, 40)?, declare)
},
AMQPMethod::DeclareOk(ref declare_ok) => {
gen_declare_ok(gen_id(input, 40)?, declare_ok)
},
AMQPMethod::Delete(ref delete) => {
gen_delete(gen_id(input, 40)?, delete)
},
AMQPMethod::DeleteOk(ref delete_ok) => {
gen_delete_ok(gen_id(input, 40)?, delete_ok)
},
AMQPMethod::Bind(ref bind) => {
gen_bind(gen_id(input, 40)?, bind)
},
AMQPMethod::BindOk(ref bind_ok) => {
gen_bind_ok(gen_id(input, 40)?, bind_ok)
},
AMQPMethod::Unbind(ref unbind) => {
gen_unbind(gen_id(input, 40)?, unbind)
},
AMQPMethod::UnbindOk(ref unbind_ok) => {
gen_unbind_ok(gen_id(input, 40)?, unbind_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Declare(m) => m.get_gen_size(),
AMQPMethod::DeclareOk(m) => m.get_gen_size(),
AMQPMethod::Delete(m) => m.get_gen_size(),
AMQPMethod::DeleteOk(m) => m.get_gen_size(),
AMQPMethod::Bind(m) => m.get_gen_size(),
AMQPMethod::BindOk(m) => m.get_gen_size(),
AMQPMethod::Unbind(m) => m.get_gen_size(),
AMQPMethod::UnbindOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Declare(Declare),
DeclareOk(DeclareOk),
Delete(Delete),
DeleteOk(DeleteOk),
Bind(Bind),
BindOk(BindOk),
Unbind(Unbind),
UnbindOk(UnbindOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Declare {
pub exchange: ShortString,
pub kind: ShortString,
pub passive: Boolean,
pub durable: Boolean,
pub auto_delete: Boolean,
pub internal: Boolean,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Declare {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_declare(i: &[u8]) -> ParserResult<'_, Declare> {
let (i, _) = parse_short_uint(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, kind) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"passive",
"durable",
"auto-delete",
"internal",
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Declare {
exchange,
kind,
passive: flags.get_flag("passive").unwrap_or(false),
durable: flags.get_flag("durable").unwrap_or(false),
auto_delete: flags.get_flag("auto_delete").unwrap_or(false),
internal: flags.get_flag("internal").unwrap_or(false),
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_declare<'a>(input: &'a mut [u8], method: &'a Declare) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("passive".to_string(), method.passive);
flags.add_flag("durable".to_string(), method.durable);
flags.add_flag("auto_delete".to_string(), method.auto_delete);
flags.add_flag("internal".to_string(), method.internal);
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 10)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.kind.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Declare {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.exchange.get_gen_size()
+ self.kind.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("passive".to_string(), self.passive);
flags.add_flag("durable".to_string(), self.durable);
flags.add_flag("auto_delete".to_string(), self.auto_delete);
flags.add_flag("internal".to_string(), self.internal);
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeclareOk {
}
impl DeclareOk {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_declare_ok(i: &[u8]) -> ParserResult<'_, DeclareOk> {
Ok((i, DeclareOk {
}))
}
pub fn gen_declare_ok<'a>(input: &'a mut [u8], _: &'a DeclareOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
Ok(input)
}
impl GenSize for DeclareOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Delete {
pub exchange: ShortString,
pub if_unused: Boolean,
pub nowait: Boolean,
}
impl Delete {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_delete(i: &[u8]) -> ParserResult<'_, Delete> {
let (i, _) = parse_short_uint(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"if-unused",
"nowait",
])?;
Ok((i, Delete {
exchange,
if_unused: flags.get_flag("if_unused").unwrap_or(false),
nowait: flags.get_flag("nowait").unwrap_or(false),
}))
}
pub fn gen_delete<'a>(input: &'a mut [u8], method: &'a Delete) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("if_unused".to_string(), method.if_unused);
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 20)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Delete {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.exchange.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("if_unused".to_string(), self.if_unused);
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteOk {
}
impl DeleteOk {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_delete_ok(i: &[u8]) -> ParserResult<'_, DeleteOk> {
Ok((i, DeleteOk {
}))
}
pub fn gen_delete_ok<'a>(input: &'a mut [u8], _: &'a DeleteOk) -> GenResult<'a> {
let input = gen_id(input, 21)?;
Ok(input)
}
impl GenSize for DeleteOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Bind {
pub destination: ShortString,
pub source: ShortString,
pub routing_key: ShortString,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Bind {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
30
}
}
pub fn parse_bind(i: &[u8]) -> ParserResult<'_, Bind> {
let (i, _) = parse_short_uint(i)?;
let (i, destination) = parse_short_string(i)?;
let (i, source) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Bind {
destination,
source,
routing_key,
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_bind<'a>(input: &'a mut [u8], method: &'a Bind) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 30)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.destination.as_ref())?;
let input = gen_short_string(input, method.source.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Bind {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.destination.get_gen_size()
+ self.source.get_gen_size()
+ self.routing_key.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct BindOk {
}
impl BindOk {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
31
}
}
pub fn parse_bind_ok(i: &[u8]) -> ParserResult<'_, BindOk> {
Ok((i, BindOk {
}))
}
pub fn gen_bind_ok<'a>(input: &'a mut [u8], _: &'a BindOk) -> GenResult<'a> {
let input = gen_id(input, 31)?;
Ok(input)
}
impl GenSize for BindOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Unbind {
pub destination: ShortString,
pub source: ShortString,
pub routing_key: ShortString,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Unbind {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
40
}
}
pub fn parse_unbind(i: &[u8]) -> ParserResult<'_, Unbind> {
let (i, _) = parse_short_uint(i)?;
let (i, destination) = parse_short_string(i)?;
let (i, source) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Unbind {
destination,
source,
routing_key,
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_unbind<'a>(input: &'a mut [u8], method: &'a Unbind) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 40)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.destination.as_ref())?;
let input = gen_short_string(input, method.source.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Unbind {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.destination.get_gen_size()
+ self.source.get_gen_size()
+ self.routing_key.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UnbindOk {
}
impl UnbindOk {
pub fn get_amqp_class_id(&self) -> u16 {
40
}
pub fn get_amqp_method_id(&self) -> u16 {
51
}
}
pub fn parse_unbind_ok(i: &[u8]) -> ParserResult<'_, UnbindOk> {
Ok((i, UnbindOk {
}))
}
pub fn gen_unbind_ok<'a>(input: &'a mut [u8], _: &'a UnbindOk) -> GenResult<'a> {
let input = gen_id(input, 51)?;
Ok(input)
}
impl GenSize for UnbindOk {
fn get_gen_size(&self) -> usize {
2
}
}
}
pub mod queue {
use super::*;
pub fn parse_queue(i: &[u8]) -> ParserResult<'_, queue::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_declare, AMQPMethod::Declare), Some)(i),
11 => map(map(parse_declare_ok, AMQPMethod::DeclareOk), Some)(i),
20 => map(map(parse_bind, AMQPMethod::Bind), Some)(i),
21 => map(map(parse_bind_ok, AMQPMethod::BindOk), Some)(i),
30 => map(map(parse_purge, AMQPMethod::Purge), Some)(i),
31 => map(map(parse_purge_ok, AMQPMethod::PurgeOk), Some)(i),
40 => map(map(parse_delete, AMQPMethod::Delete), Some)(i),
41 => map(map(parse_delete_ok, AMQPMethod::DeleteOk), Some)(i),
50 => map(map(parse_unbind, AMQPMethod::Unbind), Some)(i),
51 => map(map(parse_unbind_ok, AMQPMethod::UnbindOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_queue<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Declare(ref declare) => {
gen_declare(gen_id(input, 50)?, declare)
},
AMQPMethod::DeclareOk(ref declare_ok) => {
gen_declare_ok(gen_id(input, 50)?, declare_ok)
},
AMQPMethod::Bind(ref bind) => {
gen_bind(gen_id(input, 50)?, bind)
},
AMQPMethod::BindOk(ref bind_ok) => {
gen_bind_ok(gen_id(input, 50)?, bind_ok)
},
AMQPMethod::Purge(ref purge) => {
gen_purge(gen_id(input, 50)?, purge)
},
AMQPMethod::PurgeOk(ref purge_ok) => {
gen_purge_ok(gen_id(input, 50)?, purge_ok)
},
AMQPMethod::Delete(ref delete) => {
gen_delete(gen_id(input, 50)?, delete)
},
AMQPMethod::DeleteOk(ref delete_ok) => {
gen_delete_ok(gen_id(input, 50)?, delete_ok)
},
AMQPMethod::Unbind(ref unbind) => {
gen_unbind(gen_id(input, 50)?, unbind)
},
AMQPMethod::UnbindOk(ref unbind_ok) => {
gen_unbind_ok(gen_id(input, 50)?, unbind_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Declare(m) => m.get_gen_size(),
AMQPMethod::DeclareOk(m) => m.get_gen_size(),
AMQPMethod::Bind(m) => m.get_gen_size(),
AMQPMethod::BindOk(m) => m.get_gen_size(),
AMQPMethod::Purge(m) => m.get_gen_size(),
AMQPMethod::PurgeOk(m) => m.get_gen_size(),
AMQPMethod::Delete(m) => m.get_gen_size(),
AMQPMethod::DeleteOk(m) => m.get_gen_size(),
AMQPMethod::Unbind(m) => m.get_gen_size(),
AMQPMethod::UnbindOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Declare(Declare),
DeclareOk(DeclareOk),
Bind(Bind),
BindOk(BindOk),
Purge(Purge),
PurgeOk(PurgeOk),
Delete(Delete),
DeleteOk(DeleteOk),
Unbind(Unbind),
UnbindOk(UnbindOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Declare {
pub queue: ShortString,
pub passive: Boolean,
pub durable: Boolean,
pub exclusive: Boolean,
pub auto_delete: Boolean,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Declare {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_declare(i: &[u8]) -> ParserResult<'_, Declare> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"passive",
"durable",
"exclusive",
"auto-delete",
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Declare {
queue,
passive: flags.get_flag("passive").unwrap_or(false),
durable: flags.get_flag("durable").unwrap_or(false),
exclusive: flags.get_flag("exclusive").unwrap_or(false),
auto_delete: flags.get_flag("auto_delete").unwrap_or(false),
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_declare<'a>(input: &'a mut [u8], method: &'a Declare) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("passive".to_string(), method.passive);
flags.add_flag("durable".to_string(), method.durable);
flags.add_flag("exclusive".to_string(), method.exclusive);
flags.add_flag("auto_delete".to_string(), method.auto_delete);
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 10)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Declare {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("passive".to_string(), self.passive);
flags.add_flag("durable".to_string(), self.durable);
flags.add_flag("exclusive".to_string(), self.exclusive);
flags.add_flag("auto_delete".to_string(), self.auto_delete);
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeclareOk {
pub queue: ShortString,
pub message_count: LongUInt,
pub consumer_count: LongUInt,
}
impl DeclareOk {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_declare_ok(i: &[u8]) -> ParserResult<'_, DeclareOk> {
let (i, queue) = parse_short_string(i)?;
let (i, message_count) = parse_long_uint(i)?;
let (i, consumer_count) = parse_long_uint(i)?;
Ok((i, DeclareOk {
queue,
message_count,
consumer_count,
}))
}
pub fn gen_declare_ok<'a>(input: &'a mut [u8], method: &'a DeclareOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_long_uint(input, method.message_count)?;
let input = gen_long_uint(input, method.consumer_count)?;
Ok(input)
}
impl GenSize for DeclareOk {
fn get_gen_size(&self) -> usize {
2
+ self.queue.get_gen_size()
+ self.message_count.get_gen_size()
+ self.consumer_count.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Bind {
pub queue: ShortString,
pub exchange: ShortString,
pub routing_key: ShortString,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Bind {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_bind(i: &[u8]) -> ParserResult<'_, Bind> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Bind {
queue,
exchange,
routing_key,
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_bind<'a>(input: &'a mut [u8], method: &'a Bind) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 20)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Bind {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct BindOk {
}
impl BindOk {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_bind_ok(i: &[u8]) -> ParserResult<'_, BindOk> {
Ok((i, BindOk {
}))
}
pub fn gen_bind_ok<'a>(input: &'a mut [u8], _: &'a BindOk) -> GenResult<'a> {
let input = gen_id(input, 21)?;
Ok(input)
}
impl GenSize for BindOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Purge {
pub queue: ShortString,
pub nowait: Boolean,
}
impl Purge {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
30
}
}
pub fn parse_purge(i: &[u8]) -> ParserResult<'_, Purge> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
Ok((i, Purge {
queue,
nowait: flags.get_flag("nowait").unwrap_or(false),
}))
}
pub fn gen_purge<'a>(input: &'a mut [u8], method: &'a Purge) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 30)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Purge {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct PurgeOk {
pub message_count: LongUInt,
}
impl PurgeOk {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
31
}
}
pub fn parse_purge_ok(i: &[u8]) -> ParserResult<'_, PurgeOk> {
let (i, message_count) = parse_long_uint(i)?;
Ok((i, PurgeOk {
message_count,
}))
}
pub fn gen_purge_ok<'a>(input: &'a mut [u8], method: &'a PurgeOk) -> GenResult<'a> {
let input = gen_id(input, 31)?;
let input = gen_long_uint(input, method.message_count)?;
Ok(input)
}
impl GenSize for PurgeOk {
fn get_gen_size(&self) -> usize {
2
+ self.message_count.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Delete {
pub queue: ShortString,
pub if_unused: Boolean,
pub if_empty: Boolean,
pub nowait: Boolean,
}
impl Delete {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
40
}
}
pub fn parse_delete(i: &[u8]) -> ParserResult<'_, Delete> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"if-unused",
"if-empty",
"nowait",
])?;
Ok((i, Delete {
queue,
if_unused: flags.get_flag("if_unused").unwrap_or(false),
if_empty: flags.get_flag("if_empty").unwrap_or(false),
nowait: flags.get_flag("nowait").unwrap_or(false),
}))
}
pub fn gen_delete<'a>(input: &'a mut [u8], method: &'a Delete) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("if_unused".to_string(), method.if_unused);
flags.add_flag("if_empty".to_string(), method.if_empty);
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 40)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Delete {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("if_unused".to_string(), self.if_unused);
flags.add_flag("if_empty".to_string(), self.if_empty);
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct DeleteOk {
pub message_count: LongUInt,
}
impl DeleteOk {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
41
}
}
pub fn parse_delete_ok(i: &[u8]) -> ParserResult<'_, DeleteOk> {
let (i, message_count) = parse_long_uint(i)?;
Ok((i, DeleteOk {
message_count,
}))
}
pub fn gen_delete_ok<'a>(input: &'a mut [u8], method: &'a DeleteOk) -> GenResult<'a> {
let input = gen_id(input, 41)?;
let input = gen_long_uint(input, method.message_count)?;
Ok(input)
}
impl GenSize for DeleteOk {
fn get_gen_size(&self) -> usize {
2
+ self.message_count.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Unbind {
pub queue: ShortString,
pub exchange: ShortString,
pub routing_key: ShortString,
pub arguments: FieldTable,
}
impl Unbind {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
50
}
}
pub fn parse_unbind(i: &[u8]) -> ParserResult<'_, Unbind> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Unbind {
queue,
exchange,
routing_key,
arguments,
}))
}
pub fn gen_unbind<'a>(input: &'a mut [u8], method: &'a Unbind) -> GenResult<'a> {
let input = gen_id(input, 50)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Unbind {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct UnbindOk {
}
impl UnbindOk {
pub fn get_amqp_class_id(&self) -> u16 {
50
}
pub fn get_amqp_method_id(&self) -> u16 {
51
}
}
pub fn parse_unbind_ok(i: &[u8]) -> ParserResult<'_, UnbindOk> {
Ok((i, UnbindOk {
}))
}
pub fn gen_unbind_ok<'a>(input: &'a mut [u8], _: &'a UnbindOk) -> GenResult<'a> {
let input = gen_id(input, 51)?;
Ok(input)
}
impl GenSize for UnbindOk {
fn get_gen_size(&self) -> usize {
2
}
}
}
pub mod basic {
use super::*;
pub fn parse_basic(i: &[u8]) -> ParserResult<'_, basic::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_qos, AMQPMethod::Qos), Some)(i),
11 => map(map(parse_qos_ok, AMQPMethod::QosOk), Some)(i),
20 => map(map(parse_consume, AMQPMethod::Consume), Some)(i),
21 => map(map(parse_consume_ok, AMQPMethod::ConsumeOk), Some)(i),
30 => map(map(parse_cancel, AMQPMethod::Cancel), Some)(i),
31 => map(map(parse_cancel_ok, AMQPMethod::CancelOk), Some)(i),
40 => map(map(parse_publish, AMQPMethod::Publish), Some)(i),
50 => map(map(parse_return, AMQPMethod::Return), Some)(i),
60 => map(map(parse_deliver, AMQPMethod::Deliver), Some)(i),
70 => map(map(parse_get, AMQPMethod::Get), Some)(i),
71 => map(map(parse_get_ok, AMQPMethod::GetOk), Some)(i),
72 => map(map(parse_get_empty, AMQPMethod::GetEmpty), Some)(i),
80 => map(map(parse_ack, AMQPMethod::Ack), Some)(i),
90 => map(map(parse_reject, AMQPMethod::Reject), Some)(i),
100 => map(map(parse_recover_async, AMQPMethod::RecoverAsync), Some)(i),
110 => map(map(parse_recover, AMQPMethod::Recover), Some)(i),
111 => map(map(parse_recover_ok, AMQPMethod::RecoverOk), Some)(i),
120 => map(map(parse_nack, AMQPMethod::Nack), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_basic<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Qos(ref qos) => {
gen_qos(gen_id(input, 60)?, qos)
},
AMQPMethod::QosOk(ref qos_ok) => {
gen_qos_ok(gen_id(input, 60)?, qos_ok)
},
AMQPMethod::Consume(ref consume) => {
gen_consume(gen_id(input, 60)?, consume)
},
AMQPMethod::ConsumeOk(ref consume_ok) => {
gen_consume_ok(gen_id(input, 60)?, consume_ok)
},
AMQPMethod::Cancel(ref cancel) => {
gen_cancel(gen_id(input, 60)?, cancel)
},
AMQPMethod::CancelOk(ref cancel_ok) => {
gen_cancel_ok(gen_id(input, 60)?, cancel_ok)
},
AMQPMethod::Publish(ref publish) => {
gen_publish(gen_id(input, 60)?, publish)
},
AMQPMethod::Return(ref r#return) => {
gen_return(gen_id(input, 60)?, r#return)
},
AMQPMethod::Deliver(ref deliver) => {
gen_deliver(gen_id(input, 60)?, deliver)
},
AMQPMethod::Get(ref get) => {
gen_get(gen_id(input, 60)?, get)
},
AMQPMethod::GetOk(ref get_ok) => {
gen_get_ok(gen_id(input, 60)?, get_ok)
},
AMQPMethod::GetEmpty(ref get_empty) => {
gen_get_empty(gen_id(input, 60)?, get_empty)
},
AMQPMethod::Ack(ref ack) => {
gen_ack(gen_id(input, 60)?, ack)
},
AMQPMethod::Reject(ref reject) => {
gen_reject(gen_id(input, 60)?, reject)
},
AMQPMethod::RecoverAsync(ref recover_async) => {
gen_recover_async(gen_id(input, 60)?, recover_async)
},
AMQPMethod::Recover(ref recover) => {
gen_recover(gen_id(input, 60)?, recover)
},
AMQPMethod::RecoverOk(ref recover_ok) => {
gen_recover_ok(gen_id(input, 60)?, recover_ok)
},
AMQPMethod::Nack(ref nack) => {
gen_nack(gen_id(input, 60)?, nack)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Qos(m) => m.get_gen_size(),
AMQPMethod::QosOk(m) => m.get_gen_size(),
AMQPMethod::Consume(m) => m.get_gen_size(),
AMQPMethod::ConsumeOk(m) => m.get_gen_size(),
AMQPMethod::Cancel(m) => m.get_gen_size(),
AMQPMethod::CancelOk(m) => m.get_gen_size(),
AMQPMethod::Publish(m) => m.get_gen_size(),
AMQPMethod::Return(m) => m.get_gen_size(),
AMQPMethod::Deliver(m) => m.get_gen_size(),
AMQPMethod::Get(m) => m.get_gen_size(),
AMQPMethod::GetOk(m) => m.get_gen_size(),
AMQPMethod::GetEmpty(m) => m.get_gen_size(),
AMQPMethod::Ack(m) => m.get_gen_size(),
AMQPMethod::Reject(m) => m.get_gen_size(),
AMQPMethod::RecoverAsync(m) => m.get_gen_size(),
AMQPMethod::Recover(m) => m.get_gen_size(),
AMQPMethod::RecoverOk(m) => m.get_gen_size(),
AMQPMethod::Nack(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Qos(Qos),
QosOk(QosOk),
Consume(Consume),
ConsumeOk(ConsumeOk),
Cancel(Cancel),
CancelOk(CancelOk),
Publish(Publish),
Return(Return),
Deliver(Deliver),
Get(Get),
GetOk(GetOk),
GetEmpty(GetEmpty),
Ack(Ack),
Reject(Reject),
RecoverAsync(RecoverAsync),
Recover(Recover),
RecoverOk(RecoverOk),
Nack(Nack),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Qos {
pub prefetch_count: ShortUInt,
pub global: Boolean,
}
impl Qos {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_qos(i: &[u8]) -> ParserResult<'_, Qos> {
let (i, _) = parse_long_uint(i)?;
let (i, prefetch_count) = parse_short_uint(i)?;
let (i, flags) = parse_flags(i, &[
"global",
])?;
Ok((i, Qos {
prefetch_count,
global: flags.get_flag("global").unwrap_or(false),
}))
}
pub fn gen_qos<'a>(input: &'a mut [u8], method: &'a Qos) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("global".to_string(), method.global);
let input = gen_id(input, 10)?;
let input = gen_long_uint(input, 0)?;
let input = gen_short_uint(input, method.prefetch_count)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Qos {
fn get_gen_size(&self) -> usize {
2
+ 4
+ self.prefetch_count.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("global".to_string(), self.global);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct QosOk {
}
impl QosOk {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_qos_ok(i: &[u8]) -> ParserResult<'_, QosOk> {
Ok((i, QosOk {
}))
}
pub fn gen_qos_ok<'a>(input: &'a mut [u8], _: &'a QosOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
Ok(input)
}
impl GenSize for QosOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Consume {
pub queue: ShortString,
pub consumer_tag: ShortString,
pub no_local: Boolean,
pub no_ack: Boolean,
pub exclusive: Boolean,
pub nowait: Boolean,
pub arguments: FieldTable,
}
impl Consume {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_consume(i: &[u8]) -> ParserResult<'_, Consume> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, consumer_tag) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"no-local",
"no-ack",
"exclusive",
"nowait",
])?;
let (i, arguments) = parse_field_table(i)?;
Ok((i, Consume {
queue,
consumer_tag,
no_local: flags.get_flag("no_local").unwrap_or(false),
no_ack: flags.get_flag("no_ack").unwrap_or(false),
exclusive: flags.get_flag("exclusive").unwrap_or(false),
nowait: flags.get_flag("nowait").unwrap_or(false),
arguments,
}))
}
pub fn gen_consume<'a>(input: &'a mut [u8], method: &'a Consume) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("no_local".to_string(), method.no_local);
flags.add_flag("no_ack".to_string(), method.no_ack);
flags.add_flag("exclusive".to_string(), method.exclusive);
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 20)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_short_string(input, method.consumer_tag.as_ref())?;
let input = gen_flags(input, &flags)?;
let input = gen_field_table(input, &method.arguments)?;
Ok(input)
}
impl GenSize for Consume {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ self.consumer_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("no_local".to_string(), self.no_local);
flags.add_flag("no_ack".to_string(), self.no_ack);
flags.add_flag("exclusive".to_string(), self.exclusive);
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
+ self.arguments.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ConsumeOk {
pub consumer_tag: ShortString,
}
impl ConsumeOk {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_consume_ok(i: &[u8]) -> ParserResult<'_, ConsumeOk> {
let (i, consumer_tag) = parse_short_string(i)?;
Ok((i, ConsumeOk {
consumer_tag,
}))
}
pub fn gen_consume_ok<'a>(input: &'a mut [u8], method: &'a ConsumeOk) -> GenResult<'a> {
let input = gen_id(input, 21)?;
let input = gen_short_string(input, method.consumer_tag.as_ref())?;
Ok(input)
}
impl GenSize for ConsumeOk {
fn get_gen_size(&self) -> usize {
2
+ self.consumer_tag.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Cancel {
pub consumer_tag: ShortString,
pub nowait: Boolean,
}
impl Cancel {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
30
}
}
pub fn parse_cancel(i: &[u8]) -> ParserResult<'_, Cancel> {
let (i, consumer_tag) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
Ok((i, Cancel {
consumer_tag,
nowait: flags.get_flag("nowait").unwrap_or(false),
}))
}
pub fn gen_cancel<'a>(input: &'a mut [u8], method: &'a Cancel) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 30)?;
let input = gen_short_string(input, method.consumer_tag.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Cancel {
fn get_gen_size(&self) -> usize {
2
+ self.consumer_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CancelOk {
pub consumer_tag: ShortString,
}
impl CancelOk {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
31
}
}
pub fn parse_cancel_ok(i: &[u8]) -> ParserResult<'_, CancelOk> {
let (i, consumer_tag) = parse_short_string(i)?;
Ok((i, CancelOk {
consumer_tag,
}))
}
pub fn gen_cancel_ok<'a>(input: &'a mut [u8], method: &'a CancelOk) -> GenResult<'a> {
let input = gen_id(input, 31)?;
let input = gen_short_string(input, method.consumer_tag.as_ref())?;
Ok(input)
}
impl GenSize for CancelOk {
fn get_gen_size(&self) -> usize {
2
+ self.consumer_tag.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Publish {
pub exchange: ShortString,
pub routing_key: ShortString,
pub mandatory: Boolean,
pub immediate: Boolean,
}
impl Publish {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
40
}
}
pub fn parse_publish(i: &[u8]) -> ParserResult<'_, Publish> {
let (i, _) = parse_short_uint(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"mandatory",
"immediate",
])?;
Ok((i, Publish {
exchange,
routing_key,
mandatory: flags.get_flag("mandatory").unwrap_or(false),
immediate: flags.get_flag("immediate").unwrap_or(false),
}))
}
pub fn gen_publish<'a>(input: &'a mut [u8], method: &'a Publish) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("mandatory".to_string(), method.mandatory);
flags.add_flag("immediate".to_string(), method.immediate);
let input = gen_id(input, 40)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Publish {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("mandatory".to_string(), self.mandatory);
flags.add_flag("immediate".to_string(), self.immediate);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Return {
pub reply_code: ShortUInt,
pub reply_text: ShortString,
pub exchange: ShortString,
pub routing_key: ShortString,
}
impl Return {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
50
}
}
pub fn parse_return(i: &[u8]) -> ParserResult<'_, Return> {
let (i, reply_code) = parse_short_uint(i)?;
let (i, reply_text) = parse_short_string(i)?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
Ok((i, Return {
reply_code,
reply_text,
exchange,
routing_key,
}))
}
pub fn gen_return<'a>(input: &'a mut [u8], method: &'a Return) -> GenResult<'a> {
let input = gen_id(input, 50)?;
let input = gen_short_uint(input, method.reply_code)?;
let input = gen_short_string(input, method.reply_text.as_ref())?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
Ok(input)
}
impl GenSize for Return {
fn get_gen_size(&self) -> usize {
2
+ self.reply_code.get_gen_size()
+ self.reply_text.get_gen_size()
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Deliver {
pub consumer_tag: ShortString,
pub delivery_tag: LongLongUInt,
pub redelivered: Boolean,
pub exchange: ShortString,
pub routing_key: ShortString,
}
impl Deliver {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
60
}
}
pub fn parse_deliver(i: &[u8]) -> ParserResult<'_, Deliver> {
let (i, consumer_tag) = parse_short_string(i)?;
let (i, delivery_tag) = parse_long_long_uint(i)?;
let (i, flags) = parse_flags(i, &[
"redelivered",
])?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
Ok((i, Deliver {
consumer_tag,
delivery_tag,
redelivered: flags.get_flag("redelivered").unwrap_or(false),
exchange,
routing_key,
}))
}
pub fn gen_deliver<'a>(input: &'a mut [u8], method: &'a Deliver) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("redelivered".to_string(), method.redelivered);
let input = gen_id(input, 60)?;
let input = gen_short_string(input, method.consumer_tag.as_ref())?;
let input = gen_long_long_uint(input, method.delivery_tag)?;
let input = gen_flags(input, &flags)?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
Ok(input)
}
impl GenSize for Deliver {
fn get_gen_size(&self) -> usize {
2
+ self.consumer_tag.get_gen_size()
+ self.delivery_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("redelivered".to_string(), self.redelivered);
flags.get_gen_size()
}
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Get {
pub queue: ShortString,
pub no_ack: Boolean,
}
impl Get {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
70
}
}
pub fn parse_get(i: &[u8]) -> ParserResult<'_, Get> {
let (i, _) = parse_short_uint(i)?;
let (i, queue) = parse_short_string(i)?;
let (i, flags) = parse_flags(i, &[
"no-ack",
])?;
Ok((i, Get {
queue,
no_ack: flags.get_flag("no_ack").unwrap_or(false),
}))
}
pub fn gen_get<'a>(input: &'a mut [u8], method: &'a Get) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("no_ack".to_string(), method.no_ack);
let input = gen_id(input, 70)?;
let input = gen_short_uint(input, 0)?;
let input = gen_short_string(input, method.queue.as_ref())?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Get {
fn get_gen_size(&self) -> usize {
2
+ 2
+ self.queue.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("no_ack".to_string(), self.no_ack);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetOk {
pub delivery_tag: LongLongUInt,
pub redelivered: Boolean,
pub exchange: ShortString,
pub routing_key: ShortString,
pub message_count: LongUInt,
}
impl GetOk {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
71
}
}
pub fn parse_get_ok(i: &[u8]) -> ParserResult<'_, GetOk> {
let (i, delivery_tag) = parse_long_long_uint(i)?;
let (i, flags) = parse_flags(i, &[
"redelivered",
])?;
let (i, exchange) = parse_short_string(i)?;
let (i, routing_key) = parse_short_string(i)?;
let (i, message_count) = parse_long_uint(i)?;
Ok((i, GetOk {
delivery_tag,
redelivered: flags.get_flag("redelivered").unwrap_or(false),
exchange,
routing_key,
message_count,
}))
}
pub fn gen_get_ok<'a>(input: &'a mut [u8], method: &'a GetOk) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("redelivered".to_string(), method.redelivered);
let input = gen_id(input, 71)?;
let input = gen_long_long_uint(input, method.delivery_tag)?;
let input = gen_flags(input, &flags)?;
let input = gen_short_string(input, method.exchange.as_ref())?;
let input = gen_short_string(input, method.routing_key.as_ref())?;
let input = gen_long_uint(input, method.message_count)?;
Ok(input)
}
impl GenSize for GetOk {
fn get_gen_size(&self) -> usize {
2
+ self.delivery_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("redelivered".to_string(), self.redelivered);
flags.get_gen_size()
}
+ self.exchange.get_gen_size()
+ self.routing_key.get_gen_size()
+ self.message_count.get_gen_size()
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetEmpty {
}
impl GetEmpty {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
72
}
}
pub fn parse_get_empty(i: &[u8]) -> ParserResult<'_, GetEmpty> {
let (i, _) = parse_short_string(i)?;
Ok((i, GetEmpty {
}))
}
pub fn gen_get_empty<'a>(input: &'a mut [u8], _method: &'a GetEmpty) -> GenResult<'a> {
let input = gen_id(input, 72)?;
let input = gen_short_string(input, ShortStringRef(""))?;
Ok(input)
}
impl GenSize for GetEmpty {
fn get_gen_size(&self) -> usize {
2
+ 1
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Ack {
pub delivery_tag: LongLongUInt,
pub multiple: Boolean,
}
impl Ack {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
80
}
}
pub fn parse_ack(i: &[u8]) -> ParserResult<'_, Ack> {
let (i, delivery_tag) = parse_long_long_uint(i)?;
let (i, flags) = parse_flags(i, &[
"multiple",
])?;
Ok((i, Ack {
delivery_tag,
multiple: flags.get_flag("multiple").unwrap_or(false),
}))
}
pub fn gen_ack<'a>(input: &'a mut [u8], method: &'a Ack) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("multiple".to_string(), method.multiple);
let input = gen_id(input, 80)?;
let input = gen_long_long_uint(input, method.delivery_tag)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Ack {
fn get_gen_size(&self) -> usize {
2
+ self.delivery_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("multiple".to_string(), self.multiple);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Reject {
pub delivery_tag: LongLongUInt,
pub requeue: Boolean,
}
impl Reject {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
90
}
}
pub fn parse_reject(i: &[u8]) -> ParserResult<'_, Reject> {
let (i, delivery_tag) = parse_long_long_uint(i)?;
let (i, flags) = parse_flags(i, &[
"requeue",
])?;
Ok((i, Reject {
delivery_tag,
requeue: flags.get_flag("requeue").unwrap_or(false),
}))
}
pub fn gen_reject<'a>(input: &'a mut [u8], method: &'a Reject) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), method.requeue);
let input = gen_id(input, 90)?;
let input = gen_long_long_uint(input, method.delivery_tag)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Reject {
fn get_gen_size(&self) -> usize {
2
+ self.delivery_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), self.requeue);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RecoverAsync {
pub requeue: Boolean,
}
impl RecoverAsync {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
100
}
}
pub fn parse_recover_async(i: &[u8]) -> ParserResult<'_, RecoverAsync> {
let (i, flags) = parse_flags(i, &[
"requeue",
])?;
Ok((i, RecoverAsync {
requeue: flags.get_flag("requeue").unwrap_or(false),
}))
}
pub fn gen_recover_async<'a>(input: &'a mut [u8], method: &'a RecoverAsync) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), method.requeue);
let input = gen_id(input, 100)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for RecoverAsync {
fn get_gen_size(&self) -> usize {
2
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), self.requeue);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Recover {
pub requeue: Boolean,
}
impl Recover {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
110
}
}
pub fn parse_recover(i: &[u8]) -> ParserResult<'_, Recover> {
let (i, flags) = parse_flags(i, &[
"requeue",
])?;
Ok((i, Recover {
requeue: flags.get_flag("requeue").unwrap_or(false),
}))
}
pub fn gen_recover<'a>(input: &'a mut [u8], method: &'a Recover) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), method.requeue);
let input = gen_id(input, 110)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Recover {
fn get_gen_size(&self) -> usize {
2
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("requeue".to_string(), self.requeue);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RecoverOk {
}
impl RecoverOk {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
111
}
}
pub fn parse_recover_ok(i: &[u8]) -> ParserResult<'_, RecoverOk> {
Ok((i, RecoverOk {
}))
}
pub fn gen_recover_ok<'a>(input: &'a mut [u8], _: &'a RecoverOk) -> GenResult<'a> {
let input = gen_id(input, 111)?;
Ok(input)
}
impl GenSize for RecoverOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Nack {
pub delivery_tag: LongLongUInt,
pub multiple: Boolean,
pub requeue: Boolean,
}
impl Nack {
pub fn get_amqp_class_id(&self) -> u16 {
60
}
pub fn get_amqp_method_id(&self) -> u16 {
120
}
}
pub fn parse_nack(i: &[u8]) -> ParserResult<'_, Nack> {
let (i, delivery_tag) = parse_long_long_uint(i)?;
let (i, flags) = parse_flags(i, &[
"multiple",
"requeue",
])?;
Ok((i, Nack {
delivery_tag,
multiple: flags.get_flag("multiple").unwrap_or(false),
requeue: flags.get_flag("requeue").unwrap_or(false),
}))
}
pub fn gen_nack<'a>(input: &'a mut [u8], method: &'a Nack) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("multiple".to_string(), method.multiple);
flags.add_flag("requeue".to_string(), method.requeue);
let input = gen_id(input, 120)?;
let input = gen_long_long_uint(input, method.delivery_tag)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Nack {
fn get_gen_size(&self) -> usize {
2
+ self.delivery_tag.get_gen_size()
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("multiple".to_string(), self.multiple);
flags.add_flag("requeue".to_string(), self.requeue);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct AMQPProperties {
content_type: Option<ShortString>,
content_encoding: Option<ShortString>,
headers: Option<FieldTable>,
delivery_mode: Option<ShortShortUInt>,
priority: Option<ShortShortUInt>,
correlation_id: Option<ShortString>,
reply_to: Option<ShortString>,
expiration: Option<ShortString>,
message_id: Option<ShortString>,
timestamp: Option<Timestamp>,
kind: Option<ShortString>,
user_id: Option<ShortString>,
app_id: Option<ShortString>,
cluster_id: Option<ShortString>,
}
impl Default for AMQPProperties {
fn default() -> AMQPProperties {
AMQPProperties {
content_type: None,
content_encoding: None,
headers: None,
delivery_mode: None,
priority: None,
correlation_id: None,
reply_to: None,
expiration: None,
message_id: None,
timestamp: None,
kind: None,
user_id: None,
app_id: None,
cluster_id: None,
}
}
}
impl AMQPProperties {
pub fn with_content_type(mut self, value: ShortString) -> AMQPProperties {
self.content_type = Some(value);
self
}
pub fn with_content_encoding(mut self, value: ShortString) -> AMQPProperties {
self.content_encoding = Some(value);
self
}
pub fn with_headers(mut self, value: FieldTable) -> AMQPProperties {
self.headers = Some(value);
self
}
pub fn with_delivery_mode(mut self, value: ShortShortUInt) -> AMQPProperties {
self.delivery_mode = Some(value);
self
}
pub fn with_priority(mut self, value: ShortShortUInt) -> AMQPProperties {
self.priority = Some(value);
self
}
pub fn with_correlation_id(mut self, value: ShortString) -> AMQPProperties {
self.correlation_id = Some(value);
self
}
pub fn with_reply_to(mut self, value: ShortString) -> AMQPProperties {
self.reply_to = Some(value);
self
}
pub fn with_expiration(mut self, value: ShortString) -> AMQPProperties {
self.expiration = Some(value);
self
}
pub fn with_message_id(mut self, value: ShortString) -> AMQPProperties {
self.message_id = Some(value);
self
}
pub fn with_timestamp(mut self, value: Timestamp) -> AMQPProperties {
self.timestamp = Some(value);
self
}
pub fn with_kind(mut self, value: ShortString) -> AMQPProperties {
self.kind = Some(value);
self
}
pub fn with_user_id(mut self, value: ShortString) -> AMQPProperties {
self.user_id = Some(value);
self
}
pub fn with_app_id(mut self, value: ShortString) -> AMQPProperties {
self.app_id = Some(value);
self
}
pub fn with_cluster_id(mut self, value: ShortString) -> AMQPProperties {
self.cluster_id = Some(value);
self
}
pub fn content_type(&self) -> &Option<ShortString> {
&self.content_type
}
pub fn content_encoding(&self) -> &Option<ShortString> {
&self.content_encoding
}
pub fn headers(&self) -> &Option<FieldTable> {
&self.headers
}
pub fn delivery_mode(&self) -> &Option<ShortShortUInt> {
&self.delivery_mode
}
pub fn priority(&self) -> &Option<ShortShortUInt> {
&self.priority
}
pub fn correlation_id(&self) -> &Option<ShortString> {
&self.correlation_id
}
pub fn reply_to(&self) -> &Option<ShortString> {
&self.reply_to
}
pub fn expiration(&self) -> &Option<ShortString> {
&self.expiration
}
pub fn message_id(&self) -> &Option<ShortString> {
&self.message_id
}
pub fn timestamp(&self) -> &Option<Timestamp> {
&self.timestamp
}
pub fn kind(&self) -> &Option<ShortString> {
&self.kind
}
pub fn user_id(&self) -> &Option<ShortString> {
&self.user_id
}
pub fn app_id(&self) -> &Option<ShortString> {
&self.app_id
}
pub fn cluster_id(&self) -> &Option<ShortString> {
&self.cluster_id
}
#[allow(clippy::identity_op)]
pub fn bitmask(&self) -> ShortUInt {
(if self.content_type.is_some() { 1 << (15 - 0) } else { 0 }) + (if self.content_encoding.is_some() { 1 << (15 - 1) } else { 0 }) + (if self.headers.is_some() { 1 << (15 - 2) } else { 0 }) + (if self.delivery_mode.is_some() { 1 << (15 - 3) } else { 0 }) + (if self.priority.is_some() { 1 << (15 - 4) } else { 0 }) + (if self.correlation_id.is_some() { 1 << (15 - 5) } else { 0 }) + (if self.reply_to.is_some() { 1 << (15 - 6) } else { 0 }) + (if self.expiration.is_some() { 1 << (15 - 7) } else { 0 }) + (if self.message_id.is_some() { 1 << (15 - 8) } else { 0 }) + (if self.timestamp.is_some() { 1 << (15 - 9) } else { 0 }) + (if self.kind.is_some() { 1 << (15 - 10) } else { 0 }) + (if self.user_id.is_some() { 1 << (15 - 11) } else { 0 }) + (if self.app_id.is_some() { 1 << (15 - 12) } else { 0 }) + (if self.cluster_id.is_some() { 1 << (15 - 13) } else { 0 }) }
}
#[allow(clippy::identity_op)]
pub fn parse_properties(i: &[u8]) -> ParserResult<'_, AMQPProperties> {
let (i, flags) = parse_short_uint(i)?;
let (i, content_type) = if flags & (1 << (15 - 0)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, content_encoding) = if flags & (1 << (15 - 1)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, headers) = if flags & (1 << (15 - 2)) != 0 { map(parse_field_table, Some)(i)? } else { (i, None) };
let (i, delivery_mode) = if flags & (1 << (15 - 3)) != 0 { map(parse_short_short_uint, Some)(i)? } else { (i, None) };
let (i, priority) = if flags & (1 << (15 - 4)) != 0 { map(parse_short_short_uint, Some)(i)? } else { (i, None) };
let (i, correlation_id) = if flags & (1 << (15 - 5)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, reply_to) = if flags & (1 << (15 - 6)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, expiration) = if flags & (1 << (15 - 7)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, message_id) = if flags & (1 << (15 - 8)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, timestamp) = if flags & (1 << (15 - 9)) != 0 { map(parse_timestamp, Some)(i)? } else { (i, None) };
let (i, kind) = if flags & (1 << (15 - 10)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, user_id) = if flags & (1 << (15 - 11)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, app_id) = if flags & (1 << (15 - 12)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
let (i, cluster_id) = if flags & (1 << (15 - 13)) != 0 { map(parse_short_string, Some)(i)? } else { (i, None) };
Ok((i, AMQPProperties {
content_type,
content_encoding,
headers,
delivery_mode,
priority,
correlation_id,
reply_to,
expiration,
message_id,
timestamp,
kind,
user_id,
app_id,
cluster_id,
}))
}
pub fn gen_properties<'a>(input: &'a mut [u8], props: &'a AMQPProperties) -> GenResult<'a> {
let mut input = gen_short_uint(input, props.bitmask())?;
if let Some(prop) = props.content_type.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.content_encoding.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.headers.as_ref(){
input = gen_field_table(input, prop)?;
}
if let Some(prop) = props.delivery_mode{
input = gen_short_short_uint(input, prop)?;
}
if let Some(prop) = props.priority{
input = gen_short_short_uint(input, prop)?;
}
if let Some(prop) = props.correlation_id.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.reply_to.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.expiration.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.message_id.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.timestamp{
input = gen_timestamp(input, prop)?;
}
if let Some(prop) = props.kind.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.user_id.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.app_id.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
if let Some(prop) = props.cluster_id.as_ref(){
input = gen_short_string(input, prop.as_ref())?;
}
Ok(input)
}
impl GenSize for AMQPProperties {
fn get_gen_size(&self) -> usize {
let mut size = self.bitmask().get_gen_size();
if let Some(prop) = self.content_type.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.content_encoding.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.headers.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.delivery_mode{
size += prop.get_gen_size();
}
if let Some(prop) = self.priority{
size += prop.get_gen_size();
}
if let Some(prop) = self.correlation_id.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.reply_to.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.expiration.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.message_id.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.timestamp{
size += prop.get_gen_size();
}
if let Some(prop) = self.kind.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.user_id.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.app_id.as_ref(){
size += prop.get_gen_size();
}
if let Some(prop) = self.cluster_id.as_ref(){
size += prop.get_gen_size();
}
size
}
}
}
pub mod tx {
use super::*;
pub fn parse_tx(i: &[u8]) -> ParserResult<'_, tx::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_select, AMQPMethod::Select), Some)(i),
11 => map(map(parse_select_ok, AMQPMethod::SelectOk), Some)(i),
20 => map(map(parse_commit, AMQPMethod::Commit), Some)(i),
21 => map(map(parse_commit_ok, AMQPMethod::CommitOk), Some)(i),
30 => map(map(parse_rollback, AMQPMethod::Rollback), Some)(i),
31 => map(map(parse_rollback_ok, AMQPMethod::RollbackOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_tx<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Select(ref select) => {
gen_select(gen_id(input, 90)?, select)
},
AMQPMethod::SelectOk(ref select_ok) => {
gen_select_ok(gen_id(input, 90)?, select_ok)
},
AMQPMethod::Commit(ref commit) => {
gen_commit(gen_id(input, 90)?, commit)
},
AMQPMethod::CommitOk(ref commit_ok) => {
gen_commit_ok(gen_id(input, 90)?, commit_ok)
},
AMQPMethod::Rollback(ref rollback) => {
gen_rollback(gen_id(input, 90)?, rollback)
},
AMQPMethod::RollbackOk(ref rollback_ok) => {
gen_rollback_ok(gen_id(input, 90)?, rollback_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Select(m) => m.get_gen_size(),
AMQPMethod::SelectOk(m) => m.get_gen_size(),
AMQPMethod::Commit(m) => m.get_gen_size(),
AMQPMethod::CommitOk(m) => m.get_gen_size(),
AMQPMethod::Rollback(m) => m.get_gen_size(),
AMQPMethod::RollbackOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Select(Select),
SelectOk(SelectOk),
Commit(Commit),
CommitOk(CommitOk),
Rollback(Rollback),
RollbackOk(RollbackOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Select {
}
impl Select {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_select(i: &[u8]) -> ParserResult<'_, Select> {
Ok((i, Select {
}))
}
pub fn gen_select<'a>(input: &'a mut [u8], _: &'a Select) -> GenResult<'a> {
let input = gen_id(input, 10)?;
Ok(input)
}
impl GenSize for Select {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SelectOk {
}
impl SelectOk {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_select_ok(i: &[u8]) -> ParserResult<'_, SelectOk> {
Ok((i, SelectOk {
}))
}
pub fn gen_select_ok<'a>(input: &'a mut [u8], _: &'a SelectOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
Ok(input)
}
impl GenSize for SelectOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Commit {
}
impl Commit {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
20
}
}
pub fn parse_commit(i: &[u8]) -> ParserResult<'_, Commit> {
Ok((i, Commit {
}))
}
pub fn gen_commit<'a>(input: &'a mut [u8], _: &'a Commit) -> GenResult<'a> {
let input = gen_id(input, 20)?;
Ok(input)
}
impl GenSize for Commit {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct CommitOk {
}
impl CommitOk {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
21
}
}
pub fn parse_commit_ok(i: &[u8]) -> ParserResult<'_, CommitOk> {
Ok((i, CommitOk {
}))
}
pub fn gen_commit_ok<'a>(input: &'a mut [u8], _: &'a CommitOk) -> GenResult<'a> {
let input = gen_id(input, 21)?;
Ok(input)
}
impl GenSize for CommitOk {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Rollback {
}
impl Rollback {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
30
}
}
pub fn parse_rollback(i: &[u8]) -> ParserResult<'_, Rollback> {
Ok((i, Rollback {
}))
}
pub fn gen_rollback<'a>(input: &'a mut [u8], _: &'a Rollback) -> GenResult<'a> {
let input = gen_id(input, 30)?;
Ok(input)
}
impl GenSize for Rollback {
fn get_gen_size(&self) -> usize {
2
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct RollbackOk {
}
impl RollbackOk {
pub fn get_amqp_class_id(&self) -> u16 {
90
}
pub fn get_amqp_method_id(&self) -> u16 {
31
}
}
pub fn parse_rollback_ok(i: &[u8]) -> ParserResult<'_, RollbackOk> {
Ok((i, RollbackOk {
}))
}
pub fn gen_rollback_ok<'a>(input: &'a mut [u8], _: &'a RollbackOk) -> GenResult<'a> {
let input = gen_id(input, 31)?;
Ok(input)
}
impl GenSize for RollbackOk {
fn get_gen_size(&self) -> usize {
2
}
}
}
pub mod confirm {
use super::*;
pub fn parse_confirm(i: &[u8]) -> ParserResult<'_, confirm::AMQPMethod> {
map_opt(flat_map(parse_id, |id| move |i| match id {
10 => map(map(parse_select, AMQPMethod::Select), Some)(i),
11 => map(map(parse_select_ok, AMQPMethod::SelectOk), Some)(i),
_ => Ok((i, None)),
}), std::convert::identity)(i)
}
pub fn gen_confirm<'a>(input: &'a mut [u8], method: &'a AMQPMethod) -> GenResult<'a> {
match *method {
AMQPMethod::Select(ref select) => {
gen_select(gen_id(input, 85)?, select)
},
AMQPMethod::SelectOk(ref select_ok) => {
gen_select_ok(gen_id(input, 85)?, select_ok)
},
}
}
impl GenSize for AMQPMethod {
fn get_gen_size(&self) -> usize {
2 + match self {
AMQPMethod::Select(m) => m.get_gen_size(),
AMQPMethod::SelectOk(m) => m.get_gen_size(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum AMQPMethod {
Select(Select),
SelectOk(SelectOk),
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct Select {
pub nowait: Boolean,
}
impl Select {
pub fn get_amqp_class_id(&self) -> u16 {
85
}
pub fn get_amqp_method_id(&self) -> u16 {
10
}
}
pub fn parse_select(i: &[u8]) -> ParserResult<'_, Select> {
let (i, flags) = parse_flags(i, &[
"nowait",
])?;
Ok((i, Select {
nowait: flags.get_flag("nowait").unwrap_or(false),
}))
}
pub fn gen_select<'a>(input: &'a mut [u8], method: &'a Select) -> GenResult<'a> {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), method.nowait);
let input = gen_id(input, 10)?;
let input = gen_flags(input, &flags)?;
Ok(input)
}
impl GenSize for Select {
fn get_gen_size(&self) -> usize {
2
+ {
let mut flags = AMQPFlags::default();
flags.add_flag("nowait".to_string(), self.nowait);
flags.get_gen_size()
}
}
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct SelectOk {
}
impl SelectOk {
pub fn get_amqp_class_id(&self) -> u16 {
85
}
pub fn get_amqp_method_id(&self) -> u16 {
11
}
}
pub fn parse_select_ok(i: &[u8]) -> ParserResult<'_, SelectOk> {
Ok((i, SelectOk {
}))
}
pub fn gen_select_ok<'a>(input: &'a mut [u8], _: &'a SelectOk) -> GenResult<'a> {
let input = gen_id(input, 11)?;
Ok(input)
}
impl GenSize for SelectOk {
fn get_gen_size(&self) -> usize {
2
}
}
}