aboutsummaryrefslogtreecommitdiffstats
path: root/src/dma/vendor/github.com/streadway/amqp/spec091.go
diff options
context:
space:
mode:
Diffstat (limited to 'src/dma/vendor/github.com/streadway/amqp/spec091.go')
-rw-r--r--src/dma/vendor/github.com/streadway/amqp/spec091.go3306
1 files changed, 3306 insertions, 0 deletions
diff --git a/src/dma/vendor/github.com/streadway/amqp/spec091.go b/src/dma/vendor/github.com/streadway/amqp/spec091.go
new file mode 100644
index 00000000..cd53ebe7
--- /dev/null
+++ b/src/dma/vendor/github.com/streadway/amqp/spec091.go
@@ -0,0 +1,3306 @@
+// Copyright (c) 2012, Sean Treadway, SoundCloud Ltd.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+// Source code and contact info at http://github.com/streadway/amqp
+
+/* GENERATED FILE - DO NOT EDIT */
+/* Rebuild from the spec/gen.go tool */
+
+package amqp
+
+import (
+ "encoding/binary"
+ "fmt"
+ "io"
+)
+
+// Error codes that can be sent from the server during a connection or
+// channel exception or used by the client to indicate a class of error like
+// ErrCredentials. The text of the error is likely more interesting than
+// these constants.
+const (
+ frameMethod = 1
+ frameHeader = 2
+ frameBody = 3
+ frameHeartbeat = 8
+ frameMinSize = 4096
+ frameEnd = 206
+ replySuccess = 200
+ ContentTooLarge = 311
+ NoRoute = 312
+ NoConsumers = 313
+ ConnectionForced = 320
+ InvalidPath = 402
+ AccessRefused = 403
+ NotFound = 404
+ ResourceLocked = 405
+ PreconditionFailed = 406
+ FrameError = 501
+ SyntaxError = 502
+ CommandInvalid = 503
+ ChannelError = 504
+ UnexpectedFrame = 505
+ ResourceError = 506
+ NotAllowed = 530
+ NotImplemented = 540
+ InternalError = 541
+)
+
+func isSoftExceptionCode(code int) bool {
+ switch code {
+ case 311:
+ return true
+ case 312:
+ return true
+ case 313:
+ return true
+ case 403:
+ return true
+ case 404:
+ return true
+ case 405:
+ return true
+ case 406:
+ return true
+
+ }
+ return false
+}
+
+type connectionStart struct {
+ VersionMajor byte
+ VersionMinor byte
+ ServerProperties Table
+ Mechanisms string
+ Locales string
+}
+
+func (msg *connectionStart) id() (uint16, uint16) {
+ return 10, 10
+}
+
+func (msg *connectionStart) wait() bool {
+ return true
+}
+
+func (msg *connectionStart) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.VersionMajor); err != nil {
+ return
+ }
+ if err = binary.Write(w, binary.BigEndian, msg.VersionMinor); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.ServerProperties); err != nil {
+ return
+ }
+
+ if err = writeLongstr(w, msg.Mechanisms); err != nil {
+ return
+ }
+ if err = writeLongstr(w, msg.Locales); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionStart) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.VersionMajor); err != nil {
+ return
+ }
+ if err = binary.Read(r, binary.BigEndian, &msg.VersionMinor); err != nil {
+ return
+ }
+
+ if msg.ServerProperties, err = readTable(r); err != nil {
+ return
+ }
+
+ if msg.Mechanisms, err = readLongstr(r); err != nil {
+ return
+ }
+ if msg.Locales, err = readLongstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionStartOk struct {
+ ClientProperties Table
+ Mechanism string
+ Response string
+ Locale string
+}
+
+func (msg *connectionStartOk) id() (uint16, uint16) {
+ return 10, 11
+}
+
+func (msg *connectionStartOk) wait() bool {
+ return true
+}
+
+func (msg *connectionStartOk) write(w io.Writer) (err error) {
+
+ if err = writeTable(w, msg.ClientProperties); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Mechanism); err != nil {
+ return
+ }
+
+ if err = writeLongstr(w, msg.Response); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Locale); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionStartOk) read(r io.Reader) (err error) {
+
+ if msg.ClientProperties, err = readTable(r); err != nil {
+ return
+ }
+
+ if msg.Mechanism, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if msg.Response, err = readLongstr(r); err != nil {
+ return
+ }
+
+ if msg.Locale, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionSecure struct {
+ Challenge string
+}
+
+func (msg *connectionSecure) id() (uint16, uint16) {
+ return 10, 20
+}
+
+func (msg *connectionSecure) wait() bool {
+ return true
+}
+
+func (msg *connectionSecure) write(w io.Writer) (err error) {
+
+ if err = writeLongstr(w, msg.Challenge); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionSecure) read(r io.Reader) (err error) {
+
+ if msg.Challenge, err = readLongstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionSecureOk struct {
+ Response string
+}
+
+func (msg *connectionSecureOk) id() (uint16, uint16) {
+ return 10, 21
+}
+
+func (msg *connectionSecureOk) wait() bool {
+ return true
+}
+
+func (msg *connectionSecureOk) write(w io.Writer) (err error) {
+
+ if err = writeLongstr(w, msg.Response); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionSecureOk) read(r io.Reader) (err error) {
+
+ if msg.Response, err = readLongstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionTune struct {
+ ChannelMax uint16
+ FrameMax uint32
+ Heartbeat uint16
+}
+
+func (msg *connectionTune) id() (uint16, uint16) {
+ return 10, 30
+}
+
+func (msg *connectionTune) wait() bool {
+ return true
+}
+
+func (msg *connectionTune) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.ChannelMax); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.FrameMax); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.Heartbeat); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionTune) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ChannelMax); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.FrameMax); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.Heartbeat); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionTuneOk struct {
+ ChannelMax uint16
+ FrameMax uint32
+ Heartbeat uint16
+}
+
+func (msg *connectionTuneOk) id() (uint16, uint16) {
+ return 10, 31
+}
+
+func (msg *connectionTuneOk) wait() bool {
+ return true
+}
+
+func (msg *connectionTuneOk) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.ChannelMax); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.FrameMax); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.Heartbeat); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionTuneOk) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ChannelMax); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.FrameMax); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.Heartbeat); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionOpen struct {
+ VirtualHost string
+ reserved1 string
+ reserved2 bool
+}
+
+func (msg *connectionOpen) id() (uint16, uint16) {
+ return 10, 40
+}
+
+func (msg *connectionOpen) wait() bool {
+ return true
+}
+
+func (msg *connectionOpen) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = writeShortstr(w, msg.VirtualHost); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.reserved2 {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionOpen) read(r io.Reader) (err error) {
+ var bits byte
+
+ if msg.VirtualHost, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.reserved1, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.reserved2 = (bits&(1<<0) > 0)
+
+ return
+}
+
+type connectionOpenOk struct {
+ reserved1 string
+}
+
+func (msg *connectionOpenOk) id() (uint16, uint16) {
+ return 10, 41
+}
+
+func (msg *connectionOpenOk) wait() bool {
+ return true
+}
+
+func (msg *connectionOpenOk) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.reserved1); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionOpenOk) read(r io.Reader) (err error) {
+
+ if msg.reserved1, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionClose struct {
+ ReplyCode uint16
+ ReplyText string
+ ClassId uint16
+ MethodId uint16
+}
+
+func (msg *connectionClose) id() (uint16, uint16) {
+ return 10, 50
+}
+
+func (msg *connectionClose) wait() bool {
+ return true
+}
+
+func (msg *connectionClose) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.ReplyCode); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.ReplyText); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.ClassId); err != nil {
+ return
+ }
+ if err = binary.Write(w, binary.BigEndian, msg.MethodId); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionClose) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ReplyCode); err != nil {
+ return
+ }
+
+ if msg.ReplyText, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ClassId); err != nil {
+ return
+ }
+ if err = binary.Read(r, binary.BigEndian, &msg.MethodId); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionCloseOk struct {
+}
+
+func (msg *connectionCloseOk) id() (uint16, uint16) {
+ return 10, 51
+}
+
+func (msg *connectionCloseOk) wait() bool {
+ return true
+}
+
+func (msg *connectionCloseOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *connectionCloseOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type connectionBlocked struct {
+ Reason string
+}
+
+func (msg *connectionBlocked) id() (uint16, uint16) {
+ return 10, 60
+}
+
+func (msg *connectionBlocked) wait() bool {
+ return false
+}
+
+func (msg *connectionBlocked) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.Reason); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *connectionBlocked) read(r io.Reader) (err error) {
+
+ if msg.Reason, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type connectionUnblocked struct {
+}
+
+func (msg *connectionUnblocked) id() (uint16, uint16) {
+ return 10, 61
+}
+
+func (msg *connectionUnblocked) wait() bool {
+ return false
+}
+
+func (msg *connectionUnblocked) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *connectionUnblocked) read(r io.Reader) (err error) {
+
+ return
+}
+
+type channelOpen struct {
+ reserved1 string
+}
+
+func (msg *channelOpen) id() (uint16, uint16) {
+ return 20, 10
+}
+
+func (msg *channelOpen) wait() bool {
+ return true
+}
+
+func (msg *channelOpen) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.reserved1); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *channelOpen) read(r io.Reader) (err error) {
+
+ if msg.reserved1, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type channelOpenOk struct {
+ reserved1 string
+}
+
+func (msg *channelOpenOk) id() (uint16, uint16) {
+ return 20, 11
+}
+
+func (msg *channelOpenOk) wait() bool {
+ return true
+}
+
+func (msg *channelOpenOk) write(w io.Writer) (err error) {
+
+ if err = writeLongstr(w, msg.reserved1); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *channelOpenOk) read(r io.Reader) (err error) {
+
+ if msg.reserved1, err = readLongstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type channelFlow struct {
+ Active bool
+}
+
+func (msg *channelFlow) id() (uint16, uint16) {
+ return 20, 20
+}
+
+func (msg *channelFlow) wait() bool {
+ return true
+}
+
+func (msg *channelFlow) write(w io.Writer) (err error) {
+ var bits byte
+
+ if msg.Active {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *channelFlow) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Active = (bits&(1<<0) > 0)
+
+ return
+}
+
+type channelFlowOk struct {
+ Active bool
+}
+
+func (msg *channelFlowOk) id() (uint16, uint16) {
+ return 20, 21
+}
+
+func (msg *channelFlowOk) wait() bool {
+ return false
+}
+
+func (msg *channelFlowOk) write(w io.Writer) (err error) {
+ var bits byte
+
+ if msg.Active {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *channelFlowOk) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Active = (bits&(1<<0) > 0)
+
+ return
+}
+
+type channelClose struct {
+ ReplyCode uint16
+ ReplyText string
+ ClassId uint16
+ MethodId uint16
+}
+
+func (msg *channelClose) id() (uint16, uint16) {
+ return 20, 40
+}
+
+func (msg *channelClose) wait() bool {
+ return true
+}
+
+func (msg *channelClose) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.ReplyCode); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.ReplyText); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.ClassId); err != nil {
+ return
+ }
+ if err = binary.Write(w, binary.BigEndian, msg.MethodId); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *channelClose) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ReplyCode); err != nil {
+ return
+ }
+
+ if msg.ReplyText, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ClassId); err != nil {
+ return
+ }
+ if err = binary.Read(r, binary.BigEndian, &msg.MethodId); err != nil {
+ return
+ }
+
+ return
+}
+
+type channelCloseOk struct {
+}
+
+func (msg *channelCloseOk) id() (uint16, uint16) {
+ return 20, 41
+}
+
+func (msg *channelCloseOk) wait() bool {
+ return true
+}
+
+func (msg *channelCloseOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *channelCloseOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type exchangeDeclare struct {
+ reserved1 uint16
+ Exchange string
+ Type string
+ Passive bool
+ Durable bool
+ AutoDelete bool
+ Internal bool
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *exchangeDeclare) id() (uint16, uint16) {
+ return 40, 10
+}
+
+func (msg *exchangeDeclare) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *exchangeDeclare) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Type); err != nil {
+ return
+ }
+
+ if msg.Passive {
+ bits |= 1 << 0
+ }
+
+ if msg.Durable {
+ bits |= 1 << 1
+ }
+
+ if msg.AutoDelete {
+ bits |= 1 << 2
+ }
+
+ if msg.Internal {
+ bits |= 1 << 3
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 4
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *exchangeDeclare) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Type, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Passive = (bits&(1<<0) > 0)
+ msg.Durable = (bits&(1<<1) > 0)
+ msg.AutoDelete = (bits&(1<<2) > 0)
+ msg.Internal = (bits&(1<<3) > 0)
+ msg.NoWait = (bits&(1<<4) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type exchangeDeclareOk struct {
+}
+
+func (msg *exchangeDeclareOk) id() (uint16, uint16) {
+ return 40, 11
+}
+
+func (msg *exchangeDeclareOk) wait() bool {
+ return true
+}
+
+func (msg *exchangeDeclareOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *exchangeDeclareOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type exchangeDelete struct {
+ reserved1 uint16
+ Exchange string
+ IfUnused bool
+ NoWait bool
+}
+
+func (msg *exchangeDelete) id() (uint16, uint16) {
+ return 40, 20
+}
+
+func (msg *exchangeDelete) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *exchangeDelete) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+
+ if msg.IfUnused {
+ bits |= 1 << 0
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 1
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *exchangeDelete) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.IfUnused = (bits&(1<<0) > 0)
+ msg.NoWait = (bits&(1<<1) > 0)
+
+ return
+}
+
+type exchangeDeleteOk struct {
+}
+
+func (msg *exchangeDeleteOk) id() (uint16, uint16) {
+ return 40, 21
+}
+
+func (msg *exchangeDeleteOk) wait() bool {
+ return true
+}
+
+func (msg *exchangeDeleteOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *exchangeDeleteOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type exchangeBind struct {
+ reserved1 uint16
+ Destination string
+ Source string
+ RoutingKey string
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *exchangeBind) id() (uint16, uint16) {
+ return 40, 30
+}
+
+func (msg *exchangeBind) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *exchangeBind) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Destination); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Source); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *exchangeBind) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Destination, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Source, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoWait = (bits&(1<<0) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type exchangeBindOk struct {
+}
+
+func (msg *exchangeBindOk) id() (uint16, uint16) {
+ return 40, 31
+}
+
+func (msg *exchangeBindOk) wait() bool {
+ return true
+}
+
+func (msg *exchangeBindOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *exchangeBindOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type exchangeUnbind struct {
+ reserved1 uint16
+ Destination string
+ Source string
+ RoutingKey string
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *exchangeUnbind) id() (uint16, uint16) {
+ return 40, 40
+}
+
+func (msg *exchangeUnbind) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *exchangeUnbind) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Destination); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Source); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *exchangeUnbind) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Destination, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Source, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoWait = (bits&(1<<0) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type exchangeUnbindOk struct {
+}
+
+func (msg *exchangeUnbindOk) id() (uint16, uint16) {
+ return 40, 51
+}
+
+func (msg *exchangeUnbindOk) wait() bool {
+ return true
+}
+
+func (msg *exchangeUnbindOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *exchangeUnbindOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type queueDeclare struct {
+ reserved1 uint16
+ Queue string
+ Passive bool
+ Durable bool
+ Exclusive bool
+ AutoDelete bool
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *queueDeclare) id() (uint16, uint16) {
+ return 50, 10
+}
+
+func (msg *queueDeclare) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *queueDeclare) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+
+ if msg.Passive {
+ bits |= 1 << 0
+ }
+
+ if msg.Durable {
+ bits |= 1 << 1
+ }
+
+ if msg.Exclusive {
+ bits |= 1 << 2
+ }
+
+ if msg.AutoDelete {
+ bits |= 1 << 3
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 4
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueDeclare) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Passive = (bits&(1<<0) > 0)
+ msg.Durable = (bits&(1<<1) > 0)
+ msg.Exclusive = (bits&(1<<2) > 0)
+ msg.AutoDelete = (bits&(1<<3) > 0)
+ msg.NoWait = (bits&(1<<4) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type queueDeclareOk struct {
+ Queue string
+ MessageCount uint32
+ ConsumerCount uint32
+}
+
+func (msg *queueDeclareOk) id() (uint16, uint16) {
+ return 50, 11
+}
+
+func (msg *queueDeclareOk) wait() bool {
+ return true
+}
+
+func (msg *queueDeclareOk) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.MessageCount); err != nil {
+ return
+ }
+ if err = binary.Write(w, binary.BigEndian, msg.ConsumerCount); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueDeclareOk) read(r io.Reader) (err error) {
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.MessageCount); err != nil {
+ return
+ }
+ if err = binary.Read(r, binary.BigEndian, &msg.ConsumerCount); err != nil {
+ return
+ }
+
+ return
+}
+
+type queueBind struct {
+ reserved1 uint16
+ Queue string
+ Exchange string
+ RoutingKey string
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *queueBind) id() (uint16, uint16) {
+ return 50, 20
+}
+
+func (msg *queueBind) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *queueBind) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueBind) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoWait = (bits&(1<<0) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type queueBindOk struct {
+}
+
+func (msg *queueBindOk) id() (uint16, uint16) {
+ return 50, 21
+}
+
+func (msg *queueBindOk) wait() bool {
+ return true
+}
+
+func (msg *queueBindOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *queueBindOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type queueUnbind struct {
+ reserved1 uint16
+ Queue string
+ Exchange string
+ RoutingKey string
+ Arguments Table
+}
+
+func (msg *queueUnbind) id() (uint16, uint16) {
+ return 50, 50
+}
+
+func (msg *queueUnbind) wait() bool {
+ return true
+}
+
+func (msg *queueUnbind) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueUnbind) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type queueUnbindOk struct {
+}
+
+func (msg *queueUnbindOk) id() (uint16, uint16) {
+ return 50, 51
+}
+
+func (msg *queueUnbindOk) wait() bool {
+ return true
+}
+
+func (msg *queueUnbindOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *queueUnbindOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type queuePurge struct {
+ reserved1 uint16
+ Queue string
+ NoWait bool
+}
+
+func (msg *queuePurge) id() (uint16, uint16) {
+ return 50, 30
+}
+
+func (msg *queuePurge) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *queuePurge) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queuePurge) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoWait = (bits&(1<<0) > 0)
+
+ return
+}
+
+type queuePurgeOk struct {
+ MessageCount uint32
+}
+
+func (msg *queuePurgeOk) id() (uint16, uint16) {
+ return 50, 31
+}
+
+func (msg *queuePurgeOk) wait() bool {
+ return true
+}
+
+func (msg *queuePurgeOk) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queuePurgeOk) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+type queueDelete struct {
+ reserved1 uint16
+ Queue string
+ IfUnused bool
+ IfEmpty bool
+ NoWait bool
+}
+
+func (msg *queueDelete) id() (uint16, uint16) {
+ return 50, 40
+}
+
+func (msg *queueDelete) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *queueDelete) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+
+ if msg.IfUnused {
+ bits |= 1 << 0
+ }
+
+ if msg.IfEmpty {
+ bits |= 1 << 1
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 2
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueDelete) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.IfUnused = (bits&(1<<0) > 0)
+ msg.IfEmpty = (bits&(1<<1) > 0)
+ msg.NoWait = (bits&(1<<2) > 0)
+
+ return
+}
+
+type queueDeleteOk struct {
+ MessageCount uint32
+}
+
+func (msg *queueDeleteOk) id() (uint16, uint16) {
+ return 50, 41
+}
+
+func (msg *queueDeleteOk) wait() bool {
+ return true
+}
+
+func (msg *queueDeleteOk) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *queueDeleteOk) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicQos struct {
+ PrefetchSize uint32
+ PrefetchCount uint16
+ Global bool
+}
+
+func (msg *basicQos) id() (uint16, uint16) {
+ return 60, 10
+}
+
+func (msg *basicQos) wait() bool {
+ return true
+}
+
+func (msg *basicQos) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.PrefetchSize); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.PrefetchCount); err != nil {
+ return
+ }
+
+ if msg.Global {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicQos) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.PrefetchSize); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.PrefetchCount); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Global = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicQosOk struct {
+}
+
+func (msg *basicQosOk) id() (uint16, uint16) {
+ return 60, 11
+}
+
+func (msg *basicQosOk) wait() bool {
+ return true
+}
+
+func (msg *basicQosOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *basicQosOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type basicConsume struct {
+ reserved1 uint16
+ Queue string
+ ConsumerTag string
+ NoLocal bool
+ NoAck bool
+ Exclusive bool
+ NoWait bool
+ Arguments Table
+}
+
+func (msg *basicConsume) id() (uint16, uint16) {
+ return 60, 20
+}
+
+func (msg *basicConsume) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *basicConsume) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.ConsumerTag); err != nil {
+ return
+ }
+
+ if msg.NoLocal {
+ bits |= 1 << 0
+ }
+
+ if msg.NoAck {
+ bits |= 1 << 1
+ }
+
+ if msg.Exclusive {
+ bits |= 1 << 2
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 3
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeTable(w, msg.Arguments); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicConsume) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.ConsumerTag, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoLocal = (bits&(1<<0) > 0)
+ msg.NoAck = (bits&(1<<1) > 0)
+ msg.Exclusive = (bits&(1<<2) > 0)
+ msg.NoWait = (bits&(1<<3) > 0)
+
+ if msg.Arguments, err = readTable(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicConsumeOk struct {
+ ConsumerTag string
+}
+
+func (msg *basicConsumeOk) id() (uint16, uint16) {
+ return 60, 21
+}
+
+func (msg *basicConsumeOk) wait() bool {
+ return true
+}
+
+func (msg *basicConsumeOk) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.ConsumerTag); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicConsumeOk) read(r io.Reader) (err error) {
+
+ if msg.ConsumerTag, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicCancel struct {
+ ConsumerTag string
+ NoWait bool
+}
+
+func (msg *basicCancel) id() (uint16, uint16) {
+ return 60, 30
+}
+
+func (msg *basicCancel) wait() bool {
+ return true && !msg.NoWait
+}
+
+func (msg *basicCancel) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = writeShortstr(w, msg.ConsumerTag); err != nil {
+ return
+ }
+
+ if msg.NoWait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicCancel) read(r io.Reader) (err error) {
+ var bits byte
+
+ if msg.ConsumerTag, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoWait = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicCancelOk struct {
+ ConsumerTag string
+}
+
+func (msg *basicCancelOk) id() (uint16, uint16) {
+ return 60, 31
+}
+
+func (msg *basicCancelOk) wait() bool {
+ return true
+}
+
+func (msg *basicCancelOk) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.ConsumerTag); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicCancelOk) read(r io.Reader) (err error) {
+
+ if msg.ConsumerTag, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicPublish struct {
+ reserved1 uint16
+ Exchange string
+ RoutingKey string
+ Mandatory bool
+ Immediate bool
+ Properties properties
+ Body []byte
+}
+
+func (msg *basicPublish) id() (uint16, uint16) {
+ return 60, 40
+}
+
+func (msg *basicPublish) wait() bool {
+ return false
+}
+
+func (msg *basicPublish) getContent() (properties, []byte) {
+ return msg.Properties, msg.Body
+}
+
+func (msg *basicPublish) setContent(props properties, body []byte) {
+ msg.Properties, msg.Body = props, body
+}
+
+func (msg *basicPublish) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if msg.Mandatory {
+ bits |= 1 << 0
+ }
+
+ if msg.Immediate {
+ bits |= 1 << 1
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicPublish) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Mandatory = (bits&(1<<0) > 0)
+ msg.Immediate = (bits&(1<<1) > 0)
+
+ return
+}
+
+type basicReturn struct {
+ ReplyCode uint16
+ ReplyText string
+ Exchange string
+ RoutingKey string
+ Properties properties
+ Body []byte
+}
+
+func (msg *basicReturn) id() (uint16, uint16) {
+ return 60, 50
+}
+
+func (msg *basicReturn) wait() bool {
+ return false
+}
+
+func (msg *basicReturn) getContent() (properties, []byte) {
+ return msg.Properties, msg.Body
+}
+
+func (msg *basicReturn) setContent(props properties, body []byte) {
+ msg.Properties, msg.Body = props, body
+}
+
+func (msg *basicReturn) write(w io.Writer) (err error) {
+
+ if err = binary.Write(w, binary.BigEndian, msg.ReplyCode); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.ReplyText); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicReturn) read(r io.Reader) (err error) {
+
+ if err = binary.Read(r, binary.BigEndian, &msg.ReplyCode); err != nil {
+ return
+ }
+
+ if msg.ReplyText, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicDeliver struct {
+ ConsumerTag string
+ DeliveryTag uint64
+ Redelivered bool
+ Exchange string
+ RoutingKey string
+ Properties properties
+ Body []byte
+}
+
+func (msg *basicDeliver) id() (uint16, uint16) {
+ return 60, 60
+}
+
+func (msg *basicDeliver) wait() bool {
+ return false
+}
+
+func (msg *basicDeliver) getContent() (properties, []byte) {
+ return msg.Properties, msg.Body
+}
+
+func (msg *basicDeliver) setContent(props properties, body []byte) {
+ msg.Properties, msg.Body = props, body
+}
+
+func (msg *basicDeliver) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = writeShortstr(w, msg.ConsumerTag); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if msg.Redelivered {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicDeliver) read(r io.Reader) (err error) {
+ var bits byte
+
+ if msg.ConsumerTag, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Redelivered = (bits&(1<<0) > 0)
+
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicGet struct {
+ reserved1 uint16
+ Queue string
+ NoAck bool
+}
+
+func (msg *basicGet) id() (uint16, uint16) {
+ return 60, 70
+}
+
+func (msg *basicGet) wait() bool {
+ return true
+}
+
+func (msg *basicGet) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.reserved1); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Queue); err != nil {
+ return
+ }
+
+ if msg.NoAck {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicGet) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.reserved1); err != nil {
+ return
+ }
+
+ if msg.Queue, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.NoAck = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicGetOk struct {
+ DeliveryTag uint64
+ Redelivered bool
+ Exchange string
+ RoutingKey string
+ MessageCount uint32
+ Properties properties
+ Body []byte
+}
+
+func (msg *basicGetOk) id() (uint16, uint16) {
+ return 60, 71
+}
+
+func (msg *basicGetOk) wait() bool {
+ return true
+}
+
+func (msg *basicGetOk) getContent() (properties, []byte) {
+ return msg.Properties, msg.Body
+}
+
+func (msg *basicGetOk) setContent(props properties, body []byte) {
+ msg.Properties, msg.Body = props, body
+}
+
+func (msg *basicGetOk) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if msg.Redelivered {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ if err = writeShortstr(w, msg.Exchange); err != nil {
+ return
+ }
+ if err = writeShortstr(w, msg.RoutingKey); err != nil {
+ return
+ }
+
+ if err = binary.Write(w, binary.BigEndian, msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicGetOk) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Redelivered = (bits&(1<<0) > 0)
+
+ if msg.Exchange, err = readShortstr(r); err != nil {
+ return
+ }
+ if msg.RoutingKey, err = readShortstr(r); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &msg.MessageCount); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicGetEmpty struct {
+ reserved1 string
+}
+
+func (msg *basicGetEmpty) id() (uint16, uint16) {
+ return 60, 72
+}
+
+func (msg *basicGetEmpty) wait() bool {
+ return true
+}
+
+func (msg *basicGetEmpty) write(w io.Writer) (err error) {
+
+ if err = writeShortstr(w, msg.reserved1); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicGetEmpty) read(r io.Reader) (err error) {
+
+ if msg.reserved1, err = readShortstr(r); err != nil {
+ return
+ }
+
+ return
+}
+
+type basicAck struct {
+ DeliveryTag uint64
+ Multiple bool
+}
+
+func (msg *basicAck) id() (uint16, uint16) {
+ return 60, 80
+}
+
+func (msg *basicAck) wait() bool {
+ return false
+}
+
+func (msg *basicAck) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if msg.Multiple {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicAck) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Multiple = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicReject struct {
+ DeliveryTag uint64
+ Requeue bool
+}
+
+func (msg *basicReject) id() (uint16, uint16) {
+ return 60, 90
+}
+
+func (msg *basicReject) wait() bool {
+ return false
+}
+
+func (msg *basicReject) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if msg.Requeue {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicReject) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Requeue = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicRecoverAsync struct {
+ Requeue bool
+}
+
+func (msg *basicRecoverAsync) id() (uint16, uint16) {
+ return 60, 100
+}
+
+func (msg *basicRecoverAsync) wait() bool {
+ return false
+}
+
+func (msg *basicRecoverAsync) write(w io.Writer) (err error) {
+ var bits byte
+
+ if msg.Requeue {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicRecoverAsync) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Requeue = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicRecover struct {
+ Requeue bool
+}
+
+func (msg *basicRecover) id() (uint16, uint16) {
+ return 60, 110
+}
+
+func (msg *basicRecover) wait() bool {
+ return true
+}
+
+func (msg *basicRecover) write(w io.Writer) (err error) {
+ var bits byte
+
+ if msg.Requeue {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicRecover) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Requeue = (bits&(1<<0) > 0)
+
+ return
+}
+
+type basicRecoverOk struct {
+}
+
+func (msg *basicRecoverOk) id() (uint16, uint16) {
+ return 60, 111
+}
+
+func (msg *basicRecoverOk) wait() bool {
+ return true
+}
+
+func (msg *basicRecoverOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *basicRecoverOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type basicNack struct {
+ DeliveryTag uint64
+ Multiple bool
+ Requeue bool
+}
+
+func (msg *basicNack) id() (uint16, uint16) {
+ return 60, 120
+}
+
+func (msg *basicNack) wait() bool {
+ return false
+}
+
+func (msg *basicNack) write(w io.Writer) (err error) {
+ var bits byte
+
+ if err = binary.Write(w, binary.BigEndian, msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if msg.Multiple {
+ bits |= 1 << 0
+ }
+
+ if msg.Requeue {
+ bits |= 1 << 1
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *basicNack) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &msg.DeliveryTag); err != nil {
+ return
+ }
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Multiple = (bits&(1<<0) > 0)
+ msg.Requeue = (bits&(1<<1) > 0)
+
+ return
+}
+
+type txSelect struct {
+}
+
+func (msg *txSelect) id() (uint16, uint16) {
+ return 90, 10
+}
+
+func (msg *txSelect) wait() bool {
+ return true
+}
+
+func (msg *txSelect) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txSelect) read(r io.Reader) (err error) {
+
+ return
+}
+
+type txSelectOk struct {
+}
+
+func (msg *txSelectOk) id() (uint16, uint16) {
+ return 90, 11
+}
+
+func (msg *txSelectOk) wait() bool {
+ return true
+}
+
+func (msg *txSelectOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txSelectOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type txCommit struct {
+}
+
+func (msg *txCommit) id() (uint16, uint16) {
+ return 90, 20
+}
+
+func (msg *txCommit) wait() bool {
+ return true
+}
+
+func (msg *txCommit) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txCommit) read(r io.Reader) (err error) {
+
+ return
+}
+
+type txCommitOk struct {
+}
+
+func (msg *txCommitOk) id() (uint16, uint16) {
+ return 90, 21
+}
+
+func (msg *txCommitOk) wait() bool {
+ return true
+}
+
+func (msg *txCommitOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txCommitOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type txRollback struct {
+}
+
+func (msg *txRollback) id() (uint16, uint16) {
+ return 90, 30
+}
+
+func (msg *txRollback) wait() bool {
+ return true
+}
+
+func (msg *txRollback) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txRollback) read(r io.Reader) (err error) {
+
+ return
+}
+
+type txRollbackOk struct {
+}
+
+func (msg *txRollbackOk) id() (uint16, uint16) {
+ return 90, 31
+}
+
+func (msg *txRollbackOk) wait() bool {
+ return true
+}
+
+func (msg *txRollbackOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *txRollbackOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+type confirmSelect struct {
+ Nowait bool
+}
+
+func (msg *confirmSelect) id() (uint16, uint16) {
+ return 85, 10
+}
+
+func (msg *confirmSelect) wait() bool {
+ return true
+}
+
+func (msg *confirmSelect) write(w io.Writer) (err error) {
+ var bits byte
+
+ if msg.Nowait {
+ bits |= 1 << 0
+ }
+
+ if err = binary.Write(w, binary.BigEndian, bits); err != nil {
+ return
+ }
+
+ return
+}
+
+func (msg *confirmSelect) read(r io.Reader) (err error) {
+ var bits byte
+
+ if err = binary.Read(r, binary.BigEndian, &bits); err != nil {
+ return
+ }
+ msg.Nowait = (bits&(1<<0) > 0)
+
+ return
+}
+
+type confirmSelectOk struct {
+}
+
+func (msg *confirmSelectOk) id() (uint16, uint16) {
+ return 85, 11
+}
+
+func (msg *confirmSelectOk) wait() bool {
+ return true
+}
+
+func (msg *confirmSelectOk) write(w io.Writer) (err error) {
+
+ return
+}
+
+func (msg *confirmSelectOk) read(r io.Reader) (err error) {
+
+ return
+}
+
+func (r *reader) parseMethodFrame(channel uint16, size uint32) (f frame, err error) {
+ mf := &methodFrame{
+ ChannelId: channel,
+ }
+
+ if err = binary.Read(r.r, binary.BigEndian, &mf.ClassId); err != nil {
+ return
+ }
+
+ if err = binary.Read(r.r, binary.BigEndian, &mf.MethodId); err != nil {
+ return
+ }
+
+ switch mf.ClassId {
+
+ case 10: // connection
+ switch mf.MethodId {
+
+ case 10: // connection start
+ //fmt.Println("NextMethod: class:10 method:10")
+ method := &connectionStart{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // connection start-ok
+ //fmt.Println("NextMethod: class:10 method:11")
+ method := &connectionStartOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // connection secure
+ //fmt.Println("NextMethod: class:10 method:20")
+ method := &connectionSecure{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // connection secure-ok
+ //fmt.Println("NextMethod: class:10 method:21")
+ method := &connectionSecureOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 30: // connection tune
+ //fmt.Println("NextMethod: class:10 method:30")
+ method := &connectionTune{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 31: // connection tune-ok
+ //fmt.Println("NextMethod: class:10 method:31")
+ method := &connectionTuneOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 40: // connection open
+ //fmt.Println("NextMethod: class:10 method:40")
+ method := &connectionOpen{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 41: // connection open-ok
+ //fmt.Println("NextMethod: class:10 method:41")
+ method := &connectionOpenOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 50: // connection close
+ //fmt.Println("NextMethod: class:10 method:50")
+ method := &connectionClose{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 51: // connection close-ok
+ //fmt.Println("NextMethod: class:10 method:51")
+ method := &connectionCloseOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 60: // connection blocked
+ //fmt.Println("NextMethod: class:10 method:60")
+ method := &connectionBlocked{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 61: // connection unblocked
+ //fmt.Println("NextMethod: class:10 method:61")
+ method := &connectionUnblocked{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 20: // channel
+ switch mf.MethodId {
+
+ case 10: // channel open
+ //fmt.Println("NextMethod: class:20 method:10")
+ method := &channelOpen{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // channel open-ok
+ //fmt.Println("NextMethod: class:20 method:11")
+ method := &channelOpenOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // channel flow
+ //fmt.Println("NextMethod: class:20 method:20")
+ method := &channelFlow{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // channel flow-ok
+ //fmt.Println("NextMethod: class:20 method:21")
+ method := &channelFlowOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 40: // channel close
+ //fmt.Println("NextMethod: class:20 method:40")
+ method := &channelClose{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 41: // channel close-ok
+ //fmt.Println("NextMethod: class:20 method:41")
+ method := &channelCloseOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 40: // exchange
+ switch mf.MethodId {
+
+ case 10: // exchange declare
+ //fmt.Println("NextMethod: class:40 method:10")
+ method := &exchangeDeclare{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // exchange declare-ok
+ //fmt.Println("NextMethod: class:40 method:11")
+ method := &exchangeDeclareOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // exchange delete
+ //fmt.Println("NextMethod: class:40 method:20")
+ method := &exchangeDelete{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // exchange delete-ok
+ //fmt.Println("NextMethod: class:40 method:21")
+ method := &exchangeDeleteOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 30: // exchange bind
+ //fmt.Println("NextMethod: class:40 method:30")
+ method := &exchangeBind{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 31: // exchange bind-ok
+ //fmt.Println("NextMethod: class:40 method:31")
+ method := &exchangeBindOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 40: // exchange unbind
+ //fmt.Println("NextMethod: class:40 method:40")
+ method := &exchangeUnbind{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 51: // exchange unbind-ok
+ //fmt.Println("NextMethod: class:40 method:51")
+ method := &exchangeUnbindOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 50: // queue
+ switch mf.MethodId {
+
+ case 10: // queue declare
+ //fmt.Println("NextMethod: class:50 method:10")
+ method := &queueDeclare{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // queue declare-ok
+ //fmt.Println("NextMethod: class:50 method:11")
+ method := &queueDeclareOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // queue bind
+ //fmt.Println("NextMethod: class:50 method:20")
+ method := &queueBind{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // queue bind-ok
+ //fmt.Println("NextMethod: class:50 method:21")
+ method := &queueBindOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 50: // queue unbind
+ //fmt.Println("NextMethod: class:50 method:50")
+ method := &queueUnbind{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 51: // queue unbind-ok
+ //fmt.Println("NextMethod: class:50 method:51")
+ method := &queueUnbindOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 30: // queue purge
+ //fmt.Println("NextMethod: class:50 method:30")
+ method := &queuePurge{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 31: // queue purge-ok
+ //fmt.Println("NextMethod: class:50 method:31")
+ method := &queuePurgeOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 40: // queue delete
+ //fmt.Println("NextMethod: class:50 method:40")
+ method := &queueDelete{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 41: // queue delete-ok
+ //fmt.Println("NextMethod: class:50 method:41")
+ method := &queueDeleteOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 60: // basic
+ switch mf.MethodId {
+
+ case 10: // basic qos
+ //fmt.Println("NextMethod: class:60 method:10")
+ method := &basicQos{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // basic qos-ok
+ //fmt.Println("NextMethod: class:60 method:11")
+ method := &basicQosOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // basic consume
+ //fmt.Println("NextMethod: class:60 method:20")
+ method := &basicConsume{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // basic consume-ok
+ //fmt.Println("NextMethod: class:60 method:21")
+ method := &basicConsumeOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 30: // basic cancel
+ //fmt.Println("NextMethod: class:60 method:30")
+ method := &basicCancel{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 31: // basic cancel-ok
+ //fmt.Println("NextMethod: class:60 method:31")
+ method := &basicCancelOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 40: // basic publish
+ //fmt.Println("NextMethod: class:60 method:40")
+ method := &basicPublish{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 50: // basic return
+ //fmt.Println("NextMethod: class:60 method:50")
+ method := &basicReturn{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 60: // basic deliver
+ //fmt.Println("NextMethod: class:60 method:60")
+ method := &basicDeliver{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 70: // basic get
+ //fmt.Println("NextMethod: class:60 method:70")
+ method := &basicGet{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 71: // basic get-ok
+ //fmt.Println("NextMethod: class:60 method:71")
+ method := &basicGetOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 72: // basic get-empty
+ //fmt.Println("NextMethod: class:60 method:72")
+ method := &basicGetEmpty{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 80: // basic ack
+ //fmt.Println("NextMethod: class:60 method:80")
+ method := &basicAck{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 90: // basic reject
+ //fmt.Println("NextMethod: class:60 method:90")
+ method := &basicReject{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 100: // basic recover-async
+ //fmt.Println("NextMethod: class:60 method:100")
+ method := &basicRecoverAsync{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 110: // basic recover
+ //fmt.Println("NextMethod: class:60 method:110")
+ method := &basicRecover{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 111: // basic recover-ok
+ //fmt.Println("NextMethod: class:60 method:111")
+ method := &basicRecoverOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 120: // basic nack
+ //fmt.Println("NextMethod: class:60 method:120")
+ method := &basicNack{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 90: // tx
+ switch mf.MethodId {
+
+ case 10: // tx select
+ //fmt.Println("NextMethod: class:90 method:10")
+ method := &txSelect{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // tx select-ok
+ //fmt.Println("NextMethod: class:90 method:11")
+ method := &txSelectOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 20: // tx commit
+ //fmt.Println("NextMethod: class:90 method:20")
+ method := &txCommit{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 21: // tx commit-ok
+ //fmt.Println("NextMethod: class:90 method:21")
+ method := &txCommitOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 30: // tx rollback
+ //fmt.Println("NextMethod: class:90 method:30")
+ method := &txRollback{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 31: // tx rollback-ok
+ //fmt.Println("NextMethod: class:90 method:31")
+ method := &txRollbackOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ case 85: // confirm
+ switch mf.MethodId {
+
+ case 10: // confirm select
+ //fmt.Println("NextMethod: class:85 method:10")
+ method := &confirmSelect{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ case 11: // confirm select-ok
+ //fmt.Println("NextMethod: class:85 method:11")
+ method := &confirmSelectOk{}
+ if err = method.read(r.r); err != nil {
+ return
+ }
+ mf.Method = method
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown method %d for class %d", mf.MethodId, mf.ClassId)
+ }
+
+ default:
+ return nil, fmt.Errorf("Bad method frame, unknown class %d", mf.ClassId)
+ }
+
+ return mf, nil
+}