more cleanup

amqp_core/src/methods/generated.rs

@@ -126,151 +126,236 @@ pub type Table = super::Table;
 
 #[derive(Debug, Clone, PartialEq)]
 pub enum Method {
+    ConnectionStart(ConnectionStart),
+    ConnectionStartOk(ConnectionStartOk),
+    ConnectionSecure(ConnectionSecure),
+    ConnectionSecureOk(ConnectionSecureOk),
+    ConnectionTune(ConnectionTune),
+    ConnectionTuneOk(ConnectionTuneOk),
+    ConnectionOpen(ConnectionOpen),
+    ConnectionOpenOk(ConnectionOpenOk),
+    ConnectionClose(ConnectionClose),
+    ConnectionCloseOk(ConnectionCloseOk),
+    ChannelOpen(ChannelOpen),
+    ChannelOpenOk(ChannelOpenOk),
+    ChannelFlow(ChannelFlow),
+    ChannelFlowOk(ChannelFlowOk),
+    ChannelClose(ChannelClose),
+    ChannelCloseOk(ChannelCloseOk),
+    ExchangeDeclare(ExchangeDeclare),
+    ExchangeDeclareOk(ExchangeDeclareOk),
+    ExchangeDelete(ExchangeDelete),
+    ExchangeDeleteOk(ExchangeDeleteOk),
+    QueueDeclare(QueueDeclare),
+    QueueDeclareOk(QueueDeclareOk),
+    QueueBind(QueueBind),
+    QueueBindOk(QueueBindOk),
+    QueueUnbind(QueueUnbind),
+    QueueUnbindOk(QueueUnbindOk),
+    QueuePurge(QueuePurge),
+    QueuePurgeOk(QueuePurgeOk),
+    QueueDelete(QueueDelete),
+    QueueDeleteOk(QueueDeleteOk),
+    BasicQos(BasicQos),
+    BasicQosOk(BasicQosOk),
+    BasicConsume(BasicConsume),
+    BasicConsumeOk(BasicConsumeOk),
+    BasicCancel(BasicCancel),
+    BasicCancelOk(BasicCancelOk),
+    BasicPublish(BasicPublish),
+    BasicReturn(BasicReturn),
+    BasicDeliver(BasicDeliver),
+    BasicGet(BasicGet),
+    BasicGetOk(BasicGetOk),
+    BasicGetEmpty(BasicGetEmpty),
+    BasicAck(BasicAck),
+    BasicReject(BasicReject),
+    BasicRecoverAsync(BasicRecoverAsync),
+    BasicRecover(BasicRecover),
+    BasicRecoverOk(BasicRecoverOk),
+    TxSelect(TxSelect),
+    TxSelectOk(TxSelectOk),
+    TxCommit(TxCommit),
+    TxCommitOk(TxCommitOk),
+    TxRollback(TxRollback),
+    TxRollbackOk(TxRollbackOk),
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method starts the connection negotiation process by telling the client the
 /// protocol version that the server proposes, along with a list of security mechanisms
 /// which the client can use for authentication.
-    ConnectionStart {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionStart {
     /// The major version number can take any value from 0 to 99 as defined in the
     /// AMQP specification.
-        version_major: Octet,
+    pub version_major: Octet,
     /// The minor version number can take any value from 0 to 99 as defined in the
     /// AMQP specification.
-        version_minor: Octet,
+    pub version_minor: Octet,
-        server_properties: PeerProperties,
+    pub server_properties: PeerProperties,
     /// must not be null
     ///
     /// A list of the security mechanisms that the server supports, delimited by spaces.
-        mechanisms: Longstr,
+    pub mechanisms: Longstr,
     /// must not be null
     ///
     /// A list of the message locales that the server supports, delimited by spaces. The
     /// locale defines the language in which the server will send reply texts.
-        locales: Longstr,
+    pub locales: Longstr,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method selects a SASL security mechanism.
-    ConnectionStartOk {
+#[derive(Debug, Clone, PartialEq)]
-        client_properties: PeerProperties,
+pub struct ConnectionStartOk {
+    pub client_properties: PeerProperties,
     /// must not be null
     ///
     /// A single security mechanisms selected by the client, which must be one of those
     /// specified by the server.
-        mechanism: Shortstr,
+    pub mechanism: Shortstr,
     /// must not be null
     ///
     /// A block of opaque data passed to the security mechanism. The contents of this
     /// data are defined by the SASL security mechanism.
-        response: Longstr,
+    pub response: Longstr,
     /// must not be null
     ///
     /// A single message locale selected by the client, which must be one of those
     /// specified by the server.
-        locale: Shortstr,
+    pub locale: Shortstr,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// The SASL protocol works by exchanging challenges and responses until both peers have
 /// received sufficient information to authenticate each other. This method challenges
 /// the client to provide more information.
-    ConnectionSecure {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionSecure {
     /// Challenge information, a block of opaque binary data passed to the security
     /// mechanism.
-        challenge: Longstr,
+    pub challenge: Longstr,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method attempts to authenticate, passing a block of SASL data for the security
 /// mechanism at the server side.
-    ConnectionSecureOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionSecureOk {
     /// must not be null
     ///
     /// A block of opaque data passed to the security mechanism. The contents of this
     /// data are defined by the SASL security mechanism.
-        response: Longstr,
+    pub response: Longstr,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method proposes a set of connection configuration values to the client. The
 /// client can accept and/or adjust these.
-    ConnectionTune {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionTune {
     /// Specifies highest channel number that the server permits.  Usable channel numbers
     /// are in the range 1..channel-max.  Zero indicates no specified limit.
-        channel_max: Short,
+    pub channel_max: Short,
     /// The largest frame size that the server proposes for the connection, including
     /// frame header and end-byte.  The client can negotiate a lower value. Zero means
     /// that the server does not impose any specific limit but may reject very large
     /// frames if it cannot allocate resources for them.
-        frame_max: Long,
+    pub frame_max: Long,
     /// The delay, in seconds, of the connection heartbeat that the server wants.
     /// Zero means the server does not want a heartbeat.
-        heartbeat: Short,
+    pub heartbeat: Short,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method sends the client's connection tuning parameters to the server.
 /// Certain fields are negotiated, others provide capability information.
-    ConnectionTuneOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionTuneOk {
     /// must not be null, must be less than the tune field of the method channel-max
     ///
     /// The maximum total number of channels that the client will use per connection.
-        channel_max: Short,
+    pub channel_max: Short,
     /// The largest frame size that the client and server will use for the connection.
     /// Zero means that the client does not impose any specific limit but may reject
     /// very large frames if it cannot allocate resources for them. Note that the
     /// frame-max limit applies principally to content frames, where large contents can
     /// be broken into frames of arbitrary size.
-        frame_max: Long,
+    pub frame_max: Long,
     /// The delay, in seconds, of the connection heartbeat that the client wants. Zero
     /// means the client does not want a heartbeat.
-        heartbeat: Short,
+    pub heartbeat: Short,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method opens a connection to a virtual host, which is a collection of
 /// resources, and acts to separate multiple application domains within a server.
 /// The server may apply arbitrary limits per virtual host, such as the number
 /// of each type of entity that may be used, per connection and/or in total.
-    ConnectionOpen {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionOpen {
     /// The name of the virtual host to work with.
-        virtual_host: Path,
+    pub virtual_host: Path,
-        reserved_1: Shortstr,
+    pub reserved_1: Shortstr,
-        reserved_2: Bit,
+    pub reserved_2: Bit,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method signals to the client that the connection is ready for use.
-    ConnectionOpenOk { reserved_1: Shortstr },
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionOpenOk {
+    pub reserved_1: Shortstr,
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method indicates that the sender wants to close the connection. This may be
 /// due to internal conditions (e.g. a forced shut-down) or due to an error handling
 /// a specific method, i.e. an exception. When a close is due to an exception, the
 /// sender provides the class and method id of the method which caused the exception.
-    ConnectionClose {
+#[derive(Debug, Clone, PartialEq)]
-        reply_code: ReplyCode,
+pub struct ConnectionClose {
-        reply_text: ReplyText,
+    pub reply_code: ReplyCode,
+    pub reply_text: ReplyText,
     /// When the close is provoked by a method exception, this is the class of the
     /// method.
-        class_id: ClassId,
+    pub class_id: ClassId,
     /// When the close is provoked by a method exception, this is the ID of the method.
-        method_id: MethodId,
+    pub method_id: MethodId,
-    },
+}
+
 /// The connection class provides methods for a client to establish a network connection to
 /// a server, and for both peers to operate the connection thereafter.
 /// This method confirms a Connection.Close method and tells the recipient that it is
 /// safe to release resources for the connection and close the socket.
-    ConnectionCloseOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ConnectionCloseOk;
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// This method opens a channel to the server.
-    ChannelOpen { reserved_1: Shortstr },
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChannelOpen {
+    pub reserved_1: Shortstr,
+}
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// This method signals to the client that the channel is ready for use.
-    ChannelOpenOk { reserved_1: Longstr },
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChannelOpenOk {
+    pub reserved_1: Longstr,
+}
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// This method asks the peer to pause or restart the flow of content data sent by
@@ -278,145 +363,165 @@ pub enum Method {
 /// overflowing its queues or otherwise finding itself receiving more messages than
 /// it can process. Note that this method is not intended for window control. It does
 /// not affect contents returned by Basic.Get-Ok methods.
-    ChannelFlow {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChannelFlow {
     /// If 1, the peer starts sending content frames. If 0, the peer stops sending
     /// content frames.
-        active: Bit,
+    pub active: Bit,
-    },
+}
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// Confirms to the peer that a flow command was received and processed.
-    ChannelFlowOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChannelFlowOk {
     /// Confirms the setting of the processed flow method: 1 means the peer will start
     /// sending or continue to send content frames; 0 means it will not.
-        active: Bit,
+    pub active: Bit,
-    },
+}
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// This method indicates that the sender wants to close the channel. This may be due to
 /// internal conditions (e.g. a forced shut-down) or due to an error handling a specific
 /// method, i.e. an exception. When a close is due to an exception, the sender provides
 /// the class and method id of the method which caused the exception.
-    ChannelClose {
+#[derive(Debug, Clone, PartialEq)]
-        reply_code: ReplyCode,
+pub struct ChannelClose {
-        reply_text: ReplyText,
+    pub reply_code: ReplyCode,
+    pub reply_text: ReplyText,
     /// When the close is provoked by a method exception, this is the class of the
     /// method.
-        class_id: ClassId,
+    pub class_id: ClassId,
     /// When the close is provoked by a method exception, this is the ID of the method.
-        method_id: MethodId,
+    pub method_id: MethodId,
-    },
+}
+
 /// The channel class provides methods for a client to establish a channel to a
 /// server and for both peers to operate the channel thereafter.
 /// This method confirms a Channel.Close method and tells the recipient that it is safe
 /// to release resources for the channel.
-    ChannelCloseOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ChannelCloseOk;
+
 /// Exchanges match and distribute messages across queues. Exchanges can be configured in
 /// the server or declared at runtime.
 /// This method creates an exchange if it does not already exist, and if the exchange
 /// exists, verifies that it is of the correct and expected class.
-    ExchangeDeclare {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct ExchangeDeclare {
+    pub reserved_1: Short,
     /// must not be null
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Each exchange belongs to one of a set of exchange types implemented by the
     /// server. The exchange types define the functionality of the exchange - i.e. how
     /// messages are routed through it. It is not valid or meaningful to attempt to
     /// change the type of an existing exchange.
-        r#type: Shortstr,
+    pub r#type: Shortstr,
     /// If set, the server will reply with Declare-Ok if the exchange already
     /// exists with the same name, and raise an error if not.  The client can
     /// use this to check whether an exchange exists without modifying the
     /// server state. When set, all other method fields except name and no-wait
     /// are ignored.  A declare with both passive and no-wait has no effect.
     /// Arguments are compared for semantic equivalence.
-        passive: Bit,
+    pub passive: Bit,
     /// If set when creating a new exchange, the exchange will be marked as durable.
     /// Durable exchanges remain active when a server restarts. Non-durable exchanges
     /// (transient exchanges) are purged if/when a server restarts.
-        durable: Bit,
+    pub durable: Bit,
-        reserved_2: Bit,
+    pub reserved_2: Bit,
-        reserved_3: Bit,
+    pub reserved_3: Bit,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
     /// A set of arguments for the declaration. The syntax and semantics of these
     /// arguments depends on the server implementation.
-        arguments: Table,
+    pub arguments: Table,
-    },
+}
+
 /// Exchanges match and distribute messages across queues. Exchanges can be configured in
 /// the server or declared at runtime.
 /// This method confirms a Declare method and confirms the name of the exchange,
 /// essential for automatically-named exchanges.
-    ExchangeDeclareOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExchangeDeclareOk;
+
 /// Exchanges match and distribute messages across queues. Exchanges can be configured in
 /// the server or declared at runtime.
 /// This method deletes an exchange. When an exchange is deleted all queue bindings on
 /// the exchange are cancelled.
-    ExchangeDelete {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct ExchangeDelete {
+    pub reserved_1: Short,
     /// must not be null
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// If set, the server will only delete the exchange if it has no queue bindings. If
     /// the exchange has queue bindings the server does not delete it but raises a
     /// channel exception instead.
-        if_unused: Bit,
+    pub if_unused: Bit,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
-    },
+}
+
 /// Exchanges match and distribute messages across queues. Exchanges can be configured in
 /// the server or declared at runtime.
 /// This method confirms the deletion of an exchange.
-    ExchangeDeleteOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct ExchangeDeleteOk;
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method creates or checks a queue. When creating a new queue the client can
 /// specify various properties that control the durability of the queue and its
 /// contents, and the level of sharing for the queue.
-    QueueDeclare {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct QueueDeclare {
-        queue: QueueName,
+    pub reserved_1: Short,
+    pub queue: QueueName,
     /// If set, the server will reply with Declare-Ok if the queue already
     /// exists with the same name, and raise an error if not.  The client can
     /// use this to check whether a queue exists without modifying the
     /// server state.  When set, all other method fields except name and no-wait
     /// are ignored.  A declare with both passive and no-wait has no effect.
     /// Arguments are compared for semantic equivalence.
-        passive: Bit,
+    pub passive: Bit,
     /// If set when creating a new queue, the queue will be marked as durable. Durable
     /// queues remain active when a server restarts. Non-durable queues (transient
     /// queues) are purged if/when a server restarts. Note that durable queues do not
     /// necessarily hold persistent messages, although it does not make sense to send
     /// persistent messages to a transient queue.
-        durable: Bit,
+    pub durable: Bit,
     /// Exclusive queues may only be accessed by the current connection, and are
     /// deleted when that connection closes.  Passive declaration of an exclusive
     /// queue by other connections are not allowed.
-        exclusive: Bit,
+    pub exclusive: Bit,
     /// If set, the queue is deleted when all consumers have finished using it.  The last
     /// consumer can be cancelled either explicitly or because its channel is closed. If
     /// there was no consumer ever on the queue, it won't be deleted.  Applications can
     /// explicitly delete auto-delete queues using the Delete method as normal.
-        auto_delete: Bit,
+    pub auto_delete: Bit,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
     /// A set of arguments for the declaration. The syntax and semantics of these
     /// arguments depends on the server implementation.
-        arguments: Table,
+    pub arguments: Table,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method confirms a Declare method and confirms the name of the queue, essential
 /// for automatically-named queues.
-    QueueDeclareOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueueDeclareOk {
     /// must not be null
     ///
     /// Reports the name of the queue. If the server generated a queue name, this field
     /// contains that name.
-        queue: QueueName,
+    pub queue: QueueName,
-        message_count: MessageCount,
+    pub message_count: MessageCount,
     /// Reports the number of active consumers for the queue. Note that consumers can
     /// suspend activity (Channel.Flow) in which case they do not appear in this count.
-        consumer_count: Long,
+    pub consumer_count: Long,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
@@ -424,11 +529,12 @@ pub enum Method {
 /// receive any messages. In a classic messaging model, store-and-forward queues
 /// are bound to a direct exchange and subscription queues are bound to a topic
 /// exchange.
-    QueueBind {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct QueueBind {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to bind.
-        queue: QueueName,
+    pub queue: QueueName,
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key for the binding. The routing key is used for routing
     /// messages depending on the exchange configuration. Not all exchanges use a
     /// routing key - refer to the specific exchange documentation.  If the queue name
@@ -437,89 +543,105 @@ pub enum Method {
     /// key as well.  If the queue name is provided but the routing key is empty, the
     /// server does the binding with that empty routing key.  The meaning of empty
     /// routing keys depends on the exchange implementation.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
     /// A set of arguments for the binding. The syntax and semantics of these arguments
     /// depends on the exchange class.
-        arguments: Table,
+    pub arguments: Table,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method confirms that the bind was successful.
-    QueueBindOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueueBindOk;
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method unbinds a queue from an exchange.
-    QueueUnbind {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct QueueUnbind {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to unbind.
-        queue: QueueName,
+    pub queue: QueueName,
     /// The name of the exchange to unbind from.
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key of the binding to unbind.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
     /// Specifies the arguments of the binding to unbind.
-        arguments: Table,
+    pub arguments: Table,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method confirms that the unbind was successful.
-    QueueUnbindOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueueUnbindOk;
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method removes all messages from a queue which are not awaiting
 /// acknowledgment.
-    QueuePurge {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct QueuePurge {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to purge.
-        queue: QueueName,
+    pub queue: QueueName,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method confirms the purge of a queue.
-    QueuePurgeOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueuePurgeOk {
     /// Reports the number of messages purged.
-        message_count: MessageCount,
+    pub message_count: MessageCount,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method deletes a queue. When a queue is deleted any pending messages are sent
 /// to a dead-letter queue if this is defined in the server configuration, and all
 /// consumers on the queue are cancelled.
-    QueueDelete {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct QueueDelete {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to delete.
-        queue: QueueName,
+    pub queue: QueueName,
     /// If set, the server will only delete the queue if it has no consumers. If the
     /// queue has consumers the server does does not delete it but raises a channel
     /// exception instead.
-        if_unused: Bit,
+    pub if_unused: Bit,
     /// If set, the server will only delete the queue if it has no messages.
-        if_empty: Bit,
+    pub if_empty: Bit,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
-    },
+}
+
 /// Queues store and forward messages. Queues can be configured in the server or created at
 /// runtime. Queues must be attached to at least one exchange in order to receive messages
 /// from publishers.
 /// This method confirms the deletion of a queue.
-    QueueDeleteOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueueDeleteOk {
     /// Reports the number of messages deleted.
-        message_count: MessageCount,
+    pub message_count: MessageCount,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method requests a specific quality of service. The QoS can be specified for the
 /// current channel or for all channels on the connection. The particular properties and
 /// semantics of a qos method always depend on the content class semantics. Though the
 /// qos method could in principle apply to both peers, it is currently meaningful only
 /// for the server.
-    BasicQos {
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicQos {
     /// The client can request that messages be sent in advance so that when the client
     /// finishes processing a message, the following message is already held locally,
     /// rather than needing to be sent down the channel. Prefetching gives a performance
@@ -528,187 +650,224 @@ pub enum Method {
     /// available prefetch size (and also falls into other prefetch limits). May be set
     /// to zero, meaning "no specific limit", although other prefetch limits may still
     /// apply. The prefetch-size is ignored if the no-ack option is set.
-        prefetch_size: Long,
+    pub prefetch_size: Long,
     /// Specifies a prefetch window in terms of whole messages. This field may be used
     /// in combination with the prefetch-size field; a message will only be sent in
     /// advance if both prefetch windows (and those at the channel and connection level)
     /// allow it. The prefetch-count is ignored if the no-ack option is set.
-        prefetch_count: Short,
+    pub prefetch_count: Short,
     /// By default the QoS settings apply to the current channel only. If this field is
     /// set, they are applied to the entire connection.
-        global: Bit,
+    pub global: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method tells the client that the requested QoS levels could be handled by the
 /// server. The requested QoS applies to all active consumers until a new QoS is
 /// defined.
-    BasicQosOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicQosOk;
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method asks the server to start a "consumer", which is a transient request for
 /// messages from a specific queue. Consumers last as long as the channel they were
 /// declared on, or until the client cancels them.
-    BasicConsume {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct BasicConsume {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to consume from.
-        queue: QueueName,
+    pub queue: QueueName,
     /// Specifies the identifier for the consumer. The consumer tag is local to a
     /// channel, so two clients can use the same consumer tags. If this field is
     /// empty the server will generate a unique tag.
-        consumer_tag: ConsumerTag,
+    pub consumer_tag: ConsumerTag,
-        no_local: NoLocal,
+    pub no_local: NoLocal,
-        no_ack: NoAck,
+    pub no_ack: NoAck,
     /// Request exclusive consumer access, meaning only this consumer can access the
     /// queue.
-        exclusive: Bit,
+    pub exclusive: Bit,
-        no_wait: NoWait,
+    pub no_wait: NoWait,
     /// A set of arguments for the consume. The syntax and semantics of these
     /// arguments depends on the server implementation.
-        arguments: Table,
+    pub arguments: Table,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// The server provides the client with a consumer tag, which is used by the client
 /// for methods called on the consumer at a later stage.
-    BasicConsumeOk {
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicConsumeOk {
     /// Holds the consumer tag specified by the client or provided by the server.
-        consumer_tag: ConsumerTag,
+    pub consumer_tag: ConsumerTag,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method cancels a consumer. This does not affect already delivered
 /// messages, but it does mean the server will not send any more messages for
 /// that consumer. The client may receive an arbitrary number of messages in
 /// between sending the cancel method and receiving the cancel-ok reply.
-    BasicCancel {
+#[derive(Debug, Clone, PartialEq)]
-        consumer_tag: ConsumerTag,
+pub struct BasicCancel {
-        no_wait: NoWait,
+    pub consumer_tag: ConsumerTag,
-    },
+    pub no_wait: NoWait,
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method confirms that the cancellation was completed.
-    BasicCancelOk { consumer_tag: ConsumerTag },
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicCancelOk {
+    pub consumer_tag: ConsumerTag,
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method publishes a message to a specific exchange. The message will be routed
 /// to queues as defined by the exchange configuration and distributed to any active
 /// consumers when the transaction, if any, is committed.
-    BasicPublish {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct BasicPublish {
+    pub reserved_1: Short,
     /// Specifies the name of the exchange to publish to. The exchange name can be
     /// empty, meaning the default exchange. If the exchange name is specified, and that
     /// exchange does not exist, the server will raise a channel exception.
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key for the message. The routing key is used for routing
     /// messages depending on the exchange configuration.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
     /// This flag tells the server how to react if the message cannot be routed to a
     /// queue. If this flag is set, the server will return an unroutable message with a
     /// Return method. If this flag is zero, the server silently drops the message.
-        mandatory: Bit,
+    pub mandatory: Bit,
     /// This flag tells the server how to react if the message cannot be routed to a
     /// queue consumer immediately. If this flag is set, the server will return an
     /// undeliverable message with a Return method. If this flag is zero, the server
     /// will queue the message, but with no guarantee that it will ever be consumed.
-        immediate: Bit,
+    pub immediate: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method returns an undeliverable message that was published with the "immediate"
 /// flag set, or an unroutable message published with the "mandatory" flag set. The
 /// reply code and text provide information about the reason that the message was
 /// undeliverable.
-    BasicReturn {
+#[derive(Debug, Clone, PartialEq)]
-        reply_code: ReplyCode,
+pub struct BasicReturn {
-        reply_text: ReplyText,
+    pub reply_code: ReplyCode,
+    pub reply_text: ReplyText,
     /// Specifies the name of the exchange that the message was originally published
     /// to.  May be empty, meaning the default exchange.
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key name specified when the message was published.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method delivers a message to the client, via a consumer. In the asynchronous
 /// message delivery model, the client starts a consumer using the Consume method, then
 /// the server responds with Deliver methods as and when messages arrive for that
 /// consumer.
-    BasicDeliver {
+#[derive(Debug, Clone, PartialEq)]
-        consumer_tag: ConsumerTag,
+pub struct BasicDeliver {
-        delivery_tag: DeliveryTag,
+    pub consumer_tag: ConsumerTag,
-        redelivered: Redelivered,
+    pub delivery_tag: DeliveryTag,
+    pub redelivered: Redelivered,
     /// Specifies the name of the exchange that the message was originally published to.
     /// May be empty, indicating the default exchange.
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key name specified when the message was published.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method provides a direct access to the messages in a queue using a synchronous
 /// dialogue that is designed for specific types of application where synchronous
 /// functionality is more important than performance.
-    BasicGet {
+#[derive(Debug, Clone, PartialEq)]
-        reserved_1: Short,
+pub struct BasicGet {
+    pub reserved_1: Short,
     /// Specifies the name of the queue to get a message from.
-        queue: QueueName,
+    pub queue: QueueName,
-        no_ack: NoAck,
+    pub no_ack: NoAck,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method delivers a message to the client following a get method. A message
 /// delivered by 'get-ok' must be acknowledged unless the no-ack option was set in the
 /// get method.
-    BasicGetOk {
+#[derive(Debug, Clone, PartialEq)]
-        delivery_tag: DeliveryTag,
+pub struct BasicGetOk {
-        redelivered: Redelivered,
+    pub delivery_tag: DeliveryTag,
+    pub redelivered: Redelivered,
     /// Specifies the name of the exchange that the message was originally published to.
     /// If empty, the message was published to the default exchange.
-        exchange: ExchangeName,
+    pub exchange: ExchangeName,
     /// Specifies the routing key name specified when the message was published.
-        routing_key: Shortstr,
+    pub routing_key: Shortstr,
-        message_count: MessageCount,
+    pub message_count: MessageCount,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method tells the client that the queue has no messages available for the
 /// client.
-    BasicGetEmpty { reserved_1: Shortstr },
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicGetEmpty {
+    pub reserved_1: Shortstr,
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method acknowledges one or more messages delivered via the Deliver or Get-Ok
 /// methods. The client can ask to confirm a single message or a set of messages up to
 /// and including a specific message.
-    BasicAck {
+#[derive(Debug, Clone, PartialEq)]
-        delivery_tag: DeliveryTag,
+pub struct BasicAck {
+    pub delivery_tag: DeliveryTag,
     /// If set to 1, the delivery tag is treated as "up to and including", so that the
     /// client can acknowledge multiple messages with a single method. If set to zero,
     /// the delivery tag refers to a single message. If the multiple field is 1, and the
     /// delivery tag is zero, tells the server to acknowledge all outstanding messages.
-        multiple: Bit,
+    pub multiple: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method allows a client to reject a message. It can be used to interrupt and
 /// cancel large incoming messages, or return untreatable messages to their original
 /// queue.
-    BasicReject {
+#[derive(Debug, Clone, PartialEq)]
-        delivery_tag: DeliveryTag,
+pub struct BasicReject {
+    pub delivery_tag: DeliveryTag,
     /// If requeue is true, the server will attempt to requeue the message.  If requeue
     /// is false or the requeue  attempt fails the messages are discarded or dead-lettered.
-        requeue: Bit,
+    pub requeue: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method asks the server to redeliver all unacknowledged messages on a
 /// specified channel. Zero or more messages may be redelivered.  This method
 /// is deprecated in favour of the synchronous Recover/Recover-Ok.
-    BasicRecoverAsync {
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicRecoverAsync {
     /// If this field is zero, the message will be redelivered to the original
     /// recipient. If this bit is 1, the server will attempt to requeue the message,
     /// potentially then delivering it to an alternative subscriber.
-        requeue: Bit,
+    pub requeue: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method asks the server to redeliver all unacknowledged messages on a
 /// specified channel. Zero or more messages may be redelivered.  This method
 /// replaces the asynchronous Recover.
-    BasicRecover {
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicRecover {
     /// If this field is zero, the message will be redelivered to the original
     /// recipient. If this bit is 1, the server will attempt to requeue the message,
     /// potentially then delivering it to an alternative subscriber.
-        requeue: Bit,
+    pub requeue: Bit,
-    },
+}
+
 /// The Basic class provides methods that support an industry-standard messaging model.
 /// This method acknowledges a Basic.Recover method.
-    BasicRecoverOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct BasicRecoverOk;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -720,7 +879,9 @@ pub enum Method {
 /// mandatory flags on Basic.Publish methods is not defined.
 /// This method sets the channel to use standard transactions. The client must use this
 /// method at least once on a channel before using the Commit or Rollback methods.
-    TxSelect,
+#[derive(Debug, Clone, PartialEq)]
+pub struct TxSelect;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -732,7 +893,9 @@ pub enum Method {
 /// mandatory flags on Basic.Publish methods is not defined.
 /// This method confirms to the client that the channel was successfully set to use
 /// standard transactions.
-    TxSelectOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct TxSelectOk;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -744,7 +907,9 @@ pub enum Method {
 /// mandatory flags on Basic.Publish methods is not defined.
 /// This method commits all message publications and acknowledgments performed in
 /// the current transaction.  A new transaction starts immediately after a commit.
-    TxCommit,
+#[derive(Debug, Clone, PartialEq)]
+pub struct TxCommit;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -756,7 +921,9 @@ pub enum Method {
 /// mandatory flags on Basic.Publish methods is not defined.
 /// This method confirms to the client that the commit succeeded. Note that if a commit
 /// fails, the server raises a channel exception.
-    TxCommitOk,
+#[derive(Debug, Clone, PartialEq)]
+pub struct TxCommitOk;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -770,7 +937,9 @@ pub enum Method {
 /// the current transaction. A new transaction starts immediately after a rollback.
 /// Note that unacked messages will not be automatically redelivered by rollback;
 /// if that is required an explicit recover call should be issued.
-    TxRollback,
+#[derive(Debug, Clone, PartialEq)]
+pub struct TxRollback;
+
 /// The Tx class allows publish and ack operations to be batched into atomic
 /// units of work.  The intention is that all publish and ack requests issued
 /// within a transaction will complete successfully or none of them will.
@@ -782,5 +951,5 @@ pub enum Method {
 /// mandatory flags on Basic.Publish methods is not defined.
 /// This method confirms to the client that the rollback succeeded. Note that if an
 /// rollback fails, the server raises a channel exception.
-    TxRollbackOk,
+#[derive(Debug, Clone, PartialEq)]
-}
+pub struct TxRollbackOk;

amqp_messaging/src/methods/consume.rs

@@ -1,17 +1,10 @@
 use amqp_core::connection::ChannelHandle;
 use amqp_core::error::ProtocolError;
-use amqp_core::methods::{Bit, ConsumerTag, NoAck, NoLocal, NoWait, QueueName, Table};
+use amqp_core::methods::BasicConsume;
 
-#[allow(clippy::too_many_arguments)]
 pub async fn consume(
     _channel_handle: ChannelHandle,
-    _queue: QueueName,
+    _basic_consume: BasicConsume,
-    _consumer_tag: ConsumerTag,
-    _no_local: NoLocal,
-    _no_ack: NoAck,
-    _exclusive: Bit,
-    _no_wait: NoWait,
-    _arguments: Table,
 ) -> Result<(), ProtocolError> {
     Ok(())
 }

amqp_messaging/src/methods/mod.rs

@@ -22,82 +22,23 @@ pub async fn handle_method(
     info!(?method, "Handling method");
 
     match method {
-        Method::ExchangeDeclare { .. } => amqp_todo!(),
+        Method::ExchangeDeclare(_) => amqp_todo!(),
-        Method::ExchangeDeclareOk => amqp_todo!(),
+        Method::ExchangeDeclareOk(_) => amqp_todo!(),
-        Method::ExchangeDelete { .. } => amqp_todo!(),
+        Method::ExchangeDelete(_) => amqp_todo!(),
-        Method::ExchangeDeleteOk => amqp_todo!(),
+        Method::ExchangeDeleteOk(_) => amqp_todo!(),
-        Method::QueueDeclare {
+        Method::QueueDeclare(queue_declare) => queue::declare(channel_handle, queue_declare).await,
-            queue,
-            passive,
-            durable,
-            exclusive,
-            auto_delete,
-            no_wait,
-            arguments,
-            ..
-        } => {
-            queue::declare(
-                channel_handle,
-                queue,
-                passive,
-                durable,
-                exclusive,
-                auto_delete,
-                no_wait,
-                arguments,
-            )
-            .await
-        }
         Method::QueueDeclareOk { .. } => amqp_todo!(),
-        Method::QueueBind {
+        Method::QueueBind(queue_bind) => queue::bind(channel_handle, queue_bind).await,
-            queue,
+        Method::QueueBindOk(_) => amqp_todo!(),
-            exchange,
-            routing_key,
-            no_wait,
-            arguments,
-            ..
-        } => {
-            queue::bind(
-                channel_handle,
-                queue,
-                exchange,
-                routing_key,
-                no_wait,
-                arguments,
-            )
-            .await
-        }
-        Method::QueueBindOk => amqp_todo!(),
         Method::QueueUnbind { .. } => amqp_todo!(),
-        Method::QueueUnbindOk => amqp_todo!(),
+        Method::QueueUnbindOk(_) => amqp_todo!(),
         Method::QueuePurge { .. } => amqp_todo!(),
         Method::QueuePurgeOk { .. } => amqp_todo!(),
         Method::QueueDelete { .. } => amqp_todo!(),
         Method::QueueDeleteOk { .. } => amqp_todo!(),
         Method::BasicQos { .. } => amqp_todo!(),
-        Method::BasicQosOk => amqp_todo!(),
+        Method::BasicQosOk(_) => amqp_todo!(),
-        Method::BasicConsume {
+        Method::BasicConsume(consume) => consume::consume(channel_handle, consume).await,
-            queue,
-            consumer_tag,
-            no_local,
-            no_ack,
-            exclusive,
-            no_wait,
-            arguments,
-            ..
-        } => {
-            consume::consume(
-                channel_handle,
-                queue,
-                consumer_tag,
-                no_local,
-                no_ack,
-                exclusive,
-                no_wait,
-                arguments,
-            )
-            .await
-        }
         Method::BasicConsumeOk { .. } => amqp_todo!(),
         Method::BasicCancel { .. } => amqp_todo!(),
         Method::BasicCancelOk { .. } => amqp_todo!(),
@@ -110,13 +51,13 @@ pub async fn handle_method(
         Method::BasicReject { .. } => amqp_todo!(),
         Method::BasicRecoverAsync { .. } => amqp_todo!(),
         Method::BasicRecover { .. } => amqp_todo!(),
-        Method::BasicRecoverOk => amqp_todo!(),
+        Method::BasicRecoverOk(_) => amqp_todo!(),
-        Method::TxSelect
+        Method::TxSelect(_)
-        | Method::TxSelectOk
+        | Method::TxSelectOk(_)
-        | Method::TxCommit
+        | Method::TxCommit(_)
-        | Method::TxCommitOk
+        | Method::TxCommitOk(_)
-        | Method::TxRollback
+        | Method::TxRollback(_)
-        | Method::TxRollbackOk => amqp_todo!(),
+        | Method::TxRollbackOk(_) => amqp_todo!(),
         Method::BasicPublish { .. } => {
             unreachable!("Basic.Publish is handled somewhere else because it has a body")
         }

amqp_messaging/src/methods/queue.rs

@@ -1,23 +1,27 @@
 use amqp_core::connection::ChannelHandle;
 use amqp_core::error::{ConException, ProtocolError};
-use amqp_core::methods::{Bit, ExchangeName, NoWait, QueueName, Shortstr, Table};
+use amqp_core::methods::{QueueBind, QueueDeclare};
 use amqp_core::queue::{QueueDeletion, QueueId, RawQueue};
 use amqp_core::{amqp_todo, GlobalData};
 use parking_lot::Mutex;
 use std::sync::atomic::AtomicUsize;
 use std::sync::Arc;
 
-#[allow(clippy::too_many_arguments)]
 pub async fn declare(
     channel_handle: ChannelHandle,
-    queue_name: QueueName,
+    queue_declare: QueueDeclare,
-    passive: Bit,
-    durable: Bit,
-    exclusive: Bit,
-    auto_delete: Bit,
-    no_wait: NoWait,
-    arguments: Table,
 ) -> Result<(), ProtocolError> {
+    let QueueDeclare {
+        queue: queue_name,
+        passive,
+        durable,
+        exclusive,
+        auto_delete,
+        no_wait,
+        arguments,
+        ..
+    } = queue_declare;
+
     if !arguments.is_empty() {
         return Err(ConException::Todo.into());
     }
@@ -58,11 +62,7 @@ pub async fn declare(
 
 pub async fn bind(
     _channel_handle: ChannelHandle,
-    _queue: QueueName,
+    _queue_bind: QueueBind,
-    _exchange: ExchangeName,
-    _routing_key: Shortstr,
-    _no_wait: NoWait,
-    _arguments: Table,
 ) -> Result<(), ProtocolError> {
     amqp_todo!();
 }

amqp_transport/src/connection.rs

@@ -3,7 +3,11 @@ use crate::frame::{ContentHeader, Frame, FrameType};
 use crate::{frame, methods, sasl};
 use amqp_core::connection::{ChannelHandle, ChannelNum, ConnectionHandle, ConnectionId};
 use amqp_core::message::{MessageId, RawMessage, RoutingInformation};
-use amqp_core::methods::{FieldValue, Method, Table};
+use amqp_core::methods::{
+    BasicPublish, ChannelClose, ChannelCloseOk, ChannelOpenOk, ConnectionClose, ConnectionCloseOk,
+    ConnectionOpen, ConnectionOpenOk, ConnectionStart, ConnectionStartOk, ConnectionTune,
+    ConnectionTuneOk, FieldValue, Method, Table,
+};
 use amqp_core::GlobalData;
 use anyhow::Context;
 use bytes::Bytes;
@@ -134,7 +138,7 @@ impl Connection {
     }
 
     async fn start(&mut self) -> Result<()> {
-        let start_method = Method::ConnectionStart {
+        let start_method = Method::ConnectionStart(ConnectionStart {
             version_major: 0,
             version_minor: 9,
             server_properties: server_properties(
@@ -144,7 +148,7 @@ impl Connection {
             ),
             mechanisms: "PLAIN".into(),
             locales: "en_US".into(),
-        };
+        });
 
         debug!(?start_method, "Sending Start method");
         self.send_method(ChannelNum::zero(), start_method).await?;
@@ -152,12 +156,12 @@ impl Connection {
         let start_ok = self.recv_method().await?;
         debug!(?start_ok, "Received Start-Ok");
 
-        if let Method::ConnectionStartOk {
+        if let Method::ConnectionStartOk(ConnectionStartOk {
             mechanism,
             locale,
             response,
             ..
-        } = start_ok
+        }) = start_ok
         {
             ensure_conn(mechanism == "PLAIN")?;
             ensure_conn(locale == "en_US")?;
@@ -171,11 +175,11 @@ impl Connection {
     }
 
     async fn tune(&mut self) -> Result<()> {
-        let tune_method = Method::ConnectionTune {
+        let tune_method = Method::ConnectionTune(ConnectionTune {
             channel_max: CHANNEL_MAX,
             frame_max: FRAME_SIZE_MAX,
             heartbeat: HEARTBEAT_DELAY,
-        };
+        });
 
         debug!("Sending Tune method");
         self.send_method(ChannelNum::zero(), tune_method).await?;
@@ -183,11 +187,11 @@ impl Connection {
         let tune_ok = self.recv_method().await?;
         debug!(?tune_ok, "Received Tune-Ok method");
 
-        if let Method::ConnectionTuneOk {
+        if let Method::ConnectionTuneOk(ConnectionTuneOk {
             channel_max,
             frame_max,
             heartbeat,
-        } = tune_ok
+        }) = tune_ok
         {
             self.channel_max = channel_max;
             self.max_frame_size = usize::try_from(frame_max).unwrap();
@@ -202,15 +206,15 @@ impl Connection {
         let open = self.recv_method().await?;
         debug!(?open, "Received Open method");
 
-        if let Method::ConnectionOpen { virtual_host, .. } = open {
+        if let Method::ConnectionOpen(ConnectionOpen { virtual_host, .. }) = open {
             ensure_conn(virtual_host == "/")?;
         }
 
         self.send_method(
             ChannelNum::zero(),
-            Method::ConnectionOpenOk {
+            Method::ConnectionOpenOk(ConnectionOpenOk {
                 reserved_1: "".to_string(),
-            },
+            }),
         )
         .await?;
 
@@ -242,14 +246,17 @@ impl Connection {
             .map(|channel| channel.status.take());
 
         match method {
-            Method::ConnectionClose {
+            Method::ConnectionClose(ConnectionClose {
                 reply_code,
                 reply_text,
                 class_id,
                 method_id,
-            } => {
+            }) => {
                 info!(%reply_code, %reply_text, %class_id, %method_id, "Closing connection");
-                self.send_method(ChannelNum::zero(), Method::ConnectionCloseOk {})
+                self.send_method(
+                    ChannelNum::zero(),
+                    Method::ConnectionCloseOk(ConnectionCloseOk),
+                )
                 .await?;
                 return Err(ProtocolError::GracefulClose.into());
             }
@@ -344,13 +351,13 @@ impl Connection {
         // The only method with content that is sent to the server is Basic.Publish.
         ensure_conn(header.class_id == BASIC_CLASS_ID)?;
 
-        if let Method::BasicPublish {
+        if let Method::BasicPublish(BasicPublish {
             exchange,
             routing_key,
             mandatory,
             immediate,
             ..
-        } = method
+        }) = method
         {
             let message = RawMessage {
                 id: MessageId::random(),
@@ -415,9 +422,9 @@ impl Connection {
 
         self.send_method(
             channel_num,
-            Method::ChannelOpenOk {
+            Method::ChannelOpenOk(ChannelOpenOk {
                 reserved_1: Vec::new(),
-            },
+            }),
         )
         .await?;
 
@@ -425,17 +432,18 @@ impl Connection {
     }
 
     async fn channel_close(&mut self, channel_id: ChannelNum, method: Method) -> Result<()> {
-        if let Method::ChannelClose {
+        if let Method::ChannelClose(ChannelClose {
             reply_code: code,
             reply_text: reason,
             ..
-        } = method
+        }) = method
         {
             info!(%code, %reason, "Closing channel");
 
             if let Some(channel) = self.channels.remove(&channel_id) {
                 drop(channel);
-                self.send_method(channel_id, Method::ChannelCloseOk).await?;
+                self.send_method(channel_id, Method::ChannelCloseOk(ChannelCloseOk))
+                    .await?;
             } else {
                 return Err(ConException::Todo.into());
             }

amqp_transport/src/tests.rs

@@ -1,13 +1,13 @@
 use crate::frame::FrameType;
 use crate::{frame, methods};
 use amqp_core::connection::ChannelNum;
-use amqp_core::methods::{FieldValue, Method};
+use amqp_core::methods::{ConnectionStart, ConnectionStartOk, FieldValue, Method};
 use std::collections::HashMap;
 
 #[tokio::test]
 async fn write_start_ok_frame() {
     let mut payload = Vec::new();
-    let method = Method::ConnectionStart {
+    let method = Method::ConnectionStart(ConnectionStart {
         version_major: 0,
         version_minor: 9,
         server_properties: HashMap::from([(
@@ -16,7 +16,7 @@ async fn write_start_ok_frame() {
         )]),
         mechanisms: "PLAIN".into(),
         locales: "en_US".into(),
-    };
+    });
 
     methods::write::write_method(method, &mut payload).unwrap();
 
@@ -141,7 +141,7 @@ fn read_start_ok_payload() {
 
     assert_eq!(
         method,
-        Method::ConnectionStartOk {
+        Method::ConnectionStartOk(ConnectionStartOk {
             client_properties: HashMap::from([
                 (
                     "product".to_string(),
@@ -179,6 +179,6 @@ fn read_start_ok_payload() {
             mechanism: "PLAIN".to_string(),
             response: "\x00admin\x00".into(),
             locale: "en_US".to_string()
-        }
+        })
     );
 }

xtask/src/codegen/mod.rs

@@ -211,11 +211,31 @@ impl Codegen {
 
         for class in &amqp.classes {
             let enum_name = class.name.to_upper_camel_case();
+            for method in &class.methods {
+                let method_name = method.name.to_upper_camel_case();
+                write!(
+                    self.output,
+                    "    {enum_name}{method_name}({enum_name}{method_name}),"
+                )
+                .ok();
+            }
+        }
+
+        writeln!(self.output, "}}\n").ok();
+
+        // now codegen the individual structs
+        for class in &amqp.classes {
+            let class_name = class.name.to_upper_camel_case();
             for method in &class.methods {
                 let method_name = method.name.to_upper_camel_case();
                 self.doc_comment(&class.doc, 4);
                 self.doc_comment(&method.doc, 4);
-                write!(self.output, "    {enum_name}{method_name}").ok();
+                writeln!(
+                    self.output,
+                    "#[derive(Debug, Clone, PartialEq)]
+pub struct {class_name}{method_name}"
+                )
+                .ok();
                 if !method.fields.is_empty() {
                     writeln!(self.output, " {{").ok();
                     for field in &method.fields {
@@ -228,21 +248,19 @@ impl Codegen {
                             writeln!(self.output, "    /// {field_docs}").ok();
                             if !field.doc.is_empty() {
                                 writeln!(self.output, "    ///").ok();
-                                self.doc_comment(&field.doc, 8);
+                                self.doc_comment(&field.doc, 4);
                             }
                         } else {
-                            self.doc_comment(&field.doc, 8);
+                            self.doc_comment(&field.doc, 4);
                         }
-                        writeln!(self.output, "        {field_name}: {field_type},").ok();
+                        writeln!(self.output, "    pub {field_name}: {field_type},").ok();
                     }
-                    writeln!(self.output, "    }},").ok();
-                } else {
-                    writeln!(self.output, ",").ok();
-                }
-            }
-        }
-
                     writeln!(self.output, "    }}\n").ok();
+                } else {
+                    writeln!(self.output, ";\n").ok();
+                }
+            }
+        }
     }
 
     fn amqp_type_to_rust_type(&self, amqp_type: &str) -> &'static str {

xtask/src/codegen/parser.rs

@@ -154,14 +154,14 @@ pub type IResult<'a, T> = nom::IResult<&'a [u8], T, TransError>;
         let method_name = method.name.to_upper_camel_case();
         writeln!(
             self.output,
-            "    Ok((input, Method::{class_name}{method_name} {{"
+            "    Ok((input, Method::{class_name}{method_name}({class_name}{method_name} {{"
         )
         .ok();
         for field in &method.fields {
             let field_name = self.snake_case(&field.name);
             writeln!(self.output, "        {field_name},").ok();
         }
-        writeln!(self.output, "    }}))").ok();
+        writeln!(self.output, "    }})))").ok();
 
         writeln!(self.output, "}}").ok();
     }

xtask/src/codegen/random.rs

@@ -43,7 +43,7 @@ use crate::methods::RandomMethod;
                 let method_name = method.name.to_upper_camel_case();
                 writeln!(
                     self.output,
-                    "                    {i} => Method::{class_name}{method_name} {{"
+                    "                    {i} => Method::{class_name}{method_name}( {class_name}{method_name}{{"
                 )
                 .ok();
                 for field in &method.fields {
@@ -54,7 +54,7 @@ use crate::methods::RandomMethod;
                     )
                     .ok();
                 }
-                writeln!(self.output, "                    }},").ok();
+                writeln!(self.output, "                    }}),").ok();
             }
             writeln!(
                 self.output,

xtask/src/codegen/write.rs

@@ -22,12 +22,16 @@ pub fn write_method<W: Write>(method: Method, mut writer: W) -> Result<(), Trans
             for method in &class.methods {
                 let method_name = method.name.to_upper_camel_case();
                 let method_index = method.index;
-                writeln!(self.output, "        Method::{class_name}{method_name} {{").ok();
+                writeln!(
+                    self.output,
+                    "        Method::{class_name}{method_name}({class_name}{method_name} {{"
+                )
+                .ok();
                 for field in &method.fields {
                     let field_name = self.snake_case(&field.name);
                     writeln!(self.output, "            {field_name},").ok();
                 }
-                writeln!(self.output, "        }} => {{").ok();
+                writeln!(self.output, "        }}) => {{").ok();
                 let [ci0, ci1] = class_index.to_be_bytes();
                 let [mi0, mi1] = method_index.to_be_bytes();
                 writeln!(