amqp

package
v0.0.0-...-b242329 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 19, 2019 License: MIT Imports: 14 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

View Source 
var (
	ErrInvalidLengthAmqp = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAmqp   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthMessages = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowMessages   = fmt.Errorf("proto: integer overflow")
)
View Source 
var (
	ErrInvalidLengthProtocolGenerated = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowProtocolGenerated   = fmt.Errorf("proto: integer overflow")
)
View Source 
var AccessRefused = 403

The client attempted to work with a server entity to which it has no access due to security settings.

View Source 
var ChannelError = 504

The client attempted to work with a channel that had not been correctly opened. This most likely indicates a fault in the client layer.

View Source 
var ClassIdBasic uint16 = 60
View Source 
var ClassIdChannel uint16 = 20
View Source 
var ClassIdConfirm uint16 = 85
View Source 
var ClassIdConnection uint16 = 10
View Source 
var ClassIdExchange uint16 = 40
View Source 
var ClassIdQueue uint16 = 50
View Source 
var ClassIdTx uint16 = 90
View Source 
var CommandInvalid = 503

The client sent an invalid sequence of frames, attempting to perform an operation that was considered invalid by the server. This usually implies a programming error in the client.

View Source 
var ConnectionForced = 320

An operator intervened to close the connection for some reason. The client may retry at some later date.

View Source 
var ContentTooLarge = 311

The client attempted to transfer content larger than the server could accept at the present time. The client may retry at a later time.

View Source 
var FrameBody = 3
View Source 
var FrameEnd = 206
View Source 
var FrameError = 501

The sender sent a malformed frame that the recipient could not decode. This strongly implies a programming error in the sending peer.

View Source 
var FrameHeader = 2
View Source 
var FrameHeartbeat = 8
View Source 
var FrameMethod = 1
View Source 
var FrameMinSize = 4096
View Source 
var InternalError = 541

The server could not complete the method because of an internal error. The server may require intervention by an operator in order to resume normal operations.

View Source 
var InvalidPath = 402

The client tried to work with an unknown virtual host.

View Source 
var MaskAppId uint16 = 0x0008
View Source 
var MaskContentEncoding uint16 = 0x4000
View Source 
var MaskContentType uint16 = 0x8000
View Source 
var MaskCorrelationId uint16 = 0x0400
View Source 
var MaskDeliveryMode uint16 = 0x1000
View Source 
var MaskExpiration uint16 = 0x0100
View Source 
var MaskHeaders uint16 = 0x2000
View Source 
var MaskMessageId uint16 = 0x0080
View Source 
var MaskPriority uint16 = 0x0800
View Source 
var MaskReplyTo uint16 = 0x0200
View Source 
var MaskReserved uint16 = 0x0004
View Source 
var MaskTimestamp uint16 = 0x0040
View Source 
var MaskType uint16 = 0x0020
View Source 
var MaskUserId uint16 = 0x0010
View Source 
var MaxShortStringLength uint8 = 255
View Source 
var MethodIdBasicAck uint16 = 80

************************ BasicAck ************************

View Source 
var MethodIdBasicCancel uint16 = 30

************************ BasicCancel ************************

View Source 
var MethodIdBasicCancelOk uint16 = 31

************************ BasicCancelOk ************************

View Source 
var MethodIdBasicConsume uint16 = 20

************************ BasicConsume ************************

View Source 
var MethodIdBasicConsumeOk uint16 = 21

************************ BasicConsumeOk ************************

View Source 
var MethodIdBasicDeliver uint16 = 60

************************ BasicDeliver ************************

View Source 
var MethodIdBasicGet uint16 = 70

************************ BasicGet ************************

View Source 
var MethodIdBasicGetEmpty uint16 = 72

************************ BasicGetEmpty ************************

View Source 
var MethodIdBasicGetOk uint16 = 71

************************ BasicGetOk ************************

View Source 
var MethodIdBasicNack uint16 = 120

************************ BasicNack ************************

View Source 
var MethodIdBasicPublish uint16 = 40

************************ BasicPublish ************************

View Source 
var MethodIdBasicQos uint16 = 10

************************ BasicQos ************************

View Source 
var MethodIdBasicQosOk uint16 = 11

************************ BasicQosOk ************************

View Source 
var MethodIdBasicRecover uint16 = 110

************************ BasicRecover ************************

View Source 
var MethodIdBasicRecoverAsync uint16 = 100

************************ BasicRecoverAsync ************************

View Source 
var MethodIdBasicRecoverOk uint16 = 111

************************ BasicRecoverOk ************************

View Source 
var MethodIdBasicReject uint16 = 90

************************ BasicReject ************************

View Source 
var MethodIdBasicReturn uint16 = 50

************************ BasicReturn ************************

View Source 
var MethodIdChannelClose uint16 = 40

************************ ChannelClose ************************

View Source 
var MethodIdChannelCloseOk uint16 = 41

************************ ChannelCloseOk ************************

View Source 
var MethodIdChannelFlow uint16 = 20

************************ ChannelFlow ************************

View Source 
var MethodIdChannelFlowOk uint16 = 21

************************ ChannelFlowOk ************************

View Source 
var MethodIdChannelOpen uint16 = 10

************************ ChannelOpen ************************

View Source 
var MethodIdChannelOpenOk uint16 = 11

************************ ChannelOpenOk ************************

View Source 
var MethodIdConfirmSelect uint16 = 10

************************ ConfirmSelect ************************

View Source 
var MethodIdConfirmSelectOk uint16 = 11

************************ ConfirmSelectOk ************************

View Source 
var MethodIdConnectionBlocked uint16 = 60

************************ ConnectionBlocked ************************

View Source 
var MethodIdConnectionClose uint16 = 50

************************ ConnectionClose ************************

View Source 
var MethodIdConnectionCloseOk uint16 = 51

************************ ConnectionCloseOk ************************

View Source 
var MethodIdConnectionOpen uint16 = 40

************************ ConnectionOpen ************************

View Source 
var MethodIdConnectionOpenOk uint16 = 41

************************ ConnectionOpenOk ************************

View Source 
var MethodIdConnectionSecure uint16 = 20

************************ ConnectionSecure ************************

View Source 
var MethodIdConnectionSecureOk uint16 = 21

************************ ConnectionSecureOk ************************

View Source 
var MethodIdConnectionStart uint16 = 10

************************ ConnectionStart ************************

View Source 
var MethodIdConnectionStartOk uint16 = 11

************************ ConnectionStartOk ************************

View Source 
var MethodIdConnectionTune uint16 = 30

************************ ConnectionTune ************************

View Source 
var MethodIdConnectionTuneOk uint16 = 31

************************ ConnectionTuneOk ************************

View Source 
var MethodIdConnectionUnblocked uint16 = 61

************************ ConnectionUnblocked ************************

View Source 
var MethodIdExchangeBind uint16 = 30

************************ ExchangeBind ************************

View Source 
var MethodIdExchangeBindOk uint16 = 31

************************ ExchangeBindOk ************************

View Source 
var MethodIdExchangeDeclare uint16 = 10

************************ ExchangeDeclare ************************

View Source 
var MethodIdExchangeDeclareOk uint16 = 11

************************ ExchangeDeclareOk ************************

View Source 
var MethodIdExchangeDelete uint16 = 20

************************ ExchangeDelete ************************

View Source 
var MethodIdExchangeDeleteOk uint16 = 21

************************ ExchangeDeleteOk ************************

View Source 
var MethodIdExchangeUnbind uint16 = 40

************************ ExchangeUnbind ************************

View Source 
var MethodIdExchangeUnbindOk uint16 = 51

************************ ExchangeUnbindOk ************************

View Source 
var MethodIdQueueBind uint16 = 20

************************ QueueBind ************************

View Source 
var MethodIdQueueBindOk uint16 = 21

************************ QueueBindOk ************************

View Source 
var MethodIdQueueDeclare uint16 = 10

************************ QueueDeclare ************************

View Source 
var MethodIdQueueDeclareOk uint16 = 11

************************ QueueDeclareOk ************************

View Source 
var MethodIdQueueDelete uint16 = 40

************************ QueueDelete ************************

View Source 
var MethodIdQueueDeleteOk uint16 = 41

************************ QueueDeleteOk ************************

View Source 
var MethodIdQueuePurge uint16 = 30

************************ QueuePurge ************************

View Source 
var MethodIdQueuePurgeOk uint16 = 31

************************ QueuePurgeOk ************************

View Source 
var MethodIdQueueUnbind uint16 = 50

************************ QueueUnbind ************************

View Source 
var MethodIdQueueUnbindOk uint16 = 51

************************ QueueUnbindOk ************************

View Source 
var MethodIdTxCommit uint16 = 20

************************ TxCommit ************************

View Source 
var MethodIdTxCommitOk uint16 = 21

************************ TxCommitOk ************************

View Source 
var MethodIdTxRollback uint16 = 30

************************ TxRollback ************************

View Source 
var MethodIdTxRollbackOk uint16 = 31

************************ TxRollbackOk ************************

View Source 
var MethodIdTxSelect uint16 = 10

************************ TxSelect ************************

View Source 
var MethodIdTxSelectOk uint16 = 11

************************ TxSelectOk ************************

View Source 
var NoConsumers = 313

When the exchange cannot deliver to a consumer when the immediate flag is set. As a result of pending data on the queue or the absence of any consumers of the queue.

View Source 
var NotAllowed = 530

The client tried to work with some entity in a manner that is prohibited by the server, due to security settings or by some other criteria.

View Source 
var NotFound = 404

The client attempted to work with a server entity that does not exist.

View Source 
var NotImplemented = 540

The client tried to use functionality that is not implemented in the server.

View Source 
var PreconditionFailed = 406

The client requested a method that was not allowed because some precondition failed.

View Source 
var ReadClassId = ReadShort
View Source 
var ReadConsumerTag = ReadShortstr
View Source 
var ReadDeliveryTag = ReadLonglong
View Source 
var ReadExchangeName = ReadShortstr
View Source 
var ReadMessageCount = ReadLong
View Source 
var ReadMethodId = ReadShort
View Source 
var ReadPath = ReadShortstr
View Source 
var ReadPeerProperties = ReadTable
View Source 
var ReadQueueName = ReadShortstr
View Source 
var ReadReplyCode = ReadShort
View Source 
var ReadReplyText = ReadShortstr
View Source 
var ReplySuccess = 200

Indicates that the method completed successfully. This reply code is reserved for future use - the current protocol design does not use positive confirmation and reply codes are sent only in case of an error.

View Source 
var ResourceError = 506

The server could not complete the method because it lacked sufficient resources. This may be due to the client creating too many of some type of entity.

View Source 
var ResourceLocked = 405

The client attempted to work with a server entity to which it has no access because another client is working with it.

View Source 
var SyntaxError = 502

The sender sent a frame that contained illegal values for one or more fields. This strongly implies a programming error in the sending peer.

View Source 
var UnexpectedFrame = 505

The peer sent a frame that was not expected, usually in the context of a content header and body. This strongly indicates a fault in the peer's content processing.

View Source 
var WriteClassId = WriteShort
View Source 
var WriteConsumerTag = WriteShortstr
View Source 
var WriteDeliveryTag = WriteLonglong
View Source 
var WriteExchangeName = WriteShortstr
View Source 
var WriteMessageCount = WriteLong
View Source 
var WriteMethodId = WriteShort
View Source 
var WritePath = WriteShortstr
View Source 
var WritePeerProperties = WriteTable
View Source 
var WriteQueueName = WriteShortstr
View Source 
var WriteReplyCode = WriteShort
View Source 
var WriteReplyText = WriteShortstr

Functions

func CheckExchangeOrQueueName 

func CheckExchangeOrQueueName(s string) error

func EquivalentTables 

func EquivalentTables(t1 *Table, t2 *Table) bool

func ReadLong 

func ReadLong(buf io.Reader) (data uint32, err error)

func ReadLonglong 

func ReadLonglong(buf io.Reader) (data uint64, err error)

func ReadLongstr 

func ReadLongstr(buf io.Reader) ([]byte, error)

func ReadOctet 

func ReadOctet(buf io.Reader) (data byte, err error)

func ReadShort 

func ReadShort(buf io.Reader) (data uint16, err error)

func ReadShortstr 

func ReadShortstr(buf io.Reader) (string, error)

func ReadTimestamp 

func ReadTimestamp(buf io.Reader) (uint64, error)

Can't get coverage on this easily since I can't currently generate timestamp values in Tables because protobuf doesn't give me a type that is different from uint64

func WriteFrame 

func WriteFrame(buf io.Writer, frame *WireFrame)

func WriteFrameEnd 

func WriteFrameEnd(buf io.Writer) error

func WriteLong 

func WriteLong(buf io.Writer, i uint32) error

func WriteLonglong 

func WriteLonglong(buf io.Writer, i uint64) error

func WriteLongstr 

func WriteLongstr(buf io.Writer, bytes []byte) (err error)

func WriteOctet 

func WriteOctet(buf io.Writer, b byte) error

func WriteProtocolHeader 

func WriteProtocolHeader(buf io.Writer) error

func WriteShort 

func WriteShort(buf io.Writer, i uint16) error

func WriteShortstr 

func WriteShortstr(buf io.Writer, s string) error

func WriteStringChar 

func WriteStringChar(buf io.Writer, b byte) error

func WriteTable 

func WriteTable(writer io.Writer, table *Table) error

func WriteTimestamp 

func WriteTimestamp(buf io.Writer, timestamp uint64) error

func WriteVersion 

func WriteVersion(buf io.Writer) error

Types

type AMQPError 

type AMQPError struct {
	Code   uint16
	Class  uint16
	Method uint16
	Msg    string
	Soft   bool
}

func NewHardError 

func NewHardError(code uint16, msg string, class uint16, method uint16) *AMQPError

func NewSoftError 

func NewSoftError(code uint16, msg string, class uint16, method uint16) *AMQPError

type BasicAck 

type BasicAck struct {
	DeliveryTag          uint64   `protobuf:"varint,1,opt,name=delivery_tag,json=deliveryTag" json:"delivery_tag"`
	Multiple             bool     `protobuf:"varint,2,opt,name=multiple" json:"multiple"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicAck) Descriptor 

func (*BasicAck) Descriptor() ([]byte, []int)

func (*BasicAck) FrameType 

func (f *BasicAck) FrameType() byte

func (*BasicAck) Marshal 

func (m *BasicAck) Marshal() (dAtA []byte, err error)

func (*BasicAck) MarshalTo 

func (m *BasicAck) MarshalTo(dAtA []byte) (int, error)

func (*BasicAck) MethodIdentifier 

func (f *BasicAck) MethodIdentifier() (uint16, uint16)

func (*BasicAck) MethodName 

func (f *BasicAck) MethodName() string

func (*BasicAck) ProtoMessage 

func (*BasicAck) ProtoMessage()

func (*BasicAck) Read 

func (f *BasicAck) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicAck) Reset 

func (m *BasicAck) Reset()

func (*BasicAck) Size 

func (m *BasicAck) Size() (n int)

func (*BasicAck) String 

func (m *BasicAck) String() string

func (*BasicAck) Unmarshal 

func (m *BasicAck) Unmarshal(dAtA []byte) error

func (*BasicAck) Write 

func (f *BasicAck) Write(writer io.Writer) (err error)

Writer

func (*BasicAck) XXX_DiscardUnknown 

func (m *BasicAck) XXX_DiscardUnknown()

func (*BasicAck) XXX_Marshal 

func (m *BasicAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicAck) XXX_Merge 

func (m *BasicAck) XXX_Merge(src proto.Message)

func (*BasicAck) XXX_Size 

func (m *BasicAck) XXX_Size() int

func (*BasicAck) XXX_Unmarshal 

func (m *BasicAck) XXX_Unmarshal(b []byte) error

type BasicCancel 

type BasicCancel struct {
	ConsumerTag          string   `protobuf:"bytes,1,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	NoWait               bool     `protobuf:"varint,2,opt,name=no_wait,json=noWait" json:"no_wait"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicCancel) Descriptor 

func (*BasicCancel) Descriptor() ([]byte, []int)

func (*BasicCancel) FrameType 

func (f *BasicCancel) FrameType() byte

func (*BasicCancel) Marshal 

func (m *BasicCancel) Marshal() (dAtA []byte, err error)

func (*BasicCancel) MarshalTo 

func (m *BasicCancel) MarshalTo(dAtA []byte) (int, error)

func (*BasicCancel) MethodIdentifier 

func (f *BasicCancel) MethodIdentifier() (uint16, uint16)

func (*BasicCancel) MethodName 

func (f *BasicCancel) MethodName() string

func (*BasicCancel) ProtoMessage 

func (*BasicCancel) ProtoMessage()

func (*BasicCancel) Read 

func (f *BasicCancel) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicCancel) Reset 

func (m *BasicCancel) Reset()

func (*BasicCancel) Size 

func (m *BasicCancel) Size() (n int)

func (*BasicCancel) String 

func (m *BasicCancel) String() string

func (*BasicCancel) Unmarshal 

func (m *BasicCancel) Unmarshal(dAtA []byte) error

func (*BasicCancel) Write 

func (f *BasicCancel) Write(writer io.Writer) (err error)

Writer

func (*BasicCancel) XXX_DiscardUnknown 

func (m *BasicCancel) XXX_DiscardUnknown()

func (*BasicCancel) XXX_Marshal 

func (m *BasicCancel) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicCancel) XXX_Merge 

func (m *BasicCancel) XXX_Merge(src proto.Message)

func (*BasicCancel) XXX_Size 

func (m *BasicCancel) XXX_Size() int

func (*BasicCancel) XXX_Unmarshal 

func (m *BasicCancel) XXX_Unmarshal(b []byte) error

type BasicCancelOk 

type BasicCancelOk struct {
	ConsumerTag          string   `protobuf:"bytes,1,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicCancelOk) Descriptor 

func (*BasicCancelOk) Descriptor() ([]byte, []int)

func (*BasicCancelOk) FrameType 

func (f *BasicCancelOk) FrameType() byte

func (*BasicCancelOk) Marshal 

func (m *BasicCancelOk) Marshal() (dAtA []byte, err error)

func (*BasicCancelOk) MarshalTo 

func (m *BasicCancelOk) MarshalTo(dAtA []byte) (int, error)

func (*BasicCancelOk) MethodIdentifier 

func (f *BasicCancelOk) MethodIdentifier() (uint16, uint16)

func (*BasicCancelOk) MethodName 

func (f *BasicCancelOk) MethodName() string

func (*BasicCancelOk) ProtoMessage 

func (*BasicCancelOk) ProtoMessage()

func (*BasicCancelOk) Read 

func (f *BasicCancelOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicCancelOk) Reset 

func (m *BasicCancelOk) Reset()

func (*BasicCancelOk) Size 

func (m *BasicCancelOk) Size() (n int)

func (*BasicCancelOk) String 

func (m *BasicCancelOk) String() string

func (*BasicCancelOk) Unmarshal 

func (m *BasicCancelOk) Unmarshal(dAtA []byte) error

func (*BasicCancelOk) Write 

func (f *BasicCancelOk) Write(writer io.Writer) (err error)

Writer

func (*BasicCancelOk) XXX_DiscardUnknown 

func (m *BasicCancelOk) XXX_DiscardUnknown()

func (*BasicCancelOk) XXX_Marshal 

func (m *BasicCancelOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicCancelOk) XXX_Merge 

func (m *BasicCancelOk) XXX_Merge(src proto.Message)

func (*BasicCancelOk) XXX_Size 

func (m *BasicCancelOk) XXX_Size() int

func (*BasicCancelOk) XXX_Unmarshal 

func (m *BasicCancelOk) XXX_Unmarshal(b []byte) error

type BasicConsume 

type BasicConsume struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	ConsumerTag          string   `protobuf:"bytes,3,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	NoLocal              bool     `protobuf:"varint,4,opt,name=no_local,json=noLocal" json:"no_local"`
	NoAck                bool     `protobuf:"varint,5,opt,name=no_ack,json=noAck" json:"no_ack"`
	Exclusive            bool     `protobuf:"varint,6,opt,name=exclusive" json:"exclusive"`
	NoWait               bool     `protobuf:"varint,7,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,8,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicConsume) Descriptor 

func (*BasicConsume) Descriptor() ([]byte, []int)

func (*BasicConsume) FrameType 

func (f *BasicConsume) FrameType() byte

func (*BasicConsume) Marshal 

func (m *BasicConsume) Marshal() (dAtA []byte, err error)

func (*BasicConsume) MarshalTo 

func (m *BasicConsume) MarshalTo(dAtA []byte) (int, error)

func (*BasicConsume) MethodIdentifier 

func (f *BasicConsume) MethodIdentifier() (uint16, uint16)

func (*BasicConsume) MethodName 

func (f *BasicConsume) MethodName() string

func (*BasicConsume) ProtoMessage 

func (*BasicConsume) ProtoMessage()

func (*BasicConsume) Read 

func (f *BasicConsume) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicConsume) Reset 

func (m *BasicConsume) Reset()

func (*BasicConsume) Size 

func (m *BasicConsume) Size() (n int)

func (*BasicConsume) String 

func (m *BasicConsume) String() string

func (*BasicConsume) Unmarshal 

func (m *BasicConsume) Unmarshal(dAtA []byte) error

func (*BasicConsume) Write 

func (f *BasicConsume) Write(writer io.Writer) (err error)

Writer

func (*BasicConsume) XXX_DiscardUnknown 

func (m *BasicConsume) XXX_DiscardUnknown()

func (*BasicConsume) XXX_Marshal 

func (m *BasicConsume) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicConsume) XXX_Merge 

func (m *BasicConsume) XXX_Merge(src proto.Message)

func (*BasicConsume) XXX_Size 

func (m *BasicConsume) XXX_Size() int

func (*BasicConsume) XXX_Unmarshal 

func (m *BasicConsume) XXX_Unmarshal(b []byte) error

type BasicConsumeOk 

type BasicConsumeOk struct {
	ConsumerTag          string   `protobuf:"bytes,1,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicConsumeOk) Descriptor 

func (*BasicConsumeOk) Descriptor() ([]byte, []int)

func (*BasicConsumeOk) FrameType 

func (f *BasicConsumeOk) FrameType() byte

func (*BasicConsumeOk) Marshal 

func (m *BasicConsumeOk) Marshal() (dAtA []byte, err error)

func (*BasicConsumeOk) MarshalTo 

func (m *BasicConsumeOk) MarshalTo(dAtA []byte) (int, error)

func (*BasicConsumeOk) MethodIdentifier 

func (f *BasicConsumeOk) MethodIdentifier() (uint16, uint16)

func (*BasicConsumeOk) MethodName 

func (f *BasicConsumeOk) MethodName() string

func (*BasicConsumeOk) ProtoMessage 

func (*BasicConsumeOk) ProtoMessage()

func (*BasicConsumeOk) Read 

func (f *BasicConsumeOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicConsumeOk) Reset 

func (m *BasicConsumeOk) Reset()

func (*BasicConsumeOk) Size 

func (m *BasicConsumeOk) Size() (n int)

func (*BasicConsumeOk) String 

func (m *BasicConsumeOk) String() string

func (*BasicConsumeOk) Unmarshal 

func (m *BasicConsumeOk) Unmarshal(dAtA []byte) error

func (*BasicConsumeOk) Write 

func (f *BasicConsumeOk) Write(writer io.Writer) (err error)

Writer

func (*BasicConsumeOk) XXX_DiscardUnknown 

func (m *BasicConsumeOk) XXX_DiscardUnknown()

func (*BasicConsumeOk) XXX_Marshal 

func (m *BasicConsumeOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicConsumeOk) XXX_Merge 

func (m *BasicConsumeOk) XXX_Merge(src proto.Message)

func (*BasicConsumeOk) XXX_Size 

func (m *BasicConsumeOk) XXX_Size() int

func (*BasicConsumeOk) XXX_Unmarshal 

func (m *BasicConsumeOk) XXX_Unmarshal(b []byte) error

type BasicContentHeaderProperties 

type BasicContentHeaderProperties struct {
	ContentType          *string  `protobuf:"bytes,1,opt,name=content_type,json=contentType" json:"content_type,omitempty"`
	ContentEncoding      *string  `protobuf:"bytes,2,opt,name=content_encoding,json=contentEncoding" json:"content_encoding,omitempty"`
	Headers              *Table   `protobuf:"bytes,3,opt,name=headers" json:"headers,omitempty"`
	DeliveryMode         *byte    `protobuf:"varint,4,opt,name=delivery_mode,json=deliveryMode,casttype=byte" json:"delivery_mode,omitempty"`
	Priority             *byte    `protobuf:"varint,5,opt,name=priority,casttype=byte" json:"priority,omitempty"`
	CorrelationId        *string  `protobuf:"bytes,6,opt,name=correlation_id,json=correlationId" json:"correlation_id,omitempty"`
	ReplyTo              *string  `protobuf:"bytes,7,opt,name=reply_to,json=replyTo" json:"reply_to,omitempty"`
	Expiration           *string  `protobuf:"bytes,8,opt,name=expiration" json:"expiration,omitempty"`
	MessageId            *string  `protobuf:"bytes,9,opt,name=message_id,json=messageId" json:"message_id,omitempty"`
	Timestamp            *uint64  `protobuf:"varint,10,opt,name=timestamp" json:"timestamp,omitempty"`
	Type                 *string  `protobuf:"bytes,11,opt,name=type" json:"type,omitempty"`
	UserId               *string  `protobuf:"bytes,12,opt,name=user_id,json=userId" json:"user_id,omitempty"`
	AppId                *string  `protobuf:"bytes,13,opt,name=app_id,json=appId" json:"app_id,omitempty"`
	Reserved             *string  `protobuf:"bytes,14,opt,name=reserved" json:"reserved,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicContentHeaderProperties) Descriptor 

func (*BasicContentHeaderProperties) Descriptor() ([]byte, []int)

func (*BasicContentHeaderProperties) GetAppId 

func (m *BasicContentHeaderProperties) GetAppId() string

func (*BasicContentHeaderProperties) GetContentEncoding 

func (m *BasicContentHeaderProperties) GetContentEncoding() string

func (*BasicContentHeaderProperties) GetContentType 

func (m *BasicContentHeaderProperties) GetContentType() string

func (*BasicContentHeaderProperties) GetCorrelationId 

func (m *BasicContentHeaderProperties) GetCorrelationId() string

func (*BasicContentHeaderProperties) GetDeliveryMode 

func (m *BasicContentHeaderProperties) GetDeliveryMode() byte

func (*BasicContentHeaderProperties) GetExpiration 

func (m *BasicContentHeaderProperties) GetExpiration() string

func (*BasicContentHeaderProperties) GetHeaders 

func (m *BasicContentHeaderProperties) GetHeaders() *Table

func (*BasicContentHeaderProperties) GetMessageId 

func (m *BasicContentHeaderProperties) GetMessageId() string

func (*BasicContentHeaderProperties) GetPriority 

func (m *BasicContentHeaderProperties) GetPriority() byte

func (*BasicContentHeaderProperties) GetReplyTo 

func (m *BasicContentHeaderProperties) GetReplyTo() string

func (*BasicContentHeaderProperties) GetReserved 

func (m *BasicContentHeaderProperties) GetReserved() string

func (*BasicContentHeaderProperties) GetTimestamp 

func (m *BasicContentHeaderProperties) GetTimestamp() uint64

func (*BasicContentHeaderProperties) GetType 

func (m *BasicContentHeaderProperties) GetType() string

func (*BasicContentHeaderProperties) GetUserId 

func (m *BasicContentHeaderProperties) GetUserId() string

func (*BasicContentHeaderProperties) Marshal 

func (m *BasicContentHeaderProperties) Marshal() (dAtA []byte, err error)

func (*BasicContentHeaderProperties) MarshalTo 

func (m *BasicContentHeaderProperties) MarshalTo(dAtA []byte) (int, error)

func (*BasicContentHeaderProperties) ProtoMessage 

func (*BasicContentHeaderProperties) ProtoMessage()

func (*BasicContentHeaderProperties) ReadProps 

func (props *BasicContentHeaderProperties) ReadProps(flags uint16, reader io.Reader, strictMode bool) (err error)

func (*BasicContentHeaderProperties) Reset 

func (m *BasicContentHeaderProperties) Reset()

func (*BasicContentHeaderProperties) Size 

func (m *BasicContentHeaderProperties) Size() (n int)

func (*BasicContentHeaderProperties) String 

func (m *BasicContentHeaderProperties) String() string

func (*BasicContentHeaderProperties) Unmarshal 

func (m *BasicContentHeaderProperties) Unmarshal(dAtA []byte) error

func (*BasicContentHeaderProperties) WriteProps 

func (props *BasicContentHeaderProperties) WriteProps(writer io.Writer) (flags uint16, err error)

func (*BasicContentHeaderProperties) XXX_DiscardUnknown 

func (m *BasicContentHeaderProperties) XXX_DiscardUnknown()

func (*BasicContentHeaderProperties) XXX_Marshal 

func (m *BasicContentHeaderProperties) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicContentHeaderProperties) XXX_Merge 

func (m *BasicContentHeaderProperties) XXX_Merge(src proto.Message)

func (*BasicContentHeaderProperties) XXX_Size 

func (m *BasicContentHeaderProperties) XXX_Size() int

func (*BasicContentHeaderProperties) XXX_Unmarshal 

func (m *BasicContentHeaderProperties) XXX_Unmarshal(b []byte) error

type BasicDeliver 

type BasicDeliver struct {
	ConsumerTag          string   `protobuf:"bytes,1,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	DeliveryTag          uint64   `protobuf:"varint,2,opt,name=delivery_tag,json=deliveryTag" json:"delivery_tag"`
	Redelivered          bool     `protobuf:"varint,3,opt,name=redelivered" json:"redelivered"`
	Exchange             string   `protobuf:"bytes,4,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,5,opt,name=routing_key,json=routingKey" json:"routing_key"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicDeliver) Descriptor 

func (*BasicDeliver) Descriptor() ([]byte, []int)

func (*BasicDeliver) FrameType 

func (f *BasicDeliver) FrameType() byte

func (*BasicDeliver) Marshal 

func (m *BasicDeliver) Marshal() (dAtA []byte, err error)

func (*BasicDeliver) MarshalTo 

func (m *BasicDeliver) MarshalTo(dAtA []byte) (int, error)

func (*BasicDeliver) MethodIdentifier 

func (f *BasicDeliver) MethodIdentifier() (uint16, uint16)

func (*BasicDeliver) MethodName 

func (f *BasicDeliver) MethodName() string

func (*BasicDeliver) ProtoMessage 

func (*BasicDeliver) ProtoMessage()

func (*BasicDeliver) Read 

func (f *BasicDeliver) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicDeliver) Reset 

func (m *BasicDeliver) Reset()

func (*BasicDeliver) Size 

func (m *BasicDeliver) Size() (n int)

func (*BasicDeliver) String 

func (m *BasicDeliver) String() string

func (*BasicDeliver) Unmarshal 

func (m *BasicDeliver) Unmarshal(dAtA []byte) error

func (*BasicDeliver) Write 

func (f *BasicDeliver) Write(writer io.Writer) (err error)

Writer

func (*BasicDeliver) XXX_DiscardUnknown 

func (m *BasicDeliver) XXX_DiscardUnknown()

func (*BasicDeliver) XXX_Marshal 

func (m *BasicDeliver) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicDeliver) XXX_Merge 

func (m *BasicDeliver) XXX_Merge(src proto.Message)

func (*BasicDeliver) XXX_Size 

func (m *BasicDeliver) XXX_Size() int

func (*BasicDeliver) XXX_Unmarshal 

func (m *BasicDeliver) XXX_Unmarshal(b []byte) error

type BasicGet 

type BasicGet struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	NoAck                bool     `protobuf:"varint,3,opt,name=no_ack,json=noAck" json:"no_ack"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicGet) Descriptor 

func (*BasicGet) Descriptor() ([]byte, []int)

func (*BasicGet) FrameType 

func (f *BasicGet) FrameType() byte

func (*BasicGet) Marshal 

func (m *BasicGet) Marshal() (dAtA []byte, err error)

func (*BasicGet) MarshalTo 

func (m *BasicGet) MarshalTo(dAtA []byte) (int, error)

func (*BasicGet) MethodIdentifier 

func (f *BasicGet) MethodIdentifier() (uint16, uint16)

func (*BasicGet) MethodName 

func (f *BasicGet) MethodName() string

func (*BasicGet) ProtoMessage 

func (*BasicGet) ProtoMessage()

func (*BasicGet) Read 

func (f *BasicGet) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicGet) Reset 

func (m *BasicGet) Reset()

func (*BasicGet) Size 

func (m *BasicGet) Size() (n int)

func (*BasicGet) String 

func (m *BasicGet) String() string

func (*BasicGet) Unmarshal 

func (m *BasicGet) Unmarshal(dAtA []byte) error

func (*BasicGet) Write 

func (f *BasicGet) Write(writer io.Writer) (err error)

Writer

func (*BasicGet) XXX_DiscardUnknown 

func (m *BasicGet) XXX_DiscardUnknown()

func (*BasicGet) XXX_Marshal 

func (m *BasicGet) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicGet) XXX_Merge 

func (m *BasicGet) XXX_Merge(src proto.Message)

func (*BasicGet) XXX_Size 

func (m *BasicGet) XXX_Size() int

func (*BasicGet) XXX_Unmarshal 

func (m *BasicGet) XXX_Unmarshal(b []byte) error

type BasicGetEmpty 

type BasicGetEmpty struct {
	Reserved1            string   `protobuf:"bytes,1,opt,name=reserved1" json:"reserved1"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicGetEmpty) Descriptor 

func (*BasicGetEmpty) Descriptor() ([]byte, []int)

func (*BasicGetEmpty) FrameType 

func (f *BasicGetEmpty) FrameType() byte

func (*BasicGetEmpty) Marshal 

func (m *BasicGetEmpty) Marshal() (dAtA []byte, err error)

func (*BasicGetEmpty) MarshalTo 

func (m *BasicGetEmpty) MarshalTo(dAtA []byte) (int, error)

func (*BasicGetEmpty) MethodIdentifier 

func (f *BasicGetEmpty) MethodIdentifier() (uint16, uint16)

func (*BasicGetEmpty) MethodName 

func (f *BasicGetEmpty) MethodName() string

func (*BasicGetEmpty) ProtoMessage 

func (*BasicGetEmpty) ProtoMessage()

func (*BasicGetEmpty) Read 

func (f *BasicGetEmpty) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicGetEmpty) Reset 

func (m *BasicGetEmpty) Reset()

func (*BasicGetEmpty) Size 

func (m *BasicGetEmpty) Size() (n int)

func (*BasicGetEmpty) String 

func (m *BasicGetEmpty) String() string

func (*BasicGetEmpty) Unmarshal 

func (m *BasicGetEmpty) Unmarshal(dAtA []byte) error

func (*BasicGetEmpty) Write 

func (f *BasicGetEmpty) Write(writer io.Writer) (err error)

Writer

func (*BasicGetEmpty) XXX_DiscardUnknown 

func (m *BasicGetEmpty) XXX_DiscardUnknown()

func (*BasicGetEmpty) XXX_Marshal 

func (m *BasicGetEmpty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicGetEmpty) XXX_Merge 

func (m *BasicGetEmpty) XXX_Merge(src proto.Message)

func (*BasicGetEmpty) XXX_Size 

func (m *BasicGetEmpty) XXX_Size() int

func (*BasicGetEmpty) XXX_Unmarshal 

func (m *BasicGetEmpty) XXX_Unmarshal(b []byte) error

type BasicGetOk 

type BasicGetOk struct {
	DeliveryTag          uint64   `protobuf:"varint,1,opt,name=delivery_tag,json=deliveryTag" json:"delivery_tag"`
	Redelivered          bool     `protobuf:"varint,2,opt,name=redelivered" json:"redelivered"`
	Exchange             string   `protobuf:"bytes,3,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	MessageCount         uint32   `protobuf:"varint,5,opt,name=message_count,json=messageCount" json:"message_count"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicGetOk) Descriptor 

func (*BasicGetOk) Descriptor() ([]byte, []int)

func (*BasicGetOk) FrameType 

func (f *BasicGetOk) FrameType() byte

func (*BasicGetOk) Marshal 

func (m *BasicGetOk) Marshal() (dAtA []byte, err error)

func (*BasicGetOk) MarshalTo 

func (m *BasicGetOk) MarshalTo(dAtA []byte) (int, error)

func (*BasicGetOk) MethodIdentifier 

func (f *BasicGetOk) MethodIdentifier() (uint16, uint16)

func (*BasicGetOk) MethodName 

func (f *BasicGetOk) MethodName() string

func (*BasicGetOk) ProtoMessage 

func (*BasicGetOk) ProtoMessage()

func (*BasicGetOk) Read 

func (f *BasicGetOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicGetOk) Reset 

func (m *BasicGetOk) Reset()

func (*BasicGetOk) Size 

func (m *BasicGetOk) Size() (n int)

func (*BasicGetOk) String 

func (m *BasicGetOk) String() string

func (*BasicGetOk) Unmarshal 

func (m *BasicGetOk) Unmarshal(dAtA []byte) error

func (*BasicGetOk) Write 

func (f *BasicGetOk) Write(writer io.Writer) (err error)

Writer

func (*BasicGetOk) XXX_DiscardUnknown 

func (m *BasicGetOk) XXX_DiscardUnknown()

func (*BasicGetOk) XXX_Marshal 

func (m *BasicGetOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicGetOk) XXX_Merge 

func (m *BasicGetOk) XXX_Merge(src proto.Message)

func (*BasicGetOk) XXX_Size 

func (m *BasicGetOk) XXX_Size() int

func (*BasicGetOk) XXX_Unmarshal 

func (m *BasicGetOk) XXX_Unmarshal(b []byte) error

type BasicNack 

type BasicNack struct {
	DeliveryTag          uint64   `protobuf:"varint,1,opt,name=delivery_tag,json=deliveryTag" json:"delivery_tag"`
	Multiple             bool     `protobuf:"varint,2,opt,name=multiple" json:"multiple"`
	Requeue              bool     `protobuf:"varint,3,opt,name=requeue" json:"requeue"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicNack) Descriptor 

func (*BasicNack) Descriptor() ([]byte, []int)

func (*BasicNack) FrameType 

func (f *BasicNack) FrameType() byte

func (*BasicNack) Marshal 

func (m *BasicNack) Marshal() (dAtA []byte, err error)

func (*BasicNack) MarshalTo 

func (m *BasicNack) MarshalTo(dAtA []byte) (int, error)

func (*BasicNack) MethodIdentifier 

func (f *BasicNack) MethodIdentifier() (uint16, uint16)

func (*BasicNack) MethodName 

func (f *BasicNack) MethodName() string

func (*BasicNack) ProtoMessage 

func (*BasicNack) ProtoMessage()

func (*BasicNack) Read 

func (f *BasicNack) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicNack) Reset 

func (m *BasicNack) Reset()

func (*BasicNack) Size 

func (m *BasicNack) Size() (n int)

func (*BasicNack) String 

func (m *BasicNack) String() string

func (*BasicNack) Unmarshal 

func (m *BasicNack) Unmarshal(dAtA []byte) error

func (*BasicNack) Write 

func (f *BasicNack) Write(writer io.Writer) (err error)

Writer

func (*BasicNack) XXX_DiscardUnknown 

func (m *BasicNack) XXX_DiscardUnknown()

func (*BasicNack) XXX_Marshal 

func (m *BasicNack) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicNack) XXX_Merge 

func (m *BasicNack) XXX_Merge(src proto.Message)

func (*BasicNack) XXX_Size 

func (m *BasicNack) XXX_Size() int

func (*BasicNack) XXX_Unmarshal 

func (m *BasicNack) XXX_Unmarshal(b []byte) error

type BasicPublish 

type BasicPublish struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Exchange             string   `protobuf:"bytes,2,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,3,opt,name=routing_key,json=routingKey" json:"routing_key"`
	Mandatory            bool     `protobuf:"varint,4,opt,name=mandatory" json:"mandatory"`
	Immediate            bool     `protobuf:"varint,5,opt,name=immediate" json:"immediate"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicPublish) Descriptor 

func (*BasicPublish) Descriptor() ([]byte, []int)

func (*BasicPublish) FrameType 

func (f *BasicPublish) FrameType() byte

func (*BasicPublish) Marshal 

func (m *BasicPublish) Marshal() (dAtA []byte, err error)

func (*BasicPublish) MarshalTo 

func (m *BasicPublish) MarshalTo(dAtA []byte) (int, error)

func (*BasicPublish) MethodIdentifier 

func (f *BasicPublish) MethodIdentifier() (uint16, uint16)

func (*BasicPublish) MethodName 

func (f *BasicPublish) MethodName() string

func (*BasicPublish) ProtoMessage 

func (*BasicPublish) ProtoMessage()

func (*BasicPublish) Read 

func (f *BasicPublish) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicPublish) Reset 

func (m *BasicPublish) Reset()

func (*BasicPublish) Size 

func (m *BasicPublish) Size() (n int)

func (*BasicPublish) String 

func (m *BasicPublish) String() string

func (*BasicPublish) Unmarshal 

func (m *BasicPublish) Unmarshal(dAtA []byte) error

func (*BasicPublish) Write 

func (f *BasicPublish) Write(writer io.Writer) (err error)

Writer

func (*BasicPublish) XXX_DiscardUnknown 

func (m *BasicPublish) XXX_DiscardUnknown()

func (*BasicPublish) XXX_Marshal 

func (m *BasicPublish) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicPublish) XXX_Merge 

func (m *BasicPublish) XXX_Merge(src proto.Message)

func (*BasicPublish) XXX_Size 

func (m *BasicPublish) XXX_Size() int

func (*BasicPublish) XXX_Unmarshal 

func (m *BasicPublish) XXX_Unmarshal(b []byte) error

type BasicQos 

type BasicQos struct {
	PrefetchSize         uint32   `protobuf:"varint,1,opt,name=prefetch_size,json=prefetchSize" json:"prefetch_size"`
	PrefetchCount        uint16   `protobuf:"varint,2,opt,name=prefetch_count,json=prefetchCount,casttype=uint16" json:"prefetch_count"`
	Global               bool     `protobuf:"varint,3,opt,name=global" json:"global"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicQos) Descriptor 

func (*BasicQos) Descriptor() ([]byte, []int)

func (*BasicQos) FrameType 

func (f *BasicQos) FrameType() byte

func (*BasicQos) Marshal 

func (m *BasicQos) Marshal() (dAtA []byte, err error)

func (*BasicQos) MarshalTo 

func (m *BasicQos) MarshalTo(dAtA []byte) (int, error)

func (*BasicQos) MethodIdentifier 

func (f *BasicQos) MethodIdentifier() (uint16, uint16)

func (*BasicQos) MethodName 

func (f *BasicQos) MethodName() string

func (*BasicQos) ProtoMessage 

func (*BasicQos) ProtoMessage()

func (*BasicQos) Read 

func (f *BasicQos) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicQos) Reset 

func (m *BasicQos) Reset()

func (*BasicQos) Size 

func (m *BasicQos) Size() (n int)

func (*BasicQos) String 

func (m *BasicQos) String() string

func (*BasicQos) Unmarshal 

func (m *BasicQos) Unmarshal(dAtA []byte) error

func (*BasicQos) Write 

func (f *BasicQos) Write(writer io.Writer) (err error)

Writer

func (*BasicQos) XXX_DiscardUnknown 

func (m *BasicQos) XXX_DiscardUnknown()

func (*BasicQos) XXX_Marshal 

func (m *BasicQos) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicQos) XXX_Merge 

func (m *BasicQos) XXX_Merge(src proto.Message)

func (*BasicQos) XXX_Size 

func (m *BasicQos) XXX_Size() int

func (*BasicQos) XXX_Unmarshal 

func (m *BasicQos) XXX_Unmarshal(b []byte) error

type BasicQosOk 

type BasicQosOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicQosOk) Descriptor 

func (*BasicQosOk) Descriptor() ([]byte, []int)

func (*BasicQosOk) FrameType 

func (f *BasicQosOk) FrameType() byte

func (*BasicQosOk) Marshal 

func (m *BasicQosOk) Marshal() (dAtA []byte, err error)

func (*BasicQosOk) MarshalTo 

func (m *BasicQosOk) MarshalTo(dAtA []byte) (int, error)

func (*BasicQosOk) MethodIdentifier 

func (f *BasicQosOk) MethodIdentifier() (uint16, uint16)

func (*BasicQosOk) MethodName 

func (f *BasicQosOk) MethodName() string

func (*BasicQosOk) ProtoMessage 

func (*BasicQosOk) ProtoMessage()

func (*BasicQosOk) Read 

func (f *BasicQosOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicQosOk) Reset 

func (m *BasicQosOk) Reset()

func (*BasicQosOk) Size 

func (m *BasicQosOk) Size() (n int)

func (*BasicQosOk) String 

func (m *BasicQosOk) String() string

func (*BasicQosOk) Unmarshal 

func (m *BasicQosOk) Unmarshal(dAtA []byte) error

func (*BasicQosOk) Write 

func (f *BasicQosOk) Write(writer io.Writer) (err error)

Writer

func (*BasicQosOk) XXX_DiscardUnknown 

func (m *BasicQosOk) XXX_DiscardUnknown()

func (*BasicQosOk) XXX_Marshal 

func (m *BasicQosOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicQosOk) XXX_Merge 

func (m *BasicQosOk) XXX_Merge(src proto.Message)

func (*BasicQosOk) XXX_Size 

func (m *BasicQosOk) XXX_Size() int

func (*BasicQosOk) XXX_Unmarshal 

func (m *BasicQosOk) XXX_Unmarshal(b []byte) error

type BasicRecover 

type BasicRecover struct {
	Requeue              bool     `protobuf:"varint,1,opt,name=requeue" json:"requeue"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicRecover) Descriptor 

func (*BasicRecover) Descriptor() ([]byte, []int)

func (*BasicRecover) FrameType 

func (f *BasicRecover) FrameType() byte

func (*BasicRecover) Marshal 

func (m *BasicRecover) Marshal() (dAtA []byte, err error)

func (*BasicRecover) MarshalTo 

func (m *BasicRecover) MarshalTo(dAtA []byte) (int, error)

func (*BasicRecover) MethodIdentifier 

func (f *BasicRecover) MethodIdentifier() (uint16, uint16)

func (*BasicRecover) MethodName 

func (f *BasicRecover) MethodName() string

func (*BasicRecover) ProtoMessage 

func (*BasicRecover) ProtoMessage()

func (*BasicRecover) Read 

func (f *BasicRecover) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicRecover) Reset 

func (m *BasicRecover) Reset()

func (*BasicRecover) Size 

func (m *BasicRecover) Size() (n int)

func (*BasicRecover) String 

func (m *BasicRecover) String() string

func (*BasicRecover) Unmarshal 

func (m *BasicRecover) Unmarshal(dAtA []byte) error

func (*BasicRecover) Write 

func (f *BasicRecover) Write(writer io.Writer) (err error)

Writer

func (*BasicRecover) XXX_DiscardUnknown 

func (m *BasicRecover) XXX_DiscardUnknown()

func (*BasicRecover) XXX_Marshal 

func (m *BasicRecover) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicRecover) XXX_Merge 

func (m *BasicRecover) XXX_Merge(src proto.Message)

func (*BasicRecover) XXX_Size 

func (m *BasicRecover) XXX_Size() int

func (*BasicRecover) XXX_Unmarshal 

func (m *BasicRecover) XXX_Unmarshal(b []byte) error

type BasicRecoverAsync 

type BasicRecoverAsync struct {
	Requeue              bool     `protobuf:"varint,1,opt,name=requeue" json:"requeue"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicRecoverAsync) Descriptor 

func (*BasicRecoverAsync) Descriptor() ([]byte, []int)

func (*BasicRecoverAsync) FrameType 

func (f *BasicRecoverAsync) FrameType() byte

func (*BasicRecoverAsync) Marshal 

func (m *BasicRecoverAsync) Marshal() (dAtA []byte, err error)

func (*BasicRecoverAsync) MarshalTo 

func (m *BasicRecoverAsync) MarshalTo(dAtA []byte) (int, error)

func (*BasicRecoverAsync) MethodIdentifier 

func (f *BasicRecoverAsync) MethodIdentifier() (uint16, uint16)

func (*BasicRecoverAsync) MethodName 

func (f *BasicRecoverAsync) MethodName() string

func (*BasicRecoverAsync) ProtoMessage 

func (*BasicRecoverAsync) ProtoMessage()

func (*BasicRecoverAsync) Read 

func (f *BasicRecoverAsync) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicRecoverAsync) Reset 

func (m *BasicRecoverAsync) Reset()

func (*BasicRecoverAsync) Size 

func (m *BasicRecoverAsync) Size() (n int)

func (*BasicRecoverAsync) String 

func (m *BasicRecoverAsync) String() string

func (*BasicRecoverAsync) Unmarshal 

func (m *BasicRecoverAsync) Unmarshal(dAtA []byte) error

func (*BasicRecoverAsync) Write 

func (f *BasicRecoverAsync) Write(writer io.Writer) (err error)

Writer

func (*BasicRecoverAsync) XXX_DiscardUnknown 

func (m *BasicRecoverAsync) XXX_DiscardUnknown()

func (*BasicRecoverAsync) XXX_Marshal 

func (m *BasicRecoverAsync) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicRecoverAsync) XXX_Merge 

func (m *BasicRecoverAsync) XXX_Merge(src proto.Message)

func (*BasicRecoverAsync) XXX_Size 

func (m *BasicRecoverAsync) XXX_Size() int

func (*BasicRecoverAsync) XXX_Unmarshal 

func (m *BasicRecoverAsync) XXX_Unmarshal(b []byte) error

type BasicRecoverOk 

type BasicRecoverOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicRecoverOk) Descriptor 

func (*BasicRecoverOk) Descriptor() ([]byte, []int)

func (*BasicRecoverOk) FrameType 

func (f *BasicRecoverOk) FrameType() byte

func (*BasicRecoverOk) Marshal 

func (m *BasicRecoverOk) Marshal() (dAtA []byte, err error)

func (*BasicRecoverOk) MarshalTo 

func (m *BasicRecoverOk) MarshalTo(dAtA []byte) (int, error)

func (*BasicRecoverOk) MethodIdentifier 

func (f *BasicRecoverOk) MethodIdentifier() (uint16, uint16)

func (*BasicRecoverOk) MethodName 

func (f *BasicRecoverOk) MethodName() string

func (*BasicRecoverOk) ProtoMessage 

func (*BasicRecoverOk) ProtoMessage()

func (*BasicRecoverOk) Read 

func (f *BasicRecoverOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicRecoverOk) Reset 

func (m *BasicRecoverOk) Reset()

func (*BasicRecoverOk) Size 

func (m *BasicRecoverOk) Size() (n int)

func (*BasicRecoverOk) String 

func (m *BasicRecoverOk) String() string

func (*BasicRecoverOk) Unmarshal 

func (m *BasicRecoverOk) Unmarshal(dAtA []byte) error

func (*BasicRecoverOk) Write 

func (f *BasicRecoverOk) Write(writer io.Writer) (err error)

Writer

func (*BasicRecoverOk) XXX_DiscardUnknown 

func (m *BasicRecoverOk) XXX_DiscardUnknown()

func (*BasicRecoverOk) XXX_Marshal 

func (m *BasicRecoverOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicRecoverOk) XXX_Merge 

func (m *BasicRecoverOk) XXX_Merge(src proto.Message)

func (*BasicRecoverOk) XXX_Size 

func (m *BasicRecoverOk) XXX_Size() int

func (*BasicRecoverOk) XXX_Unmarshal 

func (m *BasicRecoverOk) XXX_Unmarshal(b []byte) error

type BasicReject 

type BasicReject struct {
	DeliveryTag          uint64   `protobuf:"varint,1,opt,name=delivery_tag,json=deliveryTag" json:"delivery_tag"`
	Requeue              bool     `protobuf:"varint,2,opt,name=requeue" json:"requeue"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicReject) Descriptor 

func (*BasicReject) Descriptor() ([]byte, []int)

func (*BasicReject) FrameType 

func (f *BasicReject) FrameType() byte

func (*BasicReject) Marshal 

func (m *BasicReject) Marshal() (dAtA []byte, err error)

func (*BasicReject) MarshalTo 

func (m *BasicReject) MarshalTo(dAtA []byte) (int, error)

func (*BasicReject) MethodIdentifier 

func (f *BasicReject) MethodIdentifier() (uint16, uint16)

func (*BasicReject) MethodName 

func (f *BasicReject) MethodName() string

func (*BasicReject) ProtoMessage 

func (*BasicReject) ProtoMessage()

func (*BasicReject) Read 

func (f *BasicReject) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicReject) Reset 

func (m *BasicReject) Reset()

func (*BasicReject) Size 

func (m *BasicReject) Size() (n int)

func (*BasicReject) String 

func (m *BasicReject) String() string

func (*BasicReject) Unmarshal 

func (m *BasicReject) Unmarshal(dAtA []byte) error

func (*BasicReject) Write 

func (f *BasicReject) Write(writer io.Writer) (err error)

Writer

func (*BasicReject) XXX_DiscardUnknown 

func (m *BasicReject) XXX_DiscardUnknown()

func (*BasicReject) XXX_Marshal 

func (m *BasicReject) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicReject) XXX_Merge 

func (m *BasicReject) XXX_Merge(src proto.Message)

func (*BasicReject) XXX_Size 

func (m *BasicReject) XXX_Size() int

func (*BasicReject) XXX_Unmarshal 

func (m *BasicReject) XXX_Unmarshal(b []byte) error

type BasicReturn 

type BasicReturn struct {
	ReplyCode            uint16   `protobuf:"varint,1,opt,name=reply_code,json=replyCode,casttype=uint16" json:"reply_code"`
	ReplyText            string   `protobuf:"bytes,2,opt,name=reply_text,json=replyText" json:"reply_text"`
	Exchange             string   `protobuf:"bytes,3,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*BasicReturn) Descriptor 

func (*BasicReturn) Descriptor() ([]byte, []int)

func (*BasicReturn) FrameType 

func (f *BasicReturn) FrameType() byte

func (*BasicReturn) Marshal 

func (m *BasicReturn) Marshal() (dAtA []byte, err error)

func (*BasicReturn) MarshalTo 

func (m *BasicReturn) MarshalTo(dAtA []byte) (int, error)

func (*BasicReturn) MethodIdentifier 

func (f *BasicReturn) MethodIdentifier() (uint16, uint16)

func (*BasicReturn) MethodName 

func (f *BasicReturn) MethodName() string

func (*BasicReturn) ProtoMessage 

func (*BasicReturn) ProtoMessage()

func (*BasicReturn) Read 

func (f *BasicReturn) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*BasicReturn) Reset 

func (m *BasicReturn) Reset()

func (*BasicReturn) Size 

func (m *BasicReturn) Size() (n int)

func (*BasicReturn) String 

func (m *BasicReturn) String() string

func (*BasicReturn) Unmarshal 

func (m *BasicReturn) Unmarshal(dAtA []byte) error

func (*BasicReturn) Write 

func (f *BasicReturn) Write(writer io.Writer) (err error)

Writer

func (*BasicReturn) XXX_DiscardUnknown 

func (m *BasicReturn) XXX_DiscardUnknown()

func (*BasicReturn) XXX_Marshal 

func (m *BasicReturn) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*BasicReturn) XXX_Merge 

func (m *BasicReturn) XXX_Merge(src proto.Message)

func (*BasicReturn) XXX_Size 

func (m *BasicReturn) XXX_Size() int

func (*BasicReturn) XXX_Unmarshal 

func (m *BasicReturn) XXX_Unmarshal(b []byte) error

type ChannelClose 

type ChannelClose struct {
	ReplyCode            uint16   `protobuf:"varint,1,opt,name=reply_code,json=replyCode,casttype=uint16" json:"reply_code"`
	ReplyText            string   `protobuf:"bytes,2,opt,name=reply_text,json=replyText" json:"reply_text"`
	ClassId              uint16   `protobuf:"varint,3,opt,name=class_id,json=classId,casttype=uint16" json:"class_id"`
	MethodId             uint16   `protobuf:"varint,4,opt,name=method_id,json=methodId,casttype=uint16" json:"method_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelClose) Descriptor 

func (*ChannelClose) Descriptor() ([]byte, []int)

func (*ChannelClose) FrameType 

func (f *ChannelClose) FrameType() byte

func (*ChannelClose) Marshal 

func (m *ChannelClose) Marshal() (dAtA []byte, err error)

func (*ChannelClose) MarshalTo 

func (m *ChannelClose) MarshalTo(dAtA []byte) (int, error)

func (*ChannelClose) MethodIdentifier 

func (f *ChannelClose) MethodIdentifier() (uint16, uint16)

func (*ChannelClose) MethodName 

func (f *ChannelClose) MethodName() string

func (*ChannelClose) ProtoMessage 

func (*ChannelClose) ProtoMessage()

func (*ChannelClose) Read 

func (f *ChannelClose) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelClose) Reset 

func (m *ChannelClose) Reset()

func (*ChannelClose) Size 

func (m *ChannelClose) Size() (n int)

func (*ChannelClose) String 

func (m *ChannelClose) String() string

func (*ChannelClose) Unmarshal 

func (m *ChannelClose) Unmarshal(dAtA []byte) error

func (*ChannelClose) Write 

func (f *ChannelClose) Write(writer io.Writer) (err error)

Writer

func (*ChannelClose) XXX_DiscardUnknown 

func (m *ChannelClose) XXX_DiscardUnknown()

func (*ChannelClose) XXX_Marshal 

func (m *ChannelClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelClose) XXX_Merge 

func (m *ChannelClose) XXX_Merge(src proto.Message)

func (*ChannelClose) XXX_Size 

func (m *ChannelClose) XXX_Size() int

func (*ChannelClose) XXX_Unmarshal 

func (m *ChannelClose) XXX_Unmarshal(b []byte) error

type ChannelCloseOk 

type ChannelCloseOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelCloseOk) Descriptor 

func (*ChannelCloseOk) Descriptor() ([]byte, []int)

func (*ChannelCloseOk) FrameType 

func (f *ChannelCloseOk) FrameType() byte

func (*ChannelCloseOk) Marshal 

func (m *ChannelCloseOk) Marshal() (dAtA []byte, err error)

func (*ChannelCloseOk) MarshalTo 

func (m *ChannelCloseOk) MarshalTo(dAtA []byte) (int, error)

func (*ChannelCloseOk) MethodIdentifier 

func (f *ChannelCloseOk) MethodIdentifier() (uint16, uint16)

func (*ChannelCloseOk) MethodName 

func (f *ChannelCloseOk) MethodName() string

func (*ChannelCloseOk) ProtoMessage 

func (*ChannelCloseOk) ProtoMessage()

func (*ChannelCloseOk) Read 

func (f *ChannelCloseOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelCloseOk) Reset 

func (m *ChannelCloseOk) Reset()

func (*ChannelCloseOk) Size 

func (m *ChannelCloseOk) Size() (n int)

func (*ChannelCloseOk) String 

func (m *ChannelCloseOk) String() string

func (*ChannelCloseOk) Unmarshal 

func (m *ChannelCloseOk) Unmarshal(dAtA []byte) error

func (*ChannelCloseOk) Write 

func (f *ChannelCloseOk) Write(writer io.Writer) (err error)

Writer

func (*ChannelCloseOk) XXX_DiscardUnknown 

func (m *ChannelCloseOk) XXX_DiscardUnknown()

func (*ChannelCloseOk) XXX_Marshal 

func (m *ChannelCloseOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelCloseOk) XXX_Merge 

func (m *ChannelCloseOk) XXX_Merge(src proto.Message)

func (*ChannelCloseOk) XXX_Size 

func (m *ChannelCloseOk) XXX_Size() int

func (*ChannelCloseOk) XXX_Unmarshal 

func (m *ChannelCloseOk) XXX_Unmarshal(b []byte) error

type ChannelFlow 

type ChannelFlow struct {
	Active               bool     `protobuf:"varint,1,opt,name=active" json:"active"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelFlow) Descriptor 

func (*ChannelFlow) Descriptor() ([]byte, []int)

func (*ChannelFlow) FrameType 

func (f *ChannelFlow) FrameType() byte

func (*ChannelFlow) Marshal 

func (m *ChannelFlow) Marshal() (dAtA []byte, err error)

func (*ChannelFlow) MarshalTo 

func (m *ChannelFlow) MarshalTo(dAtA []byte) (int, error)

func (*ChannelFlow) MethodIdentifier 

func (f *ChannelFlow) MethodIdentifier() (uint16, uint16)

func (*ChannelFlow) MethodName 

func (f *ChannelFlow) MethodName() string

func (*ChannelFlow) ProtoMessage 

func (*ChannelFlow) ProtoMessage()

func (*ChannelFlow) Read 

func (f *ChannelFlow) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelFlow) Reset 

func (m *ChannelFlow) Reset()

func (*ChannelFlow) Size 

func (m *ChannelFlow) Size() (n int)

func (*ChannelFlow) String 

func (m *ChannelFlow) String() string

func (*ChannelFlow) Unmarshal 

func (m *ChannelFlow) Unmarshal(dAtA []byte) error

func (*ChannelFlow) Write 

func (f *ChannelFlow) Write(writer io.Writer) (err error)

Writer

func (*ChannelFlow) XXX_DiscardUnknown 

func (m *ChannelFlow) XXX_DiscardUnknown()

func (*ChannelFlow) XXX_Marshal 

func (m *ChannelFlow) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelFlow) XXX_Merge 

func (m *ChannelFlow) XXX_Merge(src proto.Message)

func (*ChannelFlow) XXX_Size 

func (m *ChannelFlow) XXX_Size() int

func (*ChannelFlow) XXX_Unmarshal 

func (m *ChannelFlow) XXX_Unmarshal(b []byte) error

type ChannelFlowOk 

type ChannelFlowOk struct {
	Active               bool     `protobuf:"varint,1,opt,name=active" json:"active"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelFlowOk) Descriptor 

func (*ChannelFlowOk) Descriptor() ([]byte, []int)

func (*ChannelFlowOk) FrameType 

func (f *ChannelFlowOk) FrameType() byte

func (*ChannelFlowOk) Marshal 

func (m *ChannelFlowOk) Marshal() (dAtA []byte, err error)

func (*ChannelFlowOk) MarshalTo 

func (m *ChannelFlowOk) MarshalTo(dAtA []byte) (int, error)

func (*ChannelFlowOk) MethodIdentifier 

func (f *ChannelFlowOk) MethodIdentifier() (uint16, uint16)

func (*ChannelFlowOk) MethodName 

func (f *ChannelFlowOk) MethodName() string

func (*ChannelFlowOk) ProtoMessage 

func (*ChannelFlowOk) ProtoMessage()

func (*ChannelFlowOk) Read 

func (f *ChannelFlowOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelFlowOk) Reset 

func (m *ChannelFlowOk) Reset()

func (*ChannelFlowOk) Size 

func (m *ChannelFlowOk) Size() (n int)

func (*ChannelFlowOk) String 

func (m *ChannelFlowOk) String() string

func (*ChannelFlowOk) Unmarshal 

func (m *ChannelFlowOk) Unmarshal(dAtA []byte) error

func (*ChannelFlowOk) Write 

func (f *ChannelFlowOk) Write(writer io.Writer) (err error)

Writer

func (*ChannelFlowOk) XXX_DiscardUnknown 

func (m *ChannelFlowOk) XXX_DiscardUnknown()

func (*ChannelFlowOk) XXX_Marshal 

func (m *ChannelFlowOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelFlowOk) XXX_Merge 

func (m *ChannelFlowOk) XXX_Merge(src proto.Message)

func (*ChannelFlowOk) XXX_Size 

func (m *ChannelFlowOk) XXX_Size() int

func (*ChannelFlowOk) XXX_Unmarshal 

func (m *ChannelFlowOk) XXX_Unmarshal(b []byte) error

type ChannelOpen 

type ChannelOpen struct {
	Reserved1            string   `protobuf:"bytes,1,opt,name=reserved1" json:"reserved1"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelOpen) Descriptor 

func (*ChannelOpen) Descriptor() ([]byte, []int)

func (*ChannelOpen) FrameType 

func (f *ChannelOpen) FrameType() byte

func (*ChannelOpen) Marshal 

func (m *ChannelOpen) Marshal() (dAtA []byte, err error)

func (*ChannelOpen) MarshalTo 

func (m *ChannelOpen) MarshalTo(dAtA []byte) (int, error)

func (*ChannelOpen) MethodIdentifier 

func (f *ChannelOpen) MethodIdentifier() (uint16, uint16)

func (*ChannelOpen) MethodName 

func (f *ChannelOpen) MethodName() string

func (*ChannelOpen) ProtoMessage 

func (*ChannelOpen) ProtoMessage()

func (*ChannelOpen) Read 

func (f *ChannelOpen) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelOpen) Reset 

func (m *ChannelOpen) Reset()

func (*ChannelOpen) Size 

func (m *ChannelOpen) Size() (n int)

func (*ChannelOpen) String 

func (m *ChannelOpen) String() string

func (*ChannelOpen) Unmarshal 

func (m *ChannelOpen) Unmarshal(dAtA []byte) error

func (*ChannelOpen) Write 

func (f *ChannelOpen) Write(writer io.Writer) (err error)

Writer

func (*ChannelOpen) XXX_DiscardUnknown 

func (m *ChannelOpen) XXX_DiscardUnknown()

func (*ChannelOpen) XXX_Marshal 

func (m *ChannelOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelOpen) XXX_Merge 

func (m *ChannelOpen) XXX_Merge(src proto.Message)

func (*ChannelOpen) XXX_Size 

func (m *ChannelOpen) XXX_Size() int

func (*ChannelOpen) XXX_Unmarshal 

func (m *ChannelOpen) XXX_Unmarshal(b []byte) error

type ChannelOpenOk 

type ChannelOpenOk struct {
	Reserved1            []byte   `protobuf:"bytes,1,opt,name=reserved1" json:"reserved1,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ChannelOpenOk) Descriptor 

func (*ChannelOpenOk) Descriptor() ([]byte, []int)

func (*ChannelOpenOk) FrameType 

func (f *ChannelOpenOk) FrameType() byte

func (*ChannelOpenOk) Marshal 

func (m *ChannelOpenOk) Marshal() (dAtA []byte, err error)

func (*ChannelOpenOk) MarshalTo 

func (m *ChannelOpenOk) MarshalTo(dAtA []byte) (int, error)

func (*ChannelOpenOk) MethodIdentifier 

func (f *ChannelOpenOk) MethodIdentifier() (uint16, uint16)

func (*ChannelOpenOk) MethodName 

func (f *ChannelOpenOk) MethodName() string

func (*ChannelOpenOk) ProtoMessage 

func (*ChannelOpenOk) ProtoMessage()

func (*ChannelOpenOk) Read 

func (f *ChannelOpenOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ChannelOpenOk) Reset 

func (m *ChannelOpenOk) Reset()

func (*ChannelOpenOk) Size 

func (m *ChannelOpenOk) Size() (n int)

func (*ChannelOpenOk) String 

func (m *ChannelOpenOk) String() string

func (*ChannelOpenOk) Unmarshal 

func (m *ChannelOpenOk) Unmarshal(dAtA []byte) error

func (*ChannelOpenOk) Write 

func (f *ChannelOpenOk) Write(writer io.Writer) (err error)

Writer

func (*ChannelOpenOk) XXX_DiscardUnknown 

func (m *ChannelOpenOk) XXX_DiscardUnknown()

func (*ChannelOpenOk) XXX_Marshal 

func (m *ChannelOpenOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ChannelOpenOk) XXX_Merge 

func (m *ChannelOpenOk) XXX_Merge(src proto.Message)

func (*ChannelOpenOk) XXX_Size 

func (m *ChannelOpenOk) XXX_Size() int

func (*ChannelOpenOk) XXX_Unmarshal 

func (m *ChannelOpenOk) XXX_Unmarshal(b []byte) error

type ConfirmSelect 

type ConfirmSelect struct {
	Nowait               bool     `protobuf:"varint,1,opt,name=nowait" json:"nowait"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConfirmSelect) Descriptor 

func (*ConfirmSelect) Descriptor() ([]byte, []int)

func (*ConfirmSelect) FrameType 

func (f *ConfirmSelect) FrameType() byte

func (*ConfirmSelect) Marshal 

func (m *ConfirmSelect) Marshal() (dAtA []byte, err error)

func (*ConfirmSelect) MarshalTo 

func (m *ConfirmSelect) MarshalTo(dAtA []byte) (int, error)

func (*ConfirmSelect) MethodIdentifier 

func (f *ConfirmSelect) MethodIdentifier() (uint16, uint16)

func (*ConfirmSelect) MethodName 

func (f *ConfirmSelect) MethodName() string

func (*ConfirmSelect) ProtoMessage 

func (*ConfirmSelect) ProtoMessage()

func (*ConfirmSelect) Read 

func (f *ConfirmSelect) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConfirmSelect) Reset 

func (m *ConfirmSelect) Reset()

func (*ConfirmSelect) Size 

func (m *ConfirmSelect) Size() (n int)

func (*ConfirmSelect) String 

func (m *ConfirmSelect) String() string

func (*ConfirmSelect) Unmarshal 

func (m *ConfirmSelect) Unmarshal(dAtA []byte) error

func (*ConfirmSelect) Write 

func (f *ConfirmSelect) Write(writer io.Writer) (err error)

Writer

func (*ConfirmSelect) XXX_DiscardUnknown 

func (m *ConfirmSelect) XXX_DiscardUnknown()

func (*ConfirmSelect) XXX_Marshal 

func (m *ConfirmSelect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConfirmSelect) XXX_Merge 

func (m *ConfirmSelect) XXX_Merge(src proto.Message)

func (*ConfirmSelect) XXX_Size 

func (m *ConfirmSelect) XXX_Size() int

func (*ConfirmSelect) XXX_Unmarshal 

func (m *ConfirmSelect) XXX_Unmarshal(b []byte) error

type ConfirmSelectOk 

type ConfirmSelectOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConfirmSelectOk) Descriptor 

func (*ConfirmSelectOk) Descriptor() ([]byte, []int)

func (*ConfirmSelectOk) FrameType 

func (f *ConfirmSelectOk) FrameType() byte

func (*ConfirmSelectOk) Marshal 

func (m *ConfirmSelectOk) Marshal() (dAtA []byte, err error)

func (*ConfirmSelectOk) MarshalTo 

func (m *ConfirmSelectOk) MarshalTo(dAtA []byte) (int, error)

func (*ConfirmSelectOk) MethodIdentifier 

func (f *ConfirmSelectOk) MethodIdentifier() (uint16, uint16)

func (*ConfirmSelectOk) MethodName 

func (f *ConfirmSelectOk) MethodName() string

func (*ConfirmSelectOk) ProtoMessage 

func (*ConfirmSelectOk) ProtoMessage()

func (*ConfirmSelectOk) Read 

func (f *ConfirmSelectOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConfirmSelectOk) Reset 

func (m *ConfirmSelectOk) Reset()

func (*ConfirmSelectOk) Size 

func (m *ConfirmSelectOk) Size() (n int)

func (*ConfirmSelectOk) String 

func (m *ConfirmSelectOk) String() string

func (*ConfirmSelectOk) Unmarshal 

func (m *ConfirmSelectOk) Unmarshal(dAtA []byte) error

func (*ConfirmSelectOk) Write 

func (f *ConfirmSelectOk) Write(writer io.Writer) (err error)

Writer

func (*ConfirmSelectOk) XXX_DiscardUnknown 

func (m *ConfirmSelectOk) XXX_DiscardUnknown()

func (*ConfirmSelectOk) XXX_Marshal 

func (m *ConfirmSelectOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConfirmSelectOk) XXX_Merge 

func (m *ConfirmSelectOk) XXX_Merge(src proto.Message)

func (*ConfirmSelectOk) XXX_Size 

func (m *ConfirmSelectOk) XXX_Size() int

func (*ConfirmSelectOk) XXX_Unmarshal 

func (m *ConfirmSelectOk) XXX_Unmarshal(b []byte) error

type ConnectionBlocked 

type ConnectionBlocked struct {
	Reason               string   `protobuf:"bytes,1,opt,name=reason" json:"reason"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionBlocked) Descriptor 

func (*ConnectionBlocked) Descriptor() ([]byte, []int)

func (*ConnectionBlocked) FrameType 

func (f *ConnectionBlocked) FrameType() byte

func (*ConnectionBlocked) Marshal 

func (m *ConnectionBlocked) Marshal() (dAtA []byte, err error)

func (*ConnectionBlocked) MarshalTo 

func (m *ConnectionBlocked) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionBlocked) MethodIdentifier 

func (f *ConnectionBlocked) MethodIdentifier() (uint16, uint16)

func (*ConnectionBlocked) MethodName 

func (f *ConnectionBlocked) MethodName() string

func (*ConnectionBlocked) ProtoMessage 

func (*ConnectionBlocked) ProtoMessage()

func (*ConnectionBlocked) Read 

func (f *ConnectionBlocked) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionBlocked) Reset 

func (m *ConnectionBlocked) Reset()

func (*ConnectionBlocked) Size 

func (m *ConnectionBlocked) Size() (n int)

func (*ConnectionBlocked) String 

func (m *ConnectionBlocked) String() string

func (*ConnectionBlocked) Unmarshal 

func (m *ConnectionBlocked) Unmarshal(dAtA []byte) error

func (*ConnectionBlocked) Write 

func (f *ConnectionBlocked) Write(writer io.Writer) (err error)

Writer

func (*ConnectionBlocked) XXX_DiscardUnknown 

func (m *ConnectionBlocked) XXX_DiscardUnknown()

func (*ConnectionBlocked) XXX_Marshal 

func (m *ConnectionBlocked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionBlocked) XXX_Merge 

func (m *ConnectionBlocked) XXX_Merge(src proto.Message)

func (*ConnectionBlocked) XXX_Size 

func (m *ConnectionBlocked) XXX_Size() int

func (*ConnectionBlocked) XXX_Unmarshal 

func (m *ConnectionBlocked) XXX_Unmarshal(b []byte) error

type ConnectionClose 

type ConnectionClose struct {
	ReplyCode            uint16   `protobuf:"varint,1,opt,name=reply_code,json=replyCode,casttype=uint16" json:"reply_code"`
	ReplyText            string   `protobuf:"bytes,2,opt,name=reply_text,json=replyText" json:"reply_text"`
	ClassId              uint16   `protobuf:"varint,3,opt,name=class_id,json=classId,casttype=uint16" json:"class_id"`
	MethodId             uint16   `protobuf:"varint,4,opt,name=method_id,json=methodId,casttype=uint16" json:"method_id"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionClose) Descriptor 

func (*ConnectionClose) Descriptor() ([]byte, []int)

func (*ConnectionClose) FrameType 

func (f *ConnectionClose) FrameType() byte

func (*ConnectionClose) Marshal 

func (m *ConnectionClose) Marshal() (dAtA []byte, err error)

func (*ConnectionClose) MarshalTo 

func (m *ConnectionClose) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionClose) MethodIdentifier 

func (f *ConnectionClose) MethodIdentifier() (uint16, uint16)

func (*ConnectionClose) MethodName 

func (f *ConnectionClose) MethodName() string

func (*ConnectionClose) ProtoMessage 

func (*ConnectionClose) ProtoMessage()

func (*ConnectionClose) Read 

func (f *ConnectionClose) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionClose) Reset 

func (m *ConnectionClose) Reset()

func (*ConnectionClose) Size 

func (m *ConnectionClose) Size() (n int)

func (*ConnectionClose) String 

func (m *ConnectionClose) String() string

func (*ConnectionClose) Unmarshal 

func (m *ConnectionClose) Unmarshal(dAtA []byte) error

func (*ConnectionClose) Write 

func (f *ConnectionClose) Write(writer io.Writer) (err error)

Writer

func (*ConnectionClose) XXX_DiscardUnknown 

func (m *ConnectionClose) XXX_DiscardUnknown()

func (*ConnectionClose) XXX_Marshal 

func (m *ConnectionClose) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionClose) XXX_Merge 

func (m *ConnectionClose) XXX_Merge(src proto.Message)

func (*ConnectionClose) XXX_Size 

func (m *ConnectionClose) XXX_Size() int

func (*ConnectionClose) XXX_Unmarshal 

func (m *ConnectionClose) XXX_Unmarshal(b []byte) error

type ConnectionCloseOk 

type ConnectionCloseOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionCloseOk) Descriptor 

func (*ConnectionCloseOk) Descriptor() ([]byte, []int)

func (*ConnectionCloseOk) FrameType 

func (f *ConnectionCloseOk) FrameType() byte

func (*ConnectionCloseOk) Marshal 

func (m *ConnectionCloseOk) Marshal() (dAtA []byte, err error)

func (*ConnectionCloseOk) MarshalTo 

func (m *ConnectionCloseOk) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionCloseOk) MethodIdentifier 

func (f *ConnectionCloseOk) MethodIdentifier() (uint16, uint16)

func (*ConnectionCloseOk) MethodName 

func (f *ConnectionCloseOk) MethodName() string

func (*ConnectionCloseOk) ProtoMessage 

func (*ConnectionCloseOk) ProtoMessage()

func (*ConnectionCloseOk) Read 

func (f *ConnectionCloseOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionCloseOk) Reset 

func (m *ConnectionCloseOk) Reset()

func (*ConnectionCloseOk) Size 

func (m *ConnectionCloseOk) Size() (n int)

func (*ConnectionCloseOk) String 

func (m *ConnectionCloseOk) String() string

func (*ConnectionCloseOk) Unmarshal 

func (m *ConnectionCloseOk) Unmarshal(dAtA []byte) error

func (*ConnectionCloseOk) Write 

func (f *ConnectionCloseOk) Write(writer io.Writer) (err error)

Writer

func (*ConnectionCloseOk) XXX_DiscardUnknown 

func (m *ConnectionCloseOk) XXX_DiscardUnknown()

func (*ConnectionCloseOk) XXX_Marshal 

func (m *ConnectionCloseOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionCloseOk) XXX_Merge 

func (m *ConnectionCloseOk) XXX_Merge(src proto.Message)

func (*ConnectionCloseOk) XXX_Size 

func (m *ConnectionCloseOk) XXX_Size() int

func (*ConnectionCloseOk) XXX_Unmarshal 

func (m *ConnectionCloseOk) XXX_Unmarshal(b []byte) error

type ConnectionOpen 

type ConnectionOpen struct {
	VirtualHost          string   `protobuf:"bytes,1,opt,name=virtual_host,json=virtualHost" json:"virtual_host"`
	Reserved1            string   `protobuf:"bytes,2,opt,name=reserved1" json:"reserved1"`
	Reserved2            bool     `protobuf:"varint,3,opt,name=reserved2" json:"reserved2"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionOpen) Descriptor 

func (*ConnectionOpen) Descriptor() ([]byte, []int)

func (*ConnectionOpen) FrameType 

func (f *ConnectionOpen) FrameType() byte

func (*ConnectionOpen) Marshal 

func (m *ConnectionOpen) Marshal() (dAtA []byte, err error)

func (*ConnectionOpen) MarshalTo 

func (m *ConnectionOpen) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionOpen) MethodIdentifier 

func (f *ConnectionOpen) MethodIdentifier() (uint16, uint16)

func (*ConnectionOpen) MethodName 

func (f *ConnectionOpen) MethodName() string

func (*ConnectionOpen) ProtoMessage 

func (*ConnectionOpen) ProtoMessage()

func (*ConnectionOpen) Read 

func (f *ConnectionOpen) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionOpen) Reset 

func (m *ConnectionOpen) Reset()

func (*ConnectionOpen) Size 

func (m *ConnectionOpen) Size() (n int)

func (*ConnectionOpen) String 

func (m *ConnectionOpen) String() string

func (*ConnectionOpen) Unmarshal 

func (m *ConnectionOpen) Unmarshal(dAtA []byte) error

func (*ConnectionOpen) Write 

func (f *ConnectionOpen) Write(writer io.Writer) (err error)

Writer

func (*ConnectionOpen) XXX_DiscardUnknown 

func (m *ConnectionOpen) XXX_DiscardUnknown()

func (*ConnectionOpen) XXX_Marshal 

func (m *ConnectionOpen) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionOpen) XXX_Merge 

func (m *ConnectionOpen) XXX_Merge(src proto.Message)

func (*ConnectionOpen) XXX_Size 

func (m *ConnectionOpen) XXX_Size() int

func (*ConnectionOpen) XXX_Unmarshal 

func (m *ConnectionOpen) XXX_Unmarshal(b []byte) error

type ConnectionOpenOk 

type ConnectionOpenOk struct {
	Reserved1            string   `protobuf:"bytes,1,opt,name=reserved1" json:"reserved1"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionOpenOk) Descriptor 

func (*ConnectionOpenOk) Descriptor() ([]byte, []int)

func (*ConnectionOpenOk) FrameType 

func (f *ConnectionOpenOk) FrameType() byte

func (*ConnectionOpenOk) Marshal 

func (m *ConnectionOpenOk) Marshal() (dAtA []byte, err error)

func (*ConnectionOpenOk) MarshalTo 

func (m *ConnectionOpenOk) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionOpenOk) MethodIdentifier 

func (f *ConnectionOpenOk) MethodIdentifier() (uint16, uint16)

func (*ConnectionOpenOk) MethodName 

func (f *ConnectionOpenOk) MethodName() string

func (*ConnectionOpenOk) ProtoMessage 

func (*ConnectionOpenOk) ProtoMessage()

func (*ConnectionOpenOk) Read 

func (f *ConnectionOpenOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionOpenOk) Reset 

func (m *ConnectionOpenOk) Reset()

func (*ConnectionOpenOk) Size 

func (m *ConnectionOpenOk) Size() (n int)

func (*ConnectionOpenOk) String 

func (m *ConnectionOpenOk) String() string

func (*ConnectionOpenOk) Unmarshal 

func (m *ConnectionOpenOk) Unmarshal(dAtA []byte) error

func (*ConnectionOpenOk) Write 

func (f *ConnectionOpenOk) Write(writer io.Writer) (err error)

Writer

func (*ConnectionOpenOk) XXX_DiscardUnknown 

func (m *ConnectionOpenOk) XXX_DiscardUnknown()

func (*ConnectionOpenOk) XXX_Marshal 

func (m *ConnectionOpenOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionOpenOk) XXX_Merge 

func (m *ConnectionOpenOk) XXX_Merge(src proto.Message)

func (*ConnectionOpenOk) XXX_Size 

func (m *ConnectionOpenOk) XXX_Size() int

func (*ConnectionOpenOk) XXX_Unmarshal 

func (m *ConnectionOpenOk) XXX_Unmarshal(b []byte) error

type ConnectionSecure 

type ConnectionSecure struct {
	Challenge            []byte   `protobuf:"bytes,1,opt,name=challenge" json:"challenge,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionSecure) Descriptor 

func (*ConnectionSecure) Descriptor() ([]byte, []int)

func (*ConnectionSecure) FrameType 

func (f *ConnectionSecure) FrameType() byte

func (*ConnectionSecure) Marshal 

func (m *ConnectionSecure) Marshal() (dAtA []byte, err error)

func (*ConnectionSecure) MarshalTo 

func (m *ConnectionSecure) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionSecure) MethodIdentifier 

func (f *ConnectionSecure) MethodIdentifier() (uint16, uint16)

func (*ConnectionSecure) MethodName 

func (f *ConnectionSecure) MethodName() string

func (*ConnectionSecure) ProtoMessage 

func (*ConnectionSecure) ProtoMessage()

func (*ConnectionSecure) Read 

func (f *ConnectionSecure) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionSecure) Reset 

func (m *ConnectionSecure) Reset()

func (*ConnectionSecure) Size 

func (m *ConnectionSecure) Size() (n int)

func (*ConnectionSecure) String 

func (m *ConnectionSecure) String() string

func (*ConnectionSecure) Unmarshal 

func (m *ConnectionSecure) Unmarshal(dAtA []byte) error

func (*ConnectionSecure) Write 

func (f *ConnectionSecure) Write(writer io.Writer) (err error)

Writer

func (*ConnectionSecure) XXX_DiscardUnknown 

func (m *ConnectionSecure) XXX_DiscardUnknown()

func (*ConnectionSecure) XXX_Marshal 

func (m *ConnectionSecure) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionSecure) XXX_Merge 

func (m *ConnectionSecure) XXX_Merge(src proto.Message)

func (*ConnectionSecure) XXX_Size 

func (m *ConnectionSecure) XXX_Size() int

func (*ConnectionSecure) XXX_Unmarshal 

func (m *ConnectionSecure) XXX_Unmarshal(b []byte) error

type ConnectionSecureOk 

type ConnectionSecureOk struct {
	Response             []byte   `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionSecureOk) Descriptor 

func (*ConnectionSecureOk) Descriptor() ([]byte, []int)

func (*ConnectionSecureOk) FrameType 

func (f *ConnectionSecureOk) FrameType() byte

func (*ConnectionSecureOk) Marshal 

func (m *ConnectionSecureOk) Marshal() (dAtA []byte, err error)

func (*ConnectionSecureOk) MarshalTo 

func (m *ConnectionSecureOk) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionSecureOk) MethodIdentifier 

func (f *ConnectionSecureOk) MethodIdentifier() (uint16, uint16)

func (*ConnectionSecureOk) MethodName 

func (f *ConnectionSecureOk) MethodName() string

func (*ConnectionSecureOk) ProtoMessage 

func (*ConnectionSecureOk) ProtoMessage()

func (*ConnectionSecureOk) Read 

func (f *ConnectionSecureOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionSecureOk) Reset 

func (m *ConnectionSecureOk) Reset()

func (*ConnectionSecureOk) Size 

func (m *ConnectionSecureOk) Size() (n int)

func (*ConnectionSecureOk) String 

func (m *ConnectionSecureOk) String() string

func (*ConnectionSecureOk) Unmarshal 

func (m *ConnectionSecureOk) Unmarshal(dAtA []byte) error

func (*ConnectionSecureOk) Write 

func (f *ConnectionSecureOk) Write(writer io.Writer) (err error)

Writer

func (*ConnectionSecureOk) XXX_DiscardUnknown 

func (m *ConnectionSecureOk) XXX_DiscardUnknown()

func (*ConnectionSecureOk) XXX_Marshal 

func (m *ConnectionSecureOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionSecureOk) XXX_Merge 

func (m *ConnectionSecureOk) XXX_Merge(src proto.Message)

func (*ConnectionSecureOk) XXX_Size 

func (m *ConnectionSecureOk) XXX_Size() int

func (*ConnectionSecureOk) XXX_Unmarshal 

func (m *ConnectionSecureOk) XXX_Unmarshal(b []byte) error

type ConnectionStart 

type ConnectionStart struct {
	VersionMajor         byte     `protobuf:"varint,1,opt,name=version_major,json=versionMajor,casttype=byte" json:"version_major"`
	VersionMinor         byte     `protobuf:"varint,2,opt,name=version_minor,json=versionMinor,casttype=byte" json:"version_minor"`
	ServerProperties     *Table   `protobuf:"bytes,3,opt,name=server_properties,json=serverProperties" json:"server_properties,omitempty"`
	Mechanisms           []byte   `protobuf:"bytes,4,opt,name=mechanisms" json:"mechanisms,omitempty"`
	Locales              []byte   `protobuf:"bytes,5,opt,name=locales" json:"locales,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionStart) Descriptor 

func (*ConnectionStart) Descriptor() ([]byte, []int)

func (*ConnectionStart) FrameType 

func (f *ConnectionStart) FrameType() byte

func (*ConnectionStart) Marshal 

func (m *ConnectionStart) Marshal() (dAtA []byte, err error)

func (*ConnectionStart) MarshalTo 

func (m *ConnectionStart) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionStart) MethodIdentifier 

func (f *ConnectionStart) MethodIdentifier() (uint16, uint16)

func (*ConnectionStart) MethodName 

func (f *ConnectionStart) MethodName() string

func (*ConnectionStart) ProtoMessage 

func (*ConnectionStart) ProtoMessage()

func (*ConnectionStart) Read 

func (f *ConnectionStart) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionStart) Reset 

func (m *ConnectionStart) Reset()

func (*ConnectionStart) Size 

func (m *ConnectionStart) Size() (n int)

func (*ConnectionStart) String 

func (m *ConnectionStart) String() string

func (*ConnectionStart) Unmarshal 

func (m *ConnectionStart) Unmarshal(dAtA []byte) error

func (*ConnectionStart) Write 

func (f *ConnectionStart) Write(writer io.Writer) (err error)

Writer

func (*ConnectionStart) XXX_DiscardUnknown 

func (m *ConnectionStart) XXX_DiscardUnknown()

func (*ConnectionStart) XXX_Marshal 

func (m *ConnectionStart) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionStart) XXX_Merge 

func (m *ConnectionStart) XXX_Merge(src proto.Message)

func (*ConnectionStart) XXX_Size 

func (m *ConnectionStart) XXX_Size() int

func (*ConnectionStart) XXX_Unmarshal 

func (m *ConnectionStart) XXX_Unmarshal(b []byte) error

type ConnectionStartOk 

type ConnectionStartOk struct {
	ClientProperties     *Table   `protobuf:"bytes,1,opt,name=client_properties,json=clientProperties" json:"client_properties,omitempty"`
	Mechanism            string   `protobuf:"bytes,2,opt,name=mechanism" json:"mechanism"`
	Response             []byte   `protobuf:"bytes,3,opt,name=response" json:"response,omitempty"`
	Locale               string   `protobuf:"bytes,4,opt,name=locale" json:"locale"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionStartOk) Descriptor 

func (*ConnectionStartOk) Descriptor() ([]byte, []int)

func (*ConnectionStartOk) FrameType 

func (f *ConnectionStartOk) FrameType() byte

func (*ConnectionStartOk) Marshal 

func (m *ConnectionStartOk) Marshal() (dAtA []byte, err error)

func (*ConnectionStartOk) MarshalTo 

func (m *ConnectionStartOk) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionStartOk) MethodIdentifier 

func (f *ConnectionStartOk) MethodIdentifier() (uint16, uint16)

func (*ConnectionStartOk) MethodName 

func (f *ConnectionStartOk) MethodName() string

func (*ConnectionStartOk) ProtoMessage 

func (*ConnectionStartOk) ProtoMessage()

func (*ConnectionStartOk) Read 

func (f *ConnectionStartOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionStartOk) Reset 

func (m *ConnectionStartOk) Reset()

func (*ConnectionStartOk) Size 

func (m *ConnectionStartOk) Size() (n int)

func (*ConnectionStartOk) String 

func (m *ConnectionStartOk) String() string

func (*ConnectionStartOk) Unmarshal 

func (m *ConnectionStartOk) Unmarshal(dAtA []byte) error

func (*ConnectionStartOk) Write 

func (f *ConnectionStartOk) Write(writer io.Writer) (err error)

Writer

func (*ConnectionStartOk) XXX_DiscardUnknown 

func (m *ConnectionStartOk) XXX_DiscardUnknown()

func (*ConnectionStartOk) XXX_Marshal 

func (m *ConnectionStartOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionStartOk) XXX_Merge 

func (m *ConnectionStartOk) XXX_Merge(src proto.Message)

func (*ConnectionStartOk) XXX_Size 

func (m *ConnectionStartOk) XXX_Size() int

func (*ConnectionStartOk) XXX_Unmarshal 

func (m *ConnectionStartOk) XXX_Unmarshal(b []byte) error

type ConnectionTune 

type ConnectionTune struct {
	ChannelMax           uint16   `protobuf:"varint,1,opt,name=channel_max,json=channelMax,casttype=uint16" json:"channel_max"`
	FrameMax             uint32   `protobuf:"varint,2,opt,name=frame_max,json=frameMax" json:"frame_max"`
	Heartbeat            uint16   `protobuf:"varint,3,opt,name=heartbeat,casttype=uint16" json:"heartbeat"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionTune) Descriptor 

func (*ConnectionTune) Descriptor() ([]byte, []int)

func (*ConnectionTune) FrameType 

func (f *ConnectionTune) FrameType() byte

func (*ConnectionTune) Marshal 

func (m *ConnectionTune) Marshal() (dAtA []byte, err error)

func (*ConnectionTune) MarshalTo 

func (m *ConnectionTune) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionTune) MethodIdentifier 

func (f *ConnectionTune) MethodIdentifier() (uint16, uint16)

func (*ConnectionTune) MethodName 

func (f *ConnectionTune) MethodName() string

func (*ConnectionTune) ProtoMessage 

func (*ConnectionTune) ProtoMessage()

func (*ConnectionTune) Read 

func (f *ConnectionTune) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionTune) Reset 

func (m *ConnectionTune) Reset()

func (*ConnectionTune) Size 

func (m *ConnectionTune) Size() (n int)

func (*ConnectionTune) String 

func (m *ConnectionTune) String() string

func (*ConnectionTune) Unmarshal 

func (m *ConnectionTune) Unmarshal(dAtA []byte) error

func (*ConnectionTune) Write 

func (f *ConnectionTune) Write(writer io.Writer) (err error)

Writer

func (*ConnectionTune) XXX_DiscardUnknown 

func (m *ConnectionTune) XXX_DiscardUnknown()

func (*ConnectionTune) XXX_Marshal 

func (m *ConnectionTune) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionTune) XXX_Merge 

func (m *ConnectionTune) XXX_Merge(src proto.Message)

func (*ConnectionTune) XXX_Size 

func (m *ConnectionTune) XXX_Size() int

func (*ConnectionTune) XXX_Unmarshal 

func (m *ConnectionTune) XXX_Unmarshal(b []byte) error

type ConnectionTuneOk 

type ConnectionTuneOk struct {
	ChannelMax           uint16   `protobuf:"varint,1,opt,name=channel_max,json=channelMax,casttype=uint16" json:"channel_max"`
	FrameMax             uint32   `protobuf:"varint,2,opt,name=frame_max,json=frameMax" json:"frame_max"`
	Heartbeat            uint16   `protobuf:"varint,3,opt,name=heartbeat,casttype=uint16" json:"heartbeat"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionTuneOk) Descriptor 

func (*ConnectionTuneOk) Descriptor() ([]byte, []int)

func (*ConnectionTuneOk) FrameType 

func (f *ConnectionTuneOk) FrameType() byte

func (*ConnectionTuneOk) Marshal 

func (m *ConnectionTuneOk) Marshal() (dAtA []byte, err error)

func (*ConnectionTuneOk) MarshalTo 

func (m *ConnectionTuneOk) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionTuneOk) MethodIdentifier 

func (f *ConnectionTuneOk) MethodIdentifier() (uint16, uint16)

func (*ConnectionTuneOk) MethodName 

func (f *ConnectionTuneOk) MethodName() string

func (*ConnectionTuneOk) ProtoMessage 

func (*ConnectionTuneOk) ProtoMessage()

func (*ConnectionTuneOk) Read 

func (f *ConnectionTuneOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionTuneOk) Reset 

func (m *ConnectionTuneOk) Reset()

func (*ConnectionTuneOk) Size 

func (m *ConnectionTuneOk) Size() (n int)

func (*ConnectionTuneOk) String 

func (m *ConnectionTuneOk) String() string

func (*ConnectionTuneOk) Unmarshal 

func (m *ConnectionTuneOk) Unmarshal(dAtA []byte) error

func (*ConnectionTuneOk) Write 

func (f *ConnectionTuneOk) Write(writer io.Writer) (err error)

Writer

func (*ConnectionTuneOk) XXX_DiscardUnknown 

func (m *ConnectionTuneOk) XXX_DiscardUnknown()

func (*ConnectionTuneOk) XXX_Marshal 

func (m *ConnectionTuneOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionTuneOk) XXX_Merge 

func (m *ConnectionTuneOk) XXX_Merge(src proto.Message)

func (*ConnectionTuneOk) XXX_Size 

func (m *ConnectionTuneOk) XXX_Size() int

func (*ConnectionTuneOk) XXX_Unmarshal 

func (m *ConnectionTuneOk) XXX_Unmarshal(b []byte) error

type ConnectionUnblocked 

type ConnectionUnblocked struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ConnectionUnblocked) Descriptor 

func (*ConnectionUnblocked) Descriptor() ([]byte, []int)

func (*ConnectionUnblocked) FrameType 

func (f *ConnectionUnblocked) FrameType() byte

func (*ConnectionUnblocked) Marshal 

func (m *ConnectionUnblocked) Marshal() (dAtA []byte, err error)

func (*ConnectionUnblocked) MarshalTo 

func (m *ConnectionUnblocked) MarshalTo(dAtA []byte) (int, error)

func (*ConnectionUnblocked) MethodIdentifier 

func (f *ConnectionUnblocked) MethodIdentifier() (uint16, uint16)

func (*ConnectionUnblocked) MethodName 

func (f *ConnectionUnblocked) MethodName() string

func (*ConnectionUnblocked) ProtoMessage 

func (*ConnectionUnblocked) ProtoMessage()

func (*ConnectionUnblocked) Read 

func (f *ConnectionUnblocked) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ConnectionUnblocked) Reset 

func (m *ConnectionUnblocked) Reset()

func (*ConnectionUnblocked) Size 

func (m *ConnectionUnblocked) Size() (n int)

func (*ConnectionUnblocked) String 

func (m *ConnectionUnblocked) String() string

func (*ConnectionUnblocked) Unmarshal 

func (m *ConnectionUnblocked) Unmarshal(dAtA []byte) error

func (*ConnectionUnblocked) Write 

func (f *ConnectionUnblocked) Write(writer io.Writer) (err error)

Writer

func (*ConnectionUnblocked) XXX_DiscardUnknown 

func (m *ConnectionUnblocked) XXX_DiscardUnknown()

func (*ConnectionUnblocked) XXX_Marshal 

func (m *ConnectionUnblocked) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ConnectionUnblocked) XXX_Merge 

func (m *ConnectionUnblocked) XXX_Merge(src proto.Message)

func (*ConnectionUnblocked) XXX_Size 

func (m *ConnectionUnblocked) XXX_Size() int

func (*ConnectionUnblocked) XXX_Unmarshal 

func (m *ConnectionUnblocked) XXX_Unmarshal(b []byte) error

type ContentHeaderFrame 

type ContentHeaderFrame struct {
	ContentClass         uint16                        `protobuf:"varint,1,opt,name=content_class,json=contentClass,casttype=uint16" json:"content_class"`
	ContentWeight        uint16                        `protobuf:"varint,2,opt,name=content_weight,json=contentWeight,casttype=uint16" json:"content_weight"`
	ContentBodySize      uint64                        `protobuf:"varint,3,opt,name=content_body_size,json=contentBodySize" json:"content_body_size"`
	PropertyFlags        uint16                        `protobuf:"varint,4,opt,name=property_flags,json=propertyFlags,casttype=uint16" json:"property_flags"`
	Properties           *BasicContentHeaderProperties `protobuf:"bytes,5,opt,name=properties" json:"properties,omitempty"`
	XXX_NoUnkeyedLiteral struct{}                      `json:"-"`
	XXX_unrecognized     []byte                        `json:"-"`
	XXX_sizecache        int32                         `json:"-"`
}

func RandomHeader 

func RandomHeader(size uint64, persistent bool) *ContentHeaderFrame

func (*ContentHeaderFrame) Descriptor 

func (*ContentHeaderFrame) Descriptor() ([]byte, []int)

func (*ContentHeaderFrame) FrameType 

func (frame *ContentHeaderFrame) FrameType() byte

func (*ContentHeaderFrame) GetContentBodySize 

func (m *ContentHeaderFrame) GetContentBodySize() uint64

func (*ContentHeaderFrame) GetContentClass 

func (m *ContentHeaderFrame) GetContentClass() uint16

func (*ContentHeaderFrame) GetContentWeight 

func (m *ContentHeaderFrame) GetContentWeight() uint16

func (*ContentHeaderFrame) GetProperties 

func (m *ContentHeaderFrame) GetProperties() *BasicContentHeaderProperties

func (*ContentHeaderFrame) GetPropertyFlags 

func (m *ContentHeaderFrame) GetPropertyFlags() uint16

func (*ContentHeaderFrame) Marshal 

func (m *ContentHeaderFrame) Marshal() (dAtA []byte, err error)

func (*ContentHeaderFrame) MarshalTo 

func (m *ContentHeaderFrame) MarshalTo(dAtA []byte) (int, error)

func (*ContentHeaderFrame) ProtoMessage 

func (*ContentHeaderFrame) ProtoMessage()

func (*ContentHeaderFrame) Read 

func (frame *ContentHeaderFrame) Read(reader io.Reader, strictMode bool) (err error)

func (*ContentHeaderFrame) Reset 

func (m *ContentHeaderFrame) Reset()

func (*ContentHeaderFrame) Size 

func (m *ContentHeaderFrame) Size() (n int)

func (*ContentHeaderFrame) String 

func (m *ContentHeaderFrame) String() string

func (*ContentHeaderFrame) Unmarshal 

func (m *ContentHeaderFrame) Unmarshal(dAtA []byte) error

func (*ContentHeaderFrame) XXX_DiscardUnknown 

func (m *ContentHeaderFrame) XXX_DiscardUnknown()

func (*ContentHeaderFrame) XXX_Marshal 

func (m *ContentHeaderFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ContentHeaderFrame) XXX_Merge 

func (m *ContentHeaderFrame) XXX_Merge(src proto.Message)

func (*ContentHeaderFrame) XXX_Size 

func (m *ContentHeaderFrame) XXX_Size() int

func (*ContentHeaderFrame) XXX_Unmarshal 

func (m *ContentHeaderFrame) XXX_Unmarshal(b []byte) error

type Decimal 

type Decimal struct {
	Scale                *uint8   `protobuf:"varint,1,opt,name=scale,casttype=uint8" json:"scale,omitempty"`
	Value                *int32   `protobuf:"varint,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*Decimal) Descriptor 

func (*Decimal) Descriptor() ([]byte, []int)

func (*Decimal) Marshal 

func (m *Decimal) Marshal() (dAtA []byte, err error)

func (*Decimal) MarshalTo 

func (m *Decimal) MarshalTo(dAtA []byte) (int, error)

func (*Decimal) ProtoMessage 

func (*Decimal) ProtoMessage()

func (*Decimal) Reset 

func (m *Decimal) Reset()

func (*Decimal) Size 

func (m *Decimal) Size() (n int)

func (*Decimal) String 

func (m *Decimal) String() string

func (*Decimal) Unmarshal 

func (m *Decimal) Unmarshal(dAtA []byte) error

func (*Decimal) XXX_DiscardUnknown 

func (m *Decimal) XXX_DiscardUnknown()

func (*Decimal) XXX_Marshal 

func (m *Decimal) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Decimal) XXX_Merge 

func (m *Decimal) XXX_Merge(src proto.Message)

func (*Decimal) XXX_Size 

func (m *Decimal) XXX_Size() int

func (*Decimal) XXX_Unmarshal 

func (m *Decimal) XXX_Unmarshal(b []byte) error

type ExchangeBind 

type ExchangeBind struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Destination          string   `protobuf:"bytes,2,opt,name=destination" json:"destination"`
	Source               string   `protobuf:"bytes,3,opt,name=source" json:"source"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	NoWait               bool     `protobuf:"varint,5,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,6,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeBind) Descriptor 

func (*ExchangeBind) Descriptor() ([]byte, []int)

func (*ExchangeBind) FrameType 

func (f *ExchangeBind) FrameType() byte

func (*ExchangeBind) Marshal 

func (m *ExchangeBind) Marshal() (dAtA []byte, err error)

func (*ExchangeBind) MarshalTo 

func (m *ExchangeBind) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeBind) MethodIdentifier 

func (f *ExchangeBind) MethodIdentifier() (uint16, uint16)

func (*ExchangeBind) MethodName 

func (f *ExchangeBind) MethodName() string

func (*ExchangeBind) ProtoMessage 

func (*ExchangeBind) ProtoMessage()

func (*ExchangeBind) Read 

func (f *ExchangeBind) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeBind) Reset 

func (m *ExchangeBind) Reset()

func (*ExchangeBind) Size 

func (m *ExchangeBind) Size() (n int)

func (*ExchangeBind) String 

func (m *ExchangeBind) String() string

func (*ExchangeBind) Unmarshal 

func (m *ExchangeBind) Unmarshal(dAtA []byte) error

func (*ExchangeBind) Write 

func (f *ExchangeBind) Write(writer io.Writer) (err error)

Writer

func (*ExchangeBind) XXX_DiscardUnknown 

func (m *ExchangeBind) XXX_DiscardUnknown()

func (*ExchangeBind) XXX_Marshal 

func (m *ExchangeBind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeBind) XXX_Merge 

func (m *ExchangeBind) XXX_Merge(src proto.Message)

func (*ExchangeBind) XXX_Size 

func (m *ExchangeBind) XXX_Size() int

func (*ExchangeBind) XXX_Unmarshal 

func (m *ExchangeBind) XXX_Unmarshal(b []byte) error

type ExchangeBindOk 

type ExchangeBindOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeBindOk) Descriptor 

func (*ExchangeBindOk) Descriptor() ([]byte, []int)

func (*ExchangeBindOk) FrameType 

func (f *ExchangeBindOk) FrameType() byte

func (*ExchangeBindOk) Marshal 

func (m *ExchangeBindOk) Marshal() (dAtA []byte, err error)

func (*ExchangeBindOk) MarshalTo 

func (m *ExchangeBindOk) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeBindOk) MethodIdentifier 

func (f *ExchangeBindOk) MethodIdentifier() (uint16, uint16)

func (*ExchangeBindOk) MethodName 

func (f *ExchangeBindOk) MethodName() string

func (*ExchangeBindOk) ProtoMessage 

func (*ExchangeBindOk) ProtoMessage()

func (*ExchangeBindOk) Read 

func (f *ExchangeBindOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeBindOk) Reset 

func (m *ExchangeBindOk) Reset()

func (*ExchangeBindOk) Size 

func (m *ExchangeBindOk) Size() (n int)

func (*ExchangeBindOk) String 

func (m *ExchangeBindOk) String() string

func (*ExchangeBindOk) Unmarshal 

func (m *ExchangeBindOk) Unmarshal(dAtA []byte) error

func (*ExchangeBindOk) Write 

func (f *ExchangeBindOk) Write(writer io.Writer) (err error)

Writer

func (*ExchangeBindOk) XXX_DiscardUnknown 

func (m *ExchangeBindOk) XXX_DiscardUnknown()

func (*ExchangeBindOk) XXX_Marshal 

func (m *ExchangeBindOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeBindOk) XXX_Merge 

func (m *ExchangeBindOk) XXX_Merge(src proto.Message)

func (*ExchangeBindOk) XXX_Size 

func (m *ExchangeBindOk) XXX_Size() int

func (*ExchangeBindOk) XXX_Unmarshal 

func (m *ExchangeBindOk) XXX_Unmarshal(b []byte) error

type ExchangeDeclare 

type ExchangeDeclare struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Exchange             string   `protobuf:"bytes,2,opt,name=exchange" json:"exchange"`
	Type                 string   `protobuf:"bytes,3,opt,name=type" json:"type"`
	Passive              bool     `protobuf:"varint,4,opt,name=passive" json:"passive"`
	Durable              bool     `protobuf:"varint,5,opt,name=durable" json:"durable"`
	AutoDelete           bool     `protobuf:"varint,6,opt,name=auto_delete,json=autoDelete" json:"auto_delete"`
	Internal             bool     `protobuf:"varint,7,opt,name=internal" json:"internal"`
	NoWait               bool     `protobuf:"varint,8,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,9,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeDeclare) Descriptor 

func (*ExchangeDeclare) Descriptor() ([]byte, []int)

func (*ExchangeDeclare) FrameType 

func (f *ExchangeDeclare) FrameType() byte

func (*ExchangeDeclare) Marshal 

func (m *ExchangeDeclare) Marshal() (dAtA []byte, err error)

func (*ExchangeDeclare) MarshalTo 

func (m *ExchangeDeclare) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeDeclare) MethodIdentifier 

func (f *ExchangeDeclare) MethodIdentifier() (uint16, uint16)

func (*ExchangeDeclare) MethodName 

func (f *ExchangeDeclare) MethodName() string

func (*ExchangeDeclare) ProtoMessage 

func (*ExchangeDeclare) ProtoMessage()

func (*ExchangeDeclare) Read 

func (f *ExchangeDeclare) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeDeclare) Reset 

func (m *ExchangeDeclare) Reset()

func (*ExchangeDeclare) Size 

func (m *ExchangeDeclare) Size() (n int)

func (*ExchangeDeclare) String 

func (m *ExchangeDeclare) String() string

func (*ExchangeDeclare) Unmarshal 

func (m *ExchangeDeclare) Unmarshal(dAtA []byte) error

func (*ExchangeDeclare) Write 

func (f *ExchangeDeclare) Write(writer io.Writer) (err error)

Writer

func (*ExchangeDeclare) XXX_DiscardUnknown 

func (m *ExchangeDeclare) XXX_DiscardUnknown()

func (*ExchangeDeclare) XXX_Marshal 

func (m *ExchangeDeclare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeDeclare) XXX_Merge 

func (m *ExchangeDeclare) XXX_Merge(src proto.Message)

func (*ExchangeDeclare) XXX_Size 

func (m *ExchangeDeclare) XXX_Size() int

func (*ExchangeDeclare) XXX_Unmarshal 

func (m *ExchangeDeclare) XXX_Unmarshal(b []byte) error

type ExchangeDeclareOk 

type ExchangeDeclareOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeDeclareOk) Descriptor 

func (*ExchangeDeclareOk) Descriptor() ([]byte, []int)

func (*ExchangeDeclareOk) FrameType 

func (f *ExchangeDeclareOk) FrameType() byte

func (*ExchangeDeclareOk) Marshal 

func (m *ExchangeDeclareOk) Marshal() (dAtA []byte, err error)

func (*ExchangeDeclareOk) MarshalTo 

func (m *ExchangeDeclareOk) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeDeclareOk) MethodIdentifier 

func (f *ExchangeDeclareOk) MethodIdentifier() (uint16, uint16)

func (*ExchangeDeclareOk) MethodName 

func (f *ExchangeDeclareOk) MethodName() string

func (*ExchangeDeclareOk) ProtoMessage 

func (*ExchangeDeclareOk) ProtoMessage()

func (*ExchangeDeclareOk) Read 

func (f *ExchangeDeclareOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeDeclareOk) Reset 

func (m *ExchangeDeclareOk) Reset()

func (*ExchangeDeclareOk) Size 

func (m *ExchangeDeclareOk) Size() (n int)

func (*ExchangeDeclareOk) String 

func (m *ExchangeDeclareOk) String() string

func (*ExchangeDeclareOk) Unmarshal 

func (m *ExchangeDeclareOk) Unmarshal(dAtA []byte) error

func (*ExchangeDeclareOk) Write 

func (f *ExchangeDeclareOk) Write(writer io.Writer) (err error)

Writer

func (*ExchangeDeclareOk) XXX_DiscardUnknown 

func (m *ExchangeDeclareOk) XXX_DiscardUnknown()

func (*ExchangeDeclareOk) XXX_Marshal 

func (m *ExchangeDeclareOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeDeclareOk) XXX_Merge 

func (m *ExchangeDeclareOk) XXX_Merge(src proto.Message)

func (*ExchangeDeclareOk) XXX_Size 

func (m *ExchangeDeclareOk) XXX_Size() int

func (*ExchangeDeclareOk) XXX_Unmarshal 

func (m *ExchangeDeclareOk) XXX_Unmarshal(b []byte) error

type ExchangeDelete 

type ExchangeDelete struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Exchange             string   `protobuf:"bytes,2,opt,name=exchange" json:"exchange"`
	IfUnused             bool     `protobuf:"varint,3,opt,name=if_unused,json=ifUnused" json:"if_unused"`
	NoWait               bool     `protobuf:"varint,4,opt,name=no_wait,json=noWait" json:"no_wait"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeDelete) Descriptor 

func (*ExchangeDelete) Descriptor() ([]byte, []int)

func (*ExchangeDelete) FrameType 

func (f *ExchangeDelete) FrameType() byte

func (*ExchangeDelete) Marshal 

func (m *ExchangeDelete) Marshal() (dAtA []byte, err error)

func (*ExchangeDelete) MarshalTo 

func (m *ExchangeDelete) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeDelete) MethodIdentifier 

func (f *ExchangeDelete) MethodIdentifier() (uint16, uint16)

func (*ExchangeDelete) MethodName 

func (f *ExchangeDelete) MethodName() string

func (*ExchangeDelete) ProtoMessage 

func (*ExchangeDelete) ProtoMessage()

func (*ExchangeDelete) Read 

func (f *ExchangeDelete) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeDelete) Reset 

func (m *ExchangeDelete) Reset()

func (*ExchangeDelete) Size 

func (m *ExchangeDelete) Size() (n int)

func (*ExchangeDelete) String 

func (m *ExchangeDelete) String() string

func (*ExchangeDelete) Unmarshal 

func (m *ExchangeDelete) Unmarshal(dAtA []byte) error

func (*ExchangeDelete) Write 

func (f *ExchangeDelete) Write(writer io.Writer) (err error)

Writer

func (*ExchangeDelete) XXX_DiscardUnknown 

func (m *ExchangeDelete) XXX_DiscardUnknown()

func (*ExchangeDelete) XXX_Marshal 

func (m *ExchangeDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeDelete) XXX_Merge 

func (m *ExchangeDelete) XXX_Merge(src proto.Message)

func (*ExchangeDelete) XXX_Size 

func (m *ExchangeDelete) XXX_Size() int

func (*ExchangeDelete) XXX_Unmarshal 

func (m *ExchangeDelete) XXX_Unmarshal(b []byte) error

type ExchangeDeleteOk 

type ExchangeDeleteOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeDeleteOk) Descriptor 

func (*ExchangeDeleteOk) Descriptor() ([]byte, []int)

func (*ExchangeDeleteOk) FrameType 

func (f *ExchangeDeleteOk) FrameType() byte

func (*ExchangeDeleteOk) Marshal 

func (m *ExchangeDeleteOk) Marshal() (dAtA []byte, err error)

func (*ExchangeDeleteOk) MarshalTo 

func (m *ExchangeDeleteOk) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeDeleteOk) MethodIdentifier 

func (f *ExchangeDeleteOk) MethodIdentifier() (uint16, uint16)

func (*ExchangeDeleteOk) MethodName 

func (f *ExchangeDeleteOk) MethodName() string

func (*ExchangeDeleteOk) ProtoMessage 

func (*ExchangeDeleteOk) ProtoMessage()

func (*ExchangeDeleteOk) Read 

func (f *ExchangeDeleteOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeDeleteOk) Reset 

func (m *ExchangeDeleteOk) Reset()

func (*ExchangeDeleteOk) Size 

func (m *ExchangeDeleteOk) Size() (n int)

func (*ExchangeDeleteOk) String 

func (m *ExchangeDeleteOk) String() string

func (*ExchangeDeleteOk) Unmarshal 

func (m *ExchangeDeleteOk) Unmarshal(dAtA []byte) error

func (*ExchangeDeleteOk) Write 

func (f *ExchangeDeleteOk) Write(writer io.Writer) (err error)

Writer

func (*ExchangeDeleteOk) XXX_DiscardUnknown 

func (m *ExchangeDeleteOk) XXX_DiscardUnknown()

func (*ExchangeDeleteOk) XXX_Marshal 

func (m *ExchangeDeleteOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeDeleteOk) XXX_Merge 

func (m *ExchangeDeleteOk) XXX_Merge(src proto.Message)

func (*ExchangeDeleteOk) XXX_Size 

func (m *ExchangeDeleteOk) XXX_Size() int

func (*ExchangeDeleteOk) XXX_Unmarshal 

func (m *ExchangeDeleteOk) XXX_Unmarshal(b []byte) error

type ExchangeUnbind 

type ExchangeUnbind struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Destination          string   `protobuf:"bytes,2,opt,name=destination" json:"destination"`
	Source               string   `protobuf:"bytes,3,opt,name=source" json:"source"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	NoWait               bool     `protobuf:"varint,5,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,6,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeUnbind) Descriptor 

func (*ExchangeUnbind) Descriptor() ([]byte, []int)

func (*ExchangeUnbind) FrameType 

func (f *ExchangeUnbind) FrameType() byte

func (*ExchangeUnbind) Marshal 

func (m *ExchangeUnbind) Marshal() (dAtA []byte, err error)

func (*ExchangeUnbind) MarshalTo 

func (m *ExchangeUnbind) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeUnbind) MethodIdentifier 

func (f *ExchangeUnbind) MethodIdentifier() (uint16, uint16)

func (*ExchangeUnbind) MethodName 

func (f *ExchangeUnbind) MethodName() string

func (*ExchangeUnbind) ProtoMessage 

func (*ExchangeUnbind) ProtoMessage()

func (*ExchangeUnbind) Read 

func (f *ExchangeUnbind) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeUnbind) Reset 

func (m *ExchangeUnbind) Reset()

func (*ExchangeUnbind) Size 

func (m *ExchangeUnbind) Size() (n int)

func (*ExchangeUnbind) String 

func (m *ExchangeUnbind) String() string

func (*ExchangeUnbind) Unmarshal 

func (m *ExchangeUnbind) Unmarshal(dAtA []byte) error

func (*ExchangeUnbind) Write 

func (f *ExchangeUnbind) Write(writer io.Writer) (err error)

Writer

func (*ExchangeUnbind) XXX_DiscardUnknown 

func (m *ExchangeUnbind) XXX_DiscardUnknown()

func (*ExchangeUnbind) XXX_Marshal 

func (m *ExchangeUnbind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeUnbind) XXX_Merge 

func (m *ExchangeUnbind) XXX_Merge(src proto.Message)

func (*ExchangeUnbind) XXX_Size 

func (m *ExchangeUnbind) XXX_Size() int

func (*ExchangeUnbind) XXX_Unmarshal 

func (m *ExchangeUnbind) XXX_Unmarshal(b []byte) error

type ExchangeUnbindOk 

type ExchangeUnbindOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*ExchangeUnbindOk) Descriptor 

func (*ExchangeUnbindOk) Descriptor() ([]byte, []int)

func (*ExchangeUnbindOk) FrameType 

func (f *ExchangeUnbindOk) FrameType() byte

func (*ExchangeUnbindOk) Marshal 

func (m *ExchangeUnbindOk) Marshal() (dAtA []byte, err error)

func (*ExchangeUnbindOk) MarshalTo 

func (m *ExchangeUnbindOk) MarshalTo(dAtA []byte) (int, error)

func (*ExchangeUnbindOk) MethodIdentifier 

func (f *ExchangeUnbindOk) MethodIdentifier() (uint16, uint16)

func (*ExchangeUnbindOk) MethodName 

func (f *ExchangeUnbindOk) MethodName() string

func (*ExchangeUnbindOk) ProtoMessage 

func (*ExchangeUnbindOk) ProtoMessage()

func (*ExchangeUnbindOk) Read 

func (f *ExchangeUnbindOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*ExchangeUnbindOk) Reset 

func (m *ExchangeUnbindOk) Reset()

func (*ExchangeUnbindOk) Size 

func (m *ExchangeUnbindOk) Size() (n int)

func (*ExchangeUnbindOk) String 

func (m *ExchangeUnbindOk) String() string

func (*ExchangeUnbindOk) Unmarshal 

func (m *ExchangeUnbindOk) Unmarshal(dAtA []byte) error

func (*ExchangeUnbindOk) Write 

func (f *ExchangeUnbindOk) Write(writer io.Writer) (err error)

Writer

func (*ExchangeUnbindOk) XXX_DiscardUnknown 

func (m *ExchangeUnbindOk) XXX_DiscardUnknown()

func (*ExchangeUnbindOk) XXX_Marshal 

func (m *ExchangeUnbindOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*ExchangeUnbindOk) XXX_Merge 

func (m *ExchangeUnbindOk) XXX_Merge(src proto.Message)

func (*ExchangeUnbindOk) XXX_Size 

func (m *ExchangeUnbindOk) XXX_Size() int

func (*ExchangeUnbindOk) XXX_Unmarshal 

func (m *ExchangeUnbindOk) XXX_Unmarshal(b []byte) error

type FieldArray 

type FieldArray struct {
	Value                []*FieldValue `protobuf:"bytes,1,rep,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func NewFieldArray 

func NewFieldArray() *FieldArray

func (*FieldArray) AppendFA 

func (fa *FieldArray) AppendFA(value interface{}) error

func (*FieldArray) Descriptor 

func (*FieldArray) Descriptor() ([]byte, []int)

func (*FieldArray) Marshal 

func (m *FieldArray) Marshal() (dAtA []byte, err error)

func (*FieldArray) MarshalTo 

func (m *FieldArray) MarshalTo(dAtA []byte) (int, error)

func (*FieldArray) ProtoMessage 

func (*FieldArray) ProtoMessage()

func (*FieldArray) Reset 

func (m *FieldArray) Reset()

func (*FieldArray) Size 

func (m *FieldArray) Size() (n int)

func (*FieldArray) String 

func (m *FieldArray) String() string

func (*FieldArray) Unmarshal 

func (m *FieldArray) Unmarshal(dAtA []byte) error

func (*FieldArray) XXX_DiscardUnknown 

func (m *FieldArray) XXX_DiscardUnknown()

func (*FieldArray) XXX_Marshal 

func (m *FieldArray) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FieldArray) XXX_Merge 

func (m *FieldArray) XXX_Merge(src proto.Message)

func (*FieldArray) XXX_Size 

func (m *FieldArray) XXX_Size() int

func (*FieldArray) XXX_Unmarshal 

func (m *FieldArray) XXX_Unmarshal(b []byte) error

type FieldValue 

type FieldValue struct {
	// Types that are valid to be assigned to Value:
	//	*FieldValue_VBoolean
	//	*FieldValue_VInt8
	//	*FieldValue_VUint8
	//	*FieldValue_VInt16
	//	*FieldValue_VUint16
	//	*FieldValue_VInt32
	//	*FieldValue_VUint32
	//	*FieldValue_VInt64
	//	*FieldValue_VUint64
	//	*FieldValue_VFloat
	//	*FieldValue_VDouble
	//	*FieldValue_VDecimal
	//	*FieldValue_VShortstr
	//	*FieldValue_VLongstr
	//	*FieldValue_VArray
	//	*FieldValue_VTimestamp
	//	*FieldValue_VTable
	//	*FieldValue_VBytes
	Value                isFieldValue_Value `protobuf_oneof:"value"`
	XXX_NoUnkeyedLiteral struct{}           `json:"-"`
	XXX_sizecache        int32              `json:"-"`
}

func (*FieldValue) Descriptor 

func (*FieldValue) Descriptor() ([]byte, []int)

func (*FieldValue) GetVArray 

func (m *FieldValue) GetVArray() *FieldArray

func (*FieldValue) GetVBoolean 

func (m *FieldValue) GetVBoolean() bool

func (*FieldValue) GetVBytes 

func (m *FieldValue) GetVBytes() []byte

func (*FieldValue) GetVDecimal 

func (m *FieldValue) GetVDecimal() *Decimal

func (*FieldValue) GetVDouble 

func (m *FieldValue) GetVDouble() float64

func (*FieldValue) GetVFloat 

func (m *FieldValue) GetVFloat() float32

func (*FieldValue) GetVInt16 

func (m *FieldValue) GetVInt16() int16

func (*FieldValue) GetVInt32 

func (m *FieldValue) GetVInt32() int32

func (*FieldValue) GetVInt64 

func (m *FieldValue) GetVInt64() int64

func (*FieldValue) GetVInt8 

func (m *FieldValue) GetVInt8() int8

func (*FieldValue) GetVLongstr 

func (m *FieldValue) GetVLongstr() []byte

func (*FieldValue) GetVShortstr 

func (m *FieldValue) GetVShortstr() string

func (*FieldValue) GetVTable 

func (m *FieldValue) GetVTable() *Table

func (*FieldValue) GetVTimestamp 

func (m *FieldValue) GetVTimestamp() uint64

func (*FieldValue) GetVUint16 

func (m *FieldValue) GetVUint16() uint16

func (*FieldValue) GetVUint32 

func (m *FieldValue) GetVUint32() uint32

func (*FieldValue) GetVUint64 

func (m *FieldValue) GetVUint64() uint64

func (*FieldValue) GetVUint8 

func (m *FieldValue) GetVUint8() uint8

func (*FieldValue) GetValue 

func (m *FieldValue) GetValue() isFieldValue_Value

func (*FieldValue) Marshal 

func (m *FieldValue) Marshal() (dAtA []byte, err error)

func (*FieldValue) MarshalTo 

func (m *FieldValue) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue) ProtoMessage 

func (*FieldValue) ProtoMessage()

func (*FieldValue) Reset 

func (m *FieldValue) Reset()

func (*FieldValue) Size 

func (m *FieldValue) Size() (n int)

func (*FieldValue) String 

func (m *FieldValue) String() string

func (*FieldValue) Unmarshal 

func (m *FieldValue) Unmarshal(dAtA []byte) error

func (*FieldValue) XXX_DiscardUnknown 

func (m *FieldValue) XXX_DiscardUnknown()

func (*FieldValue) XXX_Marshal 

func (m *FieldValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FieldValue) XXX_Merge 

func (m *FieldValue) XXX_Merge(src proto.Message)

func (*FieldValue) XXX_OneofFuncs 

func (*FieldValue) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{})

XXX_OneofFuncs is for the internal use of the proto package.

func (*FieldValue) XXX_Size 

func (m *FieldValue) XXX_Size() int

func (*FieldValue) XXX_Unmarshal 

func (m *FieldValue) XXX_Unmarshal(b []byte) error

type FieldValuePair 

type FieldValuePair struct {
	Key                  *string     `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
	Value                *FieldValue `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
	XXX_NoUnkeyedLiteral struct{}    `json:"-"`
	XXX_sizecache        int32       `json:"-"`
}

func (*FieldValuePair) Descriptor 

func (*FieldValuePair) Descriptor() ([]byte, []int)

func (*FieldValuePair) Marshal 

func (m *FieldValuePair) Marshal() (dAtA []byte, err error)

func (*FieldValuePair) MarshalTo 

func (m *FieldValuePair) MarshalTo(dAtA []byte) (int, error)

func (*FieldValuePair) ProtoMessage 

func (*FieldValuePair) ProtoMessage()

func (*FieldValuePair) Reset 

func (m *FieldValuePair) Reset()

func (*FieldValuePair) Size 

func (m *FieldValuePair) Size() (n int)

func (*FieldValuePair) String 

func (m *FieldValuePair) String() string

func (*FieldValuePair) Unmarshal 

func (m *FieldValuePair) Unmarshal(dAtA []byte) error

func (*FieldValuePair) XXX_DiscardUnknown 

func (m *FieldValuePair) XXX_DiscardUnknown()

func (*FieldValuePair) XXX_Marshal 

func (m *FieldValuePair) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*FieldValuePair) XXX_Merge 

func (m *FieldValuePair) XXX_Merge(src proto.Message)

func (*FieldValuePair) XXX_Size 

func (m *FieldValuePair) XXX_Size() int

func (*FieldValuePair) XXX_Unmarshal 

func (m *FieldValuePair) XXX_Unmarshal(b []byte) error

type FieldValue_VArray 

type FieldValue_VArray struct {
	VArray *FieldArray `protobuf:"bytes,15,opt,name=v_array,json=vArray,oneof"`
}

func (*FieldValue_VArray) MarshalTo 

func (m *FieldValue_VArray) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VArray) Size 

func (m *FieldValue_VArray) Size() (n int)

type FieldValue_VBoolean 

type FieldValue_VBoolean struct {
	VBoolean bool `protobuf:"varint,1,opt,name=v_boolean,json=vBoolean,oneof"`
}

func (*FieldValue_VBoolean) MarshalTo 

func (m *FieldValue_VBoolean) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VBoolean) Size 

func (m *FieldValue_VBoolean) Size() (n int)

type FieldValue_VBytes 

type FieldValue_VBytes struct {
	VBytes []byte `protobuf:"bytes,18,opt,name=v_bytes,json=vBytes,oneof"`
}

func (*FieldValue_VBytes) MarshalTo 

func (m *FieldValue_VBytes) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VBytes) Size 

func (m *FieldValue_VBytes) Size() (n int)

type FieldValue_VDecimal 

type FieldValue_VDecimal struct {
	VDecimal *Decimal `protobuf:"bytes,12,opt,name=v_decimal,json=vDecimal,oneof"`
}

func (*FieldValue_VDecimal) MarshalTo 

func (m *FieldValue_VDecimal) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VDecimal) Size 

func (m *FieldValue_VDecimal) Size() (n int)

type FieldValue_VDouble 

type FieldValue_VDouble struct {
	VDouble float64 `protobuf:"fixed64,11,opt,name=v_double,json=vDouble,oneof"`
}

func (*FieldValue_VDouble) MarshalTo 

func (m *FieldValue_VDouble) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VDouble) Size 

func (m *FieldValue_VDouble) Size() (n int)

type FieldValue_VFloat 

type FieldValue_VFloat struct {
	VFloat float32 `protobuf:"fixed32,10,opt,name=v_float,json=vFloat,oneof"`
}

func (*FieldValue_VFloat) MarshalTo 

func (m *FieldValue_VFloat) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VFloat) Size 

func (m *FieldValue_VFloat) Size() (n int)

type FieldValue_VInt16 

type FieldValue_VInt16 struct {
	VInt16 int16 `protobuf:"varint,4,opt,name=v_int16,json=vInt16,oneof,casttype=int16"`
}

func (*FieldValue_VInt16) MarshalTo 

func (m *FieldValue_VInt16) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VInt16) Size 

func (m *FieldValue_VInt16) Size() (n int)

type FieldValue_VInt32 

type FieldValue_VInt32 struct {
	VInt32 int32 `protobuf:"varint,6,opt,name=v_int32,json=vInt32,oneof"`
}

func (*FieldValue_VInt32) MarshalTo 

func (m *FieldValue_VInt32) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VInt32) Size 

func (m *FieldValue_VInt32) Size() (n int)

type FieldValue_VInt64 

type FieldValue_VInt64 struct {
	VInt64 int64 `protobuf:"varint,8,opt,name=v_int64,json=vInt64,oneof"`
}

func (*FieldValue_VInt64) MarshalTo 

func (m *FieldValue_VInt64) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VInt64) Size 

func (m *FieldValue_VInt64) Size() (n int)

type FieldValue_VInt8 

type FieldValue_VInt8 struct {
	VInt8 int8 `protobuf:"varint,2,opt,name=v_int8,json=vInt8,oneof,casttype=int8"`
}

func (*FieldValue_VInt8) MarshalTo 

func (m *FieldValue_VInt8) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VInt8) Size 

func (m *FieldValue_VInt8) Size() (n int)

type FieldValue_VLongstr 

type FieldValue_VLongstr struct {
	VLongstr []byte `protobuf:"bytes,14,opt,name=v_longstr,json=vLongstr,oneof"`
}

func (*FieldValue_VLongstr) MarshalTo 

func (m *FieldValue_VLongstr) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VLongstr) Size 

func (m *FieldValue_VLongstr) Size() (n int)

type FieldValue_VShortstr 

type FieldValue_VShortstr struct {
	VShortstr string `protobuf:"bytes,13,opt,name=v_shortstr,json=vShortstr,oneof"`
}

func (*FieldValue_VShortstr) MarshalTo 

func (m *FieldValue_VShortstr) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VShortstr) Size 

func (m *FieldValue_VShortstr) Size() (n int)

type FieldValue_VTable 

type FieldValue_VTable struct {
	VTable *Table `protobuf:"bytes,17,opt,name=v_table,json=vTable,oneof"`
}

func (*FieldValue_VTable) MarshalTo 

func (m *FieldValue_VTable) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VTable) Size 

func (m *FieldValue_VTable) Size() (n int)

type FieldValue_VTimestamp 

type FieldValue_VTimestamp struct {
	VTimestamp uint64 `protobuf:"varint,16,opt,name=v_timestamp,json=vTimestamp,oneof"`
}

func (*FieldValue_VTimestamp) MarshalTo 

func (m *FieldValue_VTimestamp) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VTimestamp) Size 

func (m *FieldValue_VTimestamp) Size() (n int)

type FieldValue_VUint16 

type FieldValue_VUint16 struct {
	VUint16 uint16 `protobuf:"varint,5,opt,name=v_uint16,json=vUint16,oneof,casttype=uint16"`
}

func (*FieldValue_VUint16) MarshalTo 

func (m *FieldValue_VUint16) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VUint16) Size 

func (m *FieldValue_VUint16) Size() (n int)

type FieldValue_VUint32 

type FieldValue_VUint32 struct {
	VUint32 uint32 `protobuf:"varint,7,opt,name=v_uint32,json=vUint32,oneof"`
}

func (*FieldValue_VUint32) MarshalTo 

func (m *FieldValue_VUint32) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VUint32) Size 

func (m *FieldValue_VUint32) Size() (n int)

type FieldValue_VUint64 

type FieldValue_VUint64 struct {
	VUint64 uint64 `protobuf:"varint,9,opt,name=v_uint64,json=vUint64,oneof"`
}

func (*FieldValue_VUint64) MarshalTo 

func (m *FieldValue_VUint64) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VUint64) Size 

func (m *FieldValue_VUint64) Size() (n int)

type FieldValue_VUint8 

type FieldValue_VUint8 struct {
	VUint8 uint8 `protobuf:"varint,3,opt,name=v_uint8,json=vUint8,oneof,casttype=uint8"`
}

func (*FieldValue_VUint8) MarshalTo 

func (m *FieldValue_VUint8) MarshalTo(dAtA []byte) (int, error)

func (*FieldValue_VUint8) Size 

func (m *FieldValue_VUint8) Size() (n int)

type Frame 

type Frame interface {
	FrameType() byte
}

type IndexMessage 

type IndexMessage struct {
	// The ID of the underlying message
	Id int64 `protobuf:"varint,1,opt,name=id" json:"id"`
	// The number of outstanding references to the message
	Refs                 int32    `protobuf:"varint,2,opt,name=refs" json:"refs"`
	Durable              bool     `protobuf:"varint,3,opt,name=durable" json:"durable"`
	DeliveryCount        int32    `protobuf:"varint,4,opt,name=deliveryCount" json:"deliveryCount"`
	Persisted            bool     `protobuf:"varint,5,opt,name=persisted" json:"persisted"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func NewIndexMessage 

func NewIndexMessage(id int64, refCount int32, durable bool, deliveryCount int32) *IndexMessage

func (*IndexMessage) Descriptor 

func (*IndexMessage) Descriptor() ([]byte, []int)

func (*IndexMessage) GetDeliveryCount 

func (m *IndexMessage) GetDeliveryCount() int32

func (*IndexMessage) GetDurable 

func (m *IndexMessage) GetDurable() bool

func (*IndexMessage) GetId 

func (m *IndexMessage) GetId() int64

func (*IndexMessage) GetPersisted 

func (m *IndexMessage) GetPersisted() bool

func (*IndexMessage) GetRefs 

func (m *IndexMessage) GetRefs() int32

func (*IndexMessage) Marshal 

func (m *IndexMessage) Marshal() (dAtA []byte, err error)

func (*IndexMessage) MarshalTo 

func (m *IndexMessage) MarshalTo(dAtA []byte) (int, error)

func (*IndexMessage) ProtoMessage 

func (*IndexMessage) ProtoMessage()

func (*IndexMessage) Reset 

func (m *IndexMessage) Reset()

func (*IndexMessage) Size 

func (m *IndexMessage) Size() (n int)

func (*IndexMessage) String 

func (m *IndexMessage) String() string

func (*IndexMessage) Unmarshal 

func (m *IndexMessage) Unmarshal(dAtA []byte) error

func (*IndexMessage) XXX_DiscardUnknown 

func (m *IndexMessage) XXX_DiscardUnknown()

func (*IndexMessage) XXX_Marshal 

func (m *IndexMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*IndexMessage) XXX_Merge 

func (m *IndexMessage) XXX_Merge(src proto.Message)

func (*IndexMessage) XXX_Size 

func (m *IndexMessage) XXX_Size() int

func (*IndexMessage) XXX_Unmarshal 

func (m *IndexMessage) XXX_Unmarshal(b []byte) error

type Message 

type Message struct {
	Id                   int64               `protobuf:"varint,1,opt,name=id" json:"id"`
	Header               *ContentHeaderFrame `protobuf:"bytes,2,opt,name=header" json:"header,omitempty"`
	Payload              []*WireFrame        `protobuf:"bytes,3,rep,name=payload" json:"payload,omitempty"`
	Exchange             string              `protobuf:"bytes,4,opt,name=exchange" json:"exchange"`
	Key                  string              `protobuf:"bytes,5,opt,name=key" json:"key"`
	Method               *BasicPublish       `protobuf:"bytes,6,opt,name=method" json:"method,omitempty"`
	Redelivered          uint32              `protobuf:"varint,7,opt,name=redelivered" json:"redelivered"`
	LocalId              int64               `protobuf:"varint,8,opt,name=local_id,json=localId" json:"local_id"`
	XXX_NoUnkeyedLiteral struct{}            `json:"-"`
	XXX_unrecognized     []byte              `json:"-"`
	XXX_sizecache        int32               `json:"-"`
}

func NewMessage 

func NewMessage(method *BasicPublish, localId int64) *Message

func RandomMessage 

func RandomMessage(persistent bool) *Message

func (*Message) Descriptor 

func (*Message) Descriptor() ([]byte, []int)

func (*Message) GetExchange 

func (m *Message) GetExchange() string

func (*Message) GetHeader 

func (m *Message) GetHeader() *ContentHeaderFrame

func (*Message) GetId 

func (m *Message) GetId() int64

func (*Message) GetKey 

func (m *Message) GetKey() string

func (*Message) GetLocalId 

func (m *Message) GetLocalId() int64

func (*Message) GetMethod 

func (m *Message) GetMethod() *BasicPublish

func (*Message) GetPayload 

func (m *Message) GetPayload() []*WireFrame

func (*Message) GetRedelivered 

func (m *Message) GetRedelivered() uint32

func (*Message) Marshal 

func (m *Message) Marshal() (dAtA []byte, err error)

func (*Message) MarshalTo 

func (m *Message) MarshalTo(dAtA []byte) (int, error)

func (*Message) ProtoMessage 

func (*Message) ProtoMessage()

func (*Message) Reset 

func (m *Message) Reset()

func (*Message) Size 

func (m *Message) Size() (n int)

func (*Message) String 

func (m *Message) String() string

func (*Message) Unmarshal 

func (m *Message) Unmarshal(dAtA []byte) error

func (*Message) XXX_DiscardUnknown 

func (m *Message) XXX_DiscardUnknown()

func (*Message) XXX_Marshal 

func (m *Message) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Message) XXX_Merge 

func (m *Message) XXX_Merge(src proto.Message)

func (*Message) XXX_Size 

func (m *Message) XXX_Size() int

func (*Message) XXX_Unmarshal 

func (m *Message) XXX_Unmarshal(b []byte) error

type MessageResourceHolder 

type MessageResourceHolder interface {
	AcquireResources(qm *QueueMessage) bool
	ReleaseResources(qm *QueueMessage)
}

A message resource is something which has limits on the count of messages it can handle as well as the cumulative size of the messages it can handle.

type MethodFrame 

type MethodFrame interface {
	MethodName() string
	MethodIdentifier() (uint16, uint16)
	Read(reader io.Reader, strictMode bool) (err error)
	Write(writer io.Writer) (err error)
	FrameType() byte
}

func ReadMethod 

func ReadMethod(reader io.Reader, strictMode bool) (MethodFrame, error)

type QueueBind 

type QueueBind struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	Exchange             string   `protobuf:"bytes,3,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	NoWait               bool     `protobuf:"varint,5,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,6,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueBind) Descriptor 

func (*QueueBind) Descriptor() ([]byte, []int)

func (*QueueBind) FrameType 

func (f *QueueBind) FrameType() byte

func (*QueueBind) Marshal 

func (m *QueueBind) Marshal() (dAtA []byte, err error)

func (*QueueBind) MarshalTo 

func (m *QueueBind) MarshalTo(dAtA []byte) (int, error)

func (*QueueBind) MethodIdentifier 

func (f *QueueBind) MethodIdentifier() (uint16, uint16)

func (*QueueBind) MethodName 

func (f *QueueBind) MethodName() string

func (*QueueBind) ProtoMessage 

func (*QueueBind) ProtoMessage()

func (*QueueBind) Read 

func (f *QueueBind) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueBind) Reset 

func (m *QueueBind) Reset()

func (*QueueBind) Size 

func (m *QueueBind) Size() (n int)

func (*QueueBind) String 

func (m *QueueBind) String() string

func (*QueueBind) Unmarshal 

func (m *QueueBind) Unmarshal(dAtA []byte) error

func (*QueueBind) Write 

func (f *QueueBind) Write(writer io.Writer) (err error)

Writer

func (*QueueBind) XXX_DiscardUnknown 

func (m *QueueBind) XXX_DiscardUnknown()

func (*QueueBind) XXX_Marshal 

func (m *QueueBind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueBind) XXX_Merge 

func (m *QueueBind) XXX_Merge(src proto.Message)

func (*QueueBind) XXX_Size 

func (m *QueueBind) XXX_Size() int

func (*QueueBind) XXX_Unmarshal 

func (m *QueueBind) XXX_Unmarshal(b []byte) error

type QueueBindOk 

type QueueBindOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueBindOk) Descriptor 

func (*QueueBindOk) Descriptor() ([]byte, []int)

func (*QueueBindOk) FrameType 

func (f *QueueBindOk) FrameType() byte

func (*QueueBindOk) Marshal 

func (m *QueueBindOk) Marshal() (dAtA []byte, err error)

func (*QueueBindOk) MarshalTo 

func (m *QueueBindOk) MarshalTo(dAtA []byte) (int, error)

func (*QueueBindOk) MethodIdentifier 

func (f *QueueBindOk) MethodIdentifier() (uint16, uint16)

func (*QueueBindOk) MethodName 

func (f *QueueBindOk) MethodName() string

func (*QueueBindOk) ProtoMessage 

func (*QueueBindOk) ProtoMessage()

func (*QueueBindOk) Read 

func (f *QueueBindOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueBindOk) Reset 

func (m *QueueBindOk) Reset()

func (*QueueBindOk) Size 

func (m *QueueBindOk) Size() (n int)

func (*QueueBindOk) String 

func (m *QueueBindOk) String() string

func (*QueueBindOk) Unmarshal 

func (m *QueueBindOk) Unmarshal(dAtA []byte) error

func (*QueueBindOk) Write 

func (f *QueueBindOk) Write(writer io.Writer) (err error)

Writer

func (*QueueBindOk) XXX_DiscardUnknown 

func (m *QueueBindOk) XXX_DiscardUnknown()

func (*QueueBindOk) XXX_Marshal 

func (m *QueueBindOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueBindOk) XXX_Merge 

func (m *QueueBindOk) XXX_Merge(src proto.Message)

func (*QueueBindOk) XXX_Size 

func (m *QueueBindOk) XXX_Size() int

func (*QueueBindOk) XXX_Unmarshal 

func (m *QueueBindOk) XXX_Unmarshal(b []byte) error

type QueueDeclare 

type QueueDeclare struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	Passive              bool     `protobuf:"varint,3,opt,name=passive" json:"passive"`
	Durable              bool     `protobuf:"varint,4,opt,name=durable" json:"durable"`
	Exclusive            bool     `protobuf:"varint,5,opt,name=exclusive" json:"exclusive"`
	AutoDelete           bool     `protobuf:"varint,6,opt,name=auto_delete,json=autoDelete" json:"auto_delete"`
	NoWait               bool     `protobuf:"varint,7,opt,name=no_wait,json=noWait" json:"no_wait"`
	Arguments            *Table   `protobuf:"bytes,8,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueDeclare) Descriptor 

func (*QueueDeclare) Descriptor() ([]byte, []int)

func (*QueueDeclare) FrameType 

func (f *QueueDeclare) FrameType() byte

func (*QueueDeclare) Marshal 

func (m *QueueDeclare) Marshal() (dAtA []byte, err error)

func (*QueueDeclare) MarshalTo 

func (m *QueueDeclare) MarshalTo(dAtA []byte) (int, error)

func (*QueueDeclare) MethodIdentifier 

func (f *QueueDeclare) MethodIdentifier() (uint16, uint16)

func (*QueueDeclare) MethodName 

func (f *QueueDeclare) MethodName() string

func (*QueueDeclare) ProtoMessage 

func (*QueueDeclare) ProtoMessage()

func (*QueueDeclare) Read 

func (f *QueueDeclare) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueDeclare) Reset 

func (m *QueueDeclare) Reset()

func (*QueueDeclare) Size 

func (m *QueueDeclare) Size() (n int)

func (*QueueDeclare) String 

func (m *QueueDeclare) String() string

func (*QueueDeclare) Unmarshal 

func (m *QueueDeclare) Unmarshal(dAtA []byte) error

func (*QueueDeclare) Write 

func (f *QueueDeclare) Write(writer io.Writer) (err error)

Writer

func (*QueueDeclare) XXX_DiscardUnknown 

func (m *QueueDeclare) XXX_DiscardUnknown()

func (*QueueDeclare) XXX_Marshal 

func (m *QueueDeclare) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueDeclare) XXX_Merge 

func (m *QueueDeclare) XXX_Merge(src proto.Message)

func (*QueueDeclare) XXX_Size 

func (m *QueueDeclare) XXX_Size() int

func (*QueueDeclare) XXX_Unmarshal 

func (m *QueueDeclare) XXX_Unmarshal(b []byte) error

type QueueDeclareOk 

type QueueDeclareOk struct {
	Queue                string   `protobuf:"bytes,1,opt,name=queue" json:"queue"`
	MessageCount         uint32   `protobuf:"varint,2,opt,name=message_count,json=messageCount" json:"message_count"`
	ConsumerCount        uint32   `protobuf:"varint,3,opt,name=consumer_count,json=consumerCount" json:"consumer_count"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueDeclareOk) Descriptor 

func (*QueueDeclareOk) Descriptor() ([]byte, []int)

func (*QueueDeclareOk) FrameType 

func (f *QueueDeclareOk) FrameType() byte

func (*QueueDeclareOk) Marshal 

func (m *QueueDeclareOk) Marshal() (dAtA []byte, err error)

func (*QueueDeclareOk) MarshalTo 

func (m *QueueDeclareOk) MarshalTo(dAtA []byte) (int, error)

func (*QueueDeclareOk) MethodIdentifier 

func (f *QueueDeclareOk) MethodIdentifier() (uint16, uint16)

func (*QueueDeclareOk) MethodName 

func (f *QueueDeclareOk) MethodName() string

func (*QueueDeclareOk) ProtoMessage 

func (*QueueDeclareOk) ProtoMessage()

func (*QueueDeclareOk) Read 

func (f *QueueDeclareOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueDeclareOk) Reset 

func (m *QueueDeclareOk) Reset()

func (*QueueDeclareOk) Size 

func (m *QueueDeclareOk) Size() (n int)

func (*QueueDeclareOk) String 

func (m *QueueDeclareOk) String() string

func (*QueueDeclareOk) Unmarshal 

func (m *QueueDeclareOk) Unmarshal(dAtA []byte) error

func (*QueueDeclareOk) Write 

func (f *QueueDeclareOk) Write(writer io.Writer) (err error)

Writer

func (*QueueDeclareOk) XXX_DiscardUnknown 

func (m *QueueDeclareOk) XXX_DiscardUnknown()

func (*QueueDeclareOk) XXX_Marshal 

func (m *QueueDeclareOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueDeclareOk) XXX_Merge 

func (m *QueueDeclareOk) XXX_Merge(src proto.Message)

func (*QueueDeclareOk) XXX_Size 

func (m *QueueDeclareOk) XXX_Size() int

func (*QueueDeclareOk) XXX_Unmarshal 

func (m *QueueDeclareOk) XXX_Unmarshal(b []byte) error

type QueueDelete 

type QueueDelete struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	IfUnused             bool     `protobuf:"varint,3,opt,name=if_unused,json=ifUnused" json:"if_unused"`
	IfEmpty              bool     `protobuf:"varint,4,opt,name=if_empty,json=ifEmpty" json:"if_empty"`
	NoWait               bool     `protobuf:"varint,5,opt,name=no_wait,json=noWait" json:"no_wait"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueDelete) Descriptor 

func (*QueueDelete) Descriptor() ([]byte, []int)

func (*QueueDelete) FrameType 

func (f *QueueDelete) FrameType() byte

func (*QueueDelete) Marshal 

func (m *QueueDelete) Marshal() (dAtA []byte, err error)

func (*QueueDelete) MarshalTo 

func (m *QueueDelete) MarshalTo(dAtA []byte) (int, error)

func (*QueueDelete) MethodIdentifier 

func (f *QueueDelete) MethodIdentifier() (uint16, uint16)

func (*QueueDelete) MethodName 

func (f *QueueDelete) MethodName() string

func (*QueueDelete) ProtoMessage 

func (*QueueDelete) ProtoMessage()

func (*QueueDelete) Read 

func (f *QueueDelete) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueDelete) Reset 

func (m *QueueDelete) Reset()

func (*QueueDelete) Size 

func (m *QueueDelete) Size() (n int)

func (*QueueDelete) String 

func (m *QueueDelete) String() string

func (*QueueDelete) Unmarshal 

func (m *QueueDelete) Unmarshal(dAtA []byte) error

func (*QueueDelete) Write 

func (f *QueueDelete) Write(writer io.Writer) (err error)

Writer

func (*QueueDelete) XXX_DiscardUnknown 

func (m *QueueDelete) XXX_DiscardUnknown()

func (*QueueDelete) XXX_Marshal 

func (m *QueueDelete) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueDelete) XXX_Merge 

func (m *QueueDelete) XXX_Merge(src proto.Message)

func (*QueueDelete) XXX_Size 

func (m *QueueDelete) XXX_Size() int

func (*QueueDelete) XXX_Unmarshal 

func (m *QueueDelete) XXX_Unmarshal(b []byte) error

type QueueDeleteOk 

type QueueDeleteOk struct {
	MessageCount         uint32   `protobuf:"varint,1,opt,name=message_count,json=messageCount" json:"message_count"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueDeleteOk) Descriptor 

func (*QueueDeleteOk) Descriptor() ([]byte, []int)

func (*QueueDeleteOk) FrameType 

func (f *QueueDeleteOk) FrameType() byte

func (*QueueDeleteOk) Marshal 

func (m *QueueDeleteOk) Marshal() (dAtA []byte, err error)

func (*QueueDeleteOk) MarshalTo 

func (m *QueueDeleteOk) MarshalTo(dAtA []byte) (int, error)

func (*QueueDeleteOk) MethodIdentifier 

func (f *QueueDeleteOk) MethodIdentifier() (uint16, uint16)

func (*QueueDeleteOk) MethodName 

func (f *QueueDeleteOk) MethodName() string

func (*QueueDeleteOk) ProtoMessage 

func (*QueueDeleteOk) ProtoMessage()

func (*QueueDeleteOk) Read 

func (f *QueueDeleteOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueDeleteOk) Reset 

func (m *QueueDeleteOk) Reset()

func (*QueueDeleteOk) Size 

func (m *QueueDeleteOk) Size() (n int)

func (*QueueDeleteOk) String 

func (m *QueueDeleteOk) String() string

func (*QueueDeleteOk) Unmarshal 

func (m *QueueDeleteOk) Unmarshal(dAtA []byte) error

func (*QueueDeleteOk) Write 

func (f *QueueDeleteOk) Write(writer io.Writer) (err error)

Writer

func (*QueueDeleteOk) XXX_DiscardUnknown 

func (m *QueueDeleteOk) XXX_DiscardUnknown()

func (*QueueDeleteOk) XXX_Marshal 

func (m *QueueDeleteOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueDeleteOk) XXX_Merge 

func (m *QueueDeleteOk) XXX_Merge(src proto.Message)

func (*QueueDeleteOk) XXX_Size 

func (m *QueueDeleteOk) XXX_Size() int

func (*QueueDeleteOk) XXX_Unmarshal 

func (m *QueueDeleteOk) XXX_Unmarshal(b []byte) error

type QueueMessage 

type QueueMessage struct {
	Id                   int64    `protobuf:"varint,1,opt,name=id" json:"id"`
	DeliveryCount        int32    `protobuf:"varint,2,opt,name=deliveryCount" json:"deliveryCount"`
	Durable              bool     `protobuf:"varint,3,opt,name=durable" json:"durable"`
	MsgSize              uint32   `protobuf:"varint,4,opt,name=msgSize" json:"msgSize"`
	LocalId              int64    `protobuf:"varint,5,opt,name=localId" json:"localId"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func NewQueueMessage 

func NewQueueMessage(id int64, deliveryCount int32, durable bool, msgSize uint32, localId int64) *QueueMessage

func (*QueueMessage) Descriptor 

func (*QueueMessage) Descriptor() ([]byte, []int)

func (*QueueMessage) GetDeliveryCount 

func (m *QueueMessage) GetDeliveryCount() int32

func (*QueueMessage) GetDurable 

func (m *QueueMessage) GetDurable() bool

func (*QueueMessage) GetId 

func (m *QueueMessage) GetId() int64

func (*QueueMessage) GetLocalId 

func (m *QueueMessage) GetLocalId() int64

func (*QueueMessage) GetMsgSize 

func (m *QueueMessage) GetMsgSize() uint32

func (*QueueMessage) Marshal 

func (m *QueueMessage) Marshal() (dAtA []byte, err error)

func (*QueueMessage) MarshalTo 

func (m *QueueMessage) MarshalTo(dAtA []byte) (int, error)

func (*QueueMessage) ProtoMessage 

func (*QueueMessage) ProtoMessage()

func (*QueueMessage) Reset 

func (m *QueueMessage) Reset()

func (*QueueMessage) Size 

func (m *QueueMessage) Size() (n int)

func (*QueueMessage) String 

func (m *QueueMessage) String() string

func (*QueueMessage) Unmarshal 

func (m *QueueMessage) Unmarshal(dAtA []byte) error

func (*QueueMessage) XXX_DiscardUnknown 

func (m *QueueMessage) XXX_DiscardUnknown()

func (*QueueMessage) XXX_Marshal 

func (m *QueueMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueMessage) XXX_Merge 

func (m *QueueMessage) XXX_Merge(src proto.Message)

func (*QueueMessage) XXX_Size 

func (m *QueueMessage) XXX_Size() int

func (*QueueMessage) XXX_Unmarshal 

func (m *QueueMessage) XXX_Unmarshal(b []byte) error

type QueuePurge 

type QueuePurge struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	NoWait               bool     `protobuf:"varint,3,opt,name=no_wait,json=noWait" json:"no_wait"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueuePurge) Descriptor 

func (*QueuePurge) Descriptor() ([]byte, []int)

func (*QueuePurge) FrameType 

func (f *QueuePurge) FrameType() byte

func (*QueuePurge) Marshal 

func (m *QueuePurge) Marshal() (dAtA []byte, err error)

func (*QueuePurge) MarshalTo 

func (m *QueuePurge) MarshalTo(dAtA []byte) (int, error)

func (*QueuePurge) MethodIdentifier 

func (f *QueuePurge) MethodIdentifier() (uint16, uint16)

func (*QueuePurge) MethodName 

func (f *QueuePurge) MethodName() string

func (*QueuePurge) ProtoMessage 

func (*QueuePurge) ProtoMessage()

func (*QueuePurge) Read 

func (f *QueuePurge) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueuePurge) Reset 

func (m *QueuePurge) Reset()

func (*QueuePurge) Size 

func (m *QueuePurge) Size() (n int)

func (*QueuePurge) String 

func (m *QueuePurge) String() string

func (*QueuePurge) Unmarshal 

func (m *QueuePurge) Unmarshal(dAtA []byte) error

func (*QueuePurge) Write 

func (f *QueuePurge) Write(writer io.Writer) (err error)

Writer

func (*QueuePurge) XXX_DiscardUnknown 

func (m *QueuePurge) XXX_DiscardUnknown()

func (*QueuePurge) XXX_Marshal 

func (m *QueuePurge) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueuePurge) XXX_Merge 

func (m *QueuePurge) XXX_Merge(src proto.Message)

func (*QueuePurge) XXX_Size 

func (m *QueuePurge) XXX_Size() int

func (*QueuePurge) XXX_Unmarshal 

func (m *QueuePurge) XXX_Unmarshal(b []byte) error

type QueuePurgeOk 

type QueuePurgeOk struct {
	MessageCount         uint32   `protobuf:"varint,1,opt,name=message_count,json=messageCount" json:"message_count"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueuePurgeOk) Descriptor 

func (*QueuePurgeOk) Descriptor() ([]byte, []int)

func (*QueuePurgeOk) FrameType 

func (f *QueuePurgeOk) FrameType() byte

func (*QueuePurgeOk) Marshal 

func (m *QueuePurgeOk) Marshal() (dAtA []byte, err error)

func (*QueuePurgeOk) MarshalTo 

func (m *QueuePurgeOk) MarshalTo(dAtA []byte) (int, error)

func (*QueuePurgeOk) MethodIdentifier 

func (f *QueuePurgeOk) MethodIdentifier() (uint16, uint16)

func (*QueuePurgeOk) MethodName 

func (f *QueuePurgeOk) MethodName() string

func (*QueuePurgeOk) ProtoMessage 

func (*QueuePurgeOk) ProtoMessage()

func (*QueuePurgeOk) Read 

func (f *QueuePurgeOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueuePurgeOk) Reset 

func (m *QueuePurgeOk) Reset()

func (*QueuePurgeOk) Size 

func (m *QueuePurgeOk) Size() (n int)

func (*QueuePurgeOk) String 

func (m *QueuePurgeOk) String() string

func (*QueuePurgeOk) Unmarshal 

func (m *QueuePurgeOk) Unmarshal(dAtA []byte) error

func (*QueuePurgeOk) Write 

func (f *QueuePurgeOk) Write(writer io.Writer) (err error)

Writer

func (*QueuePurgeOk) XXX_DiscardUnknown 

func (m *QueuePurgeOk) XXX_DiscardUnknown()

func (*QueuePurgeOk) XXX_Marshal 

func (m *QueuePurgeOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueuePurgeOk) XXX_Merge 

func (m *QueuePurgeOk) XXX_Merge(src proto.Message)

func (*QueuePurgeOk) XXX_Size 

func (m *QueuePurgeOk) XXX_Size() int

func (*QueuePurgeOk) XXX_Unmarshal 

func (m *QueuePurgeOk) XXX_Unmarshal(b []byte) error

type QueueUnbind 

type QueueUnbind struct {
	Reserved1            uint16   `protobuf:"varint,1,opt,name=reserved1,casttype=uint16" json:"reserved1"`
	Queue                string   `protobuf:"bytes,2,opt,name=queue" json:"queue"`
	Exchange             string   `protobuf:"bytes,3,opt,name=exchange" json:"exchange"`
	RoutingKey           string   `protobuf:"bytes,4,opt,name=routing_key,json=routingKey" json:"routing_key"`
	Arguments            *Table   `protobuf:"bytes,5,opt,name=arguments" json:"arguments,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueUnbind) Descriptor 

func (*QueueUnbind) Descriptor() ([]byte, []int)

func (*QueueUnbind) FrameType 

func (f *QueueUnbind) FrameType() byte

func (*QueueUnbind) Marshal 

func (m *QueueUnbind) Marshal() (dAtA []byte, err error)

func (*QueueUnbind) MarshalTo 

func (m *QueueUnbind) MarshalTo(dAtA []byte) (int, error)

func (*QueueUnbind) MethodIdentifier 

func (f *QueueUnbind) MethodIdentifier() (uint16, uint16)

func (*QueueUnbind) MethodName 

func (f *QueueUnbind) MethodName() string

func (*QueueUnbind) ProtoMessage 

func (*QueueUnbind) ProtoMessage()

func (*QueueUnbind) Read 

func (f *QueueUnbind) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueUnbind) Reset 

func (m *QueueUnbind) Reset()

func (*QueueUnbind) Size 

func (m *QueueUnbind) Size() (n int)

func (*QueueUnbind) String 

func (m *QueueUnbind) String() string

func (*QueueUnbind) Unmarshal 

func (m *QueueUnbind) Unmarshal(dAtA []byte) error

func (*QueueUnbind) Write 

func (f *QueueUnbind) Write(writer io.Writer) (err error)

Writer

func (*QueueUnbind) XXX_DiscardUnknown 

func (m *QueueUnbind) XXX_DiscardUnknown()

func (*QueueUnbind) XXX_Marshal 

func (m *QueueUnbind) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueUnbind) XXX_Merge 

func (m *QueueUnbind) XXX_Merge(src proto.Message)

func (*QueueUnbind) XXX_Size 

func (m *QueueUnbind) XXX_Size() int

func (*QueueUnbind) XXX_Unmarshal 

func (m *QueueUnbind) XXX_Unmarshal(b []byte) error

type QueueUnbindOk 

type QueueUnbindOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*QueueUnbindOk) Descriptor 

func (*QueueUnbindOk) Descriptor() ([]byte, []int)

func (*QueueUnbindOk) FrameType 

func (f *QueueUnbindOk) FrameType() byte

func (*QueueUnbindOk) Marshal 

func (m *QueueUnbindOk) Marshal() (dAtA []byte, err error)

func (*QueueUnbindOk) MarshalTo 

func (m *QueueUnbindOk) MarshalTo(dAtA []byte) (int, error)

func (*QueueUnbindOk) MethodIdentifier 

func (f *QueueUnbindOk) MethodIdentifier() (uint16, uint16)

func (*QueueUnbindOk) MethodName 

func (f *QueueUnbindOk) MethodName() string

func (*QueueUnbindOk) ProtoMessage 

func (*QueueUnbindOk) ProtoMessage()

func (*QueueUnbindOk) Read 

func (f *QueueUnbindOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*QueueUnbindOk) Reset 

func (m *QueueUnbindOk) Reset()

func (*QueueUnbindOk) Size 

func (m *QueueUnbindOk) Size() (n int)

func (*QueueUnbindOk) String 

func (m *QueueUnbindOk) String() string

func (*QueueUnbindOk) Unmarshal 

func (m *QueueUnbindOk) Unmarshal(dAtA []byte) error

func (*QueueUnbindOk) Write 

func (f *QueueUnbindOk) Write(writer io.Writer) (err error)

Writer

func (*QueueUnbindOk) XXX_DiscardUnknown 

func (m *QueueUnbindOk) XXX_DiscardUnknown()

func (*QueueUnbindOk) XXX_Marshal 

func (m *QueueUnbindOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*QueueUnbindOk) XXX_Merge 

func (m *QueueUnbindOk) XXX_Merge(src proto.Message)

func (*QueueUnbindOk) XXX_Size 

func (m *QueueUnbindOk) XXX_Size() int

func (*QueueUnbindOk) XXX_Unmarshal 

func (m *QueueUnbindOk) XXX_Unmarshal(b []byte) error

type Table 

type Table struct {
	Table                []*FieldValuePair `protobuf:"bytes,1,rep,name=table" json:"table,omitempty"`
	XXX_NoUnkeyedLiteral struct{}          `json:"-"`
	XXX_sizecache        int32             `json:"-"`
}

func NewTable 

func NewTable() *Table

func ReadTable 

func ReadTable(reader io.Reader, strictMode bool) (*Table, error)

func (*Table) Descriptor 

func (*Table) Descriptor() ([]byte, []int)

func (*Table) GetKey 

func (table *Table) GetKey(key string) *FieldValue

func (*Table) Marshal 

func (m *Table) Marshal() (dAtA []byte, err error)

func (*Table) MarshalTo 

func (m *Table) MarshalTo(dAtA []byte) (int, error)

func (*Table) ProtoMessage 

func (*Table) ProtoMessage()

func (*Table) Reset 

func (m *Table) Reset()

func (*Table) SetKey 

func (table *Table) SetKey(key string, value interface{}) error

func (*Table) Size 

func (m *Table) Size() (n int)

func (*Table) String 

func (m *Table) String() string

func (*Table) Unmarshal 

func (m *Table) Unmarshal(dAtA []byte) error

func (*Table) XXX_DiscardUnknown 

func (m *Table) XXX_DiscardUnknown()

func (*Table) XXX_Marshal 

func (m *Table) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*Table) XXX_Merge 

func (m *Table) XXX_Merge(src proto.Message)

func (*Table) XXX_Size 

func (m *Table) XXX_Size() int

func (*Table) XXX_Unmarshal 

func (m *Table) XXX_Unmarshal(b []byte) error

type TxAck 

type TxAck struct {
	Tag                  uint64   `protobuf:"varint,1,opt,name=tag" json:"tag"`
	Multiple             bool     `protobuf:"varint,2,opt,name=multiple" json:"multiple"`
	Nack                 bool     `protobuf:"varint,3,opt,name=nack" json:"nack"`
	RequeueNack          bool     `protobuf:"varint,4,opt,name=requeue_nack,json=requeueNack" json:"requeue_nack"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func NewTxAck 

func NewTxAck(tag uint64, nack bool, requeueNack bool, multiple bool) *TxAck

func (*TxAck) Descriptor 

func (*TxAck) Descriptor() ([]byte, []int)

func (*TxAck) GetMultiple 

func (m *TxAck) GetMultiple() bool

func (*TxAck) GetNack 

func (m *TxAck) GetNack() bool

func (*TxAck) GetRequeueNack 

func (m *TxAck) GetRequeueNack() bool

func (*TxAck) GetTag 

func (m *TxAck) GetTag() uint64

func (*TxAck) Marshal 

func (m *TxAck) Marshal() (dAtA []byte, err error)

func (*TxAck) MarshalTo 

func (m *TxAck) MarshalTo(dAtA []byte) (int, error)

func (*TxAck) ProtoMessage 

func (*TxAck) ProtoMessage()

func (*TxAck) Reset 

func (m *TxAck) Reset()

func (*TxAck) Size 

func (m *TxAck) Size() (n int)

func (*TxAck) String 

func (m *TxAck) String() string

func (*TxAck) Unmarshal 

func (m *TxAck) Unmarshal(dAtA []byte) error

func (*TxAck) XXX_DiscardUnknown 

func (m *TxAck) XXX_DiscardUnknown()

func (*TxAck) XXX_Marshal 

func (m *TxAck) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxAck) XXX_Merge 

func (m *TxAck) XXX_Merge(src proto.Message)

func (*TxAck) XXX_Size 

func (m *TxAck) XXX_Size() int

func (*TxAck) XXX_Unmarshal 

func (m *TxAck) XXX_Unmarshal(b []byte) error

type TxCommit 

type TxCommit struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxCommit) Descriptor 

func (*TxCommit) Descriptor() ([]byte, []int)

func (*TxCommit) FrameType 

func (f *TxCommit) FrameType() byte

func (*TxCommit) Marshal 

func (m *TxCommit) Marshal() (dAtA []byte, err error)

func (*TxCommit) MarshalTo 

func (m *TxCommit) MarshalTo(dAtA []byte) (int, error)

func (*TxCommit) MethodIdentifier 

func (f *TxCommit) MethodIdentifier() (uint16, uint16)

func (*TxCommit) MethodName 

func (f *TxCommit) MethodName() string

func (*TxCommit) ProtoMessage 

func (*TxCommit) ProtoMessage()

func (*TxCommit) Read 

func (f *TxCommit) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxCommit) Reset 

func (m *TxCommit) Reset()

func (*TxCommit) Size 

func (m *TxCommit) Size() (n int)

func (*TxCommit) String 

func (m *TxCommit) String() string

func (*TxCommit) Unmarshal 

func (m *TxCommit) Unmarshal(dAtA []byte) error

func (*TxCommit) Write 

func (f *TxCommit) Write(writer io.Writer) (err error)

Writer

func (*TxCommit) XXX_DiscardUnknown 

func (m *TxCommit) XXX_DiscardUnknown()

func (*TxCommit) XXX_Marshal 

func (m *TxCommit) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxCommit) XXX_Merge 

func (m *TxCommit) XXX_Merge(src proto.Message)

func (*TxCommit) XXX_Size 

func (m *TxCommit) XXX_Size() int

func (*TxCommit) XXX_Unmarshal 

func (m *TxCommit) XXX_Unmarshal(b []byte) error

type TxCommitOk 

type TxCommitOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxCommitOk) Descriptor 

func (*TxCommitOk) Descriptor() ([]byte, []int)

func (*TxCommitOk) FrameType 

func (f *TxCommitOk) FrameType() byte

func (*TxCommitOk) Marshal 

func (m *TxCommitOk) Marshal() (dAtA []byte, err error)

func (*TxCommitOk) MarshalTo 

func (m *TxCommitOk) MarshalTo(dAtA []byte) (int, error)

func (*TxCommitOk) MethodIdentifier 

func (f *TxCommitOk) MethodIdentifier() (uint16, uint16)

func (*TxCommitOk) MethodName 

func (f *TxCommitOk) MethodName() string

func (*TxCommitOk) ProtoMessage 

func (*TxCommitOk) ProtoMessage()

func (*TxCommitOk) Read 

func (f *TxCommitOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxCommitOk) Reset 

func (m *TxCommitOk) Reset()

func (*TxCommitOk) Size 

func (m *TxCommitOk) Size() (n int)

func (*TxCommitOk) String 

func (m *TxCommitOk) String() string

func (*TxCommitOk) Unmarshal 

func (m *TxCommitOk) Unmarshal(dAtA []byte) error

func (*TxCommitOk) Write 

func (f *TxCommitOk) Write(writer io.Writer) (err error)

Writer

func (*TxCommitOk) XXX_DiscardUnknown 

func (m *TxCommitOk) XXX_DiscardUnknown()

func (*TxCommitOk) XXX_Marshal 

func (m *TxCommitOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxCommitOk) XXX_Merge 

func (m *TxCommitOk) XXX_Merge(src proto.Message)

func (*TxCommitOk) XXX_Size 

func (m *TxCommitOk) XXX_Size() int

func (*TxCommitOk) XXX_Unmarshal 

func (m *TxCommitOk) XXX_Unmarshal(b []byte) error

type TxMessage 

type TxMessage struct {
	Msg                  *Message `protobuf:"bytes,1,opt,name=msg" json:"msg,omitempty"`
	QueueName            string   `protobuf:"bytes,2,opt,name=queue_name,json=queueName" json:"queue_name"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_unrecognized     []byte   `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func NewTxMessage 

func NewTxMessage(msg *Message, queueName string) *TxMessage

func (*TxMessage) Descriptor 

func (*TxMessage) Descriptor() ([]byte, []int)

func (*TxMessage) GetMsg 

func (m *TxMessage) GetMsg() *Message

func (*TxMessage) GetQueueName 

func (m *TxMessage) GetQueueName() string

func (*TxMessage) Marshal 

func (m *TxMessage) Marshal() (dAtA []byte, err error)

func (*TxMessage) MarshalTo 

func (m *TxMessage) MarshalTo(dAtA []byte) (int, error)

func (*TxMessage) ProtoMessage 

func (*TxMessage) ProtoMessage()

func (*TxMessage) Reset 

func (m *TxMessage) Reset()

func (*TxMessage) Size 

func (m *TxMessage) Size() (n int)

func (*TxMessage) String 

func (m *TxMessage) String() string

func (*TxMessage) Unmarshal 

func (m *TxMessage) Unmarshal(dAtA []byte) error

func (*TxMessage) XXX_DiscardUnknown 

func (m *TxMessage) XXX_DiscardUnknown()

func (*TxMessage) XXX_Marshal 

func (m *TxMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxMessage) XXX_Merge 

func (m *TxMessage) XXX_Merge(src proto.Message)

func (*TxMessage) XXX_Size 

func (m *TxMessage) XXX_Size() int

func (*TxMessage) XXX_Unmarshal 

func (m *TxMessage) XXX_Unmarshal(b []byte) error

type TxRollback 

type TxRollback struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxRollback) Descriptor 

func (*TxRollback) Descriptor() ([]byte, []int)

func (*TxRollback) FrameType 

func (f *TxRollback) FrameType() byte

func (*TxRollback) Marshal 

func (m *TxRollback) Marshal() (dAtA []byte, err error)

func (*TxRollback) MarshalTo 

func (m *TxRollback) MarshalTo(dAtA []byte) (int, error)

func (*TxRollback) MethodIdentifier 

func (f *TxRollback) MethodIdentifier() (uint16, uint16)

func (*TxRollback) MethodName 

func (f *TxRollback) MethodName() string

func (*TxRollback) ProtoMessage 

func (*TxRollback) ProtoMessage()

func (*TxRollback) Read 

func (f *TxRollback) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxRollback) Reset 

func (m *TxRollback) Reset()

func (*TxRollback) Size 

func (m *TxRollback) Size() (n int)

func (*TxRollback) String 

func (m *TxRollback) String() string

func (*TxRollback) Unmarshal 

func (m *TxRollback) Unmarshal(dAtA []byte) error

func (*TxRollback) Write 

func (f *TxRollback) Write(writer io.Writer) (err error)

Writer

func (*TxRollback) XXX_DiscardUnknown 

func (m *TxRollback) XXX_DiscardUnknown()

func (*TxRollback) XXX_Marshal 

func (m *TxRollback) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxRollback) XXX_Merge 

func (m *TxRollback) XXX_Merge(src proto.Message)

func (*TxRollback) XXX_Size 

func (m *TxRollback) XXX_Size() int

func (*TxRollback) XXX_Unmarshal 

func (m *TxRollback) XXX_Unmarshal(b []byte) error

type TxRollbackOk 

type TxRollbackOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxRollbackOk) Descriptor 

func (*TxRollbackOk) Descriptor() ([]byte, []int)

func (*TxRollbackOk) FrameType 

func (f *TxRollbackOk) FrameType() byte

func (*TxRollbackOk) Marshal 

func (m *TxRollbackOk) Marshal() (dAtA []byte, err error)

func (*TxRollbackOk) MarshalTo 

func (m *TxRollbackOk) MarshalTo(dAtA []byte) (int, error)

func (*TxRollbackOk) MethodIdentifier 

func (f *TxRollbackOk) MethodIdentifier() (uint16, uint16)

func (*TxRollbackOk) MethodName 

func (f *TxRollbackOk) MethodName() string

func (*TxRollbackOk) ProtoMessage 

func (*TxRollbackOk) ProtoMessage()

func (*TxRollbackOk) Read 

func (f *TxRollbackOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxRollbackOk) Reset 

func (m *TxRollbackOk) Reset()

func (*TxRollbackOk) Size 

func (m *TxRollbackOk) Size() (n int)

func (*TxRollbackOk) String 

func (m *TxRollbackOk) String() string

func (*TxRollbackOk) Unmarshal 

func (m *TxRollbackOk) Unmarshal(dAtA []byte) error

func (*TxRollbackOk) Write 

func (f *TxRollbackOk) Write(writer io.Writer) (err error)

Writer

func (*TxRollbackOk) XXX_DiscardUnknown 

func (m *TxRollbackOk) XXX_DiscardUnknown()

func (*TxRollbackOk) XXX_Marshal 

func (m *TxRollbackOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxRollbackOk) XXX_Merge 

func (m *TxRollbackOk) XXX_Merge(src proto.Message)

func (*TxRollbackOk) XXX_Size 

func (m *TxRollbackOk) XXX_Size() int

func (*TxRollbackOk) XXX_Unmarshal 

func (m *TxRollbackOk) XXX_Unmarshal(b []byte) error

type TxSelect 

type TxSelect struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxSelect) Descriptor 

func (*TxSelect) Descriptor() ([]byte, []int)

func (*TxSelect) FrameType 

func (f *TxSelect) FrameType() byte

func (*TxSelect) Marshal 

func (m *TxSelect) Marshal() (dAtA []byte, err error)

func (*TxSelect) MarshalTo 

func (m *TxSelect) MarshalTo(dAtA []byte) (int, error)

func (*TxSelect) MethodIdentifier 

func (f *TxSelect) MethodIdentifier() (uint16, uint16)

func (*TxSelect) MethodName 

func (f *TxSelect) MethodName() string

func (*TxSelect) ProtoMessage 

func (*TxSelect) ProtoMessage()

func (*TxSelect) Read 

func (f *TxSelect) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxSelect) Reset 

func (m *TxSelect) Reset()

func (*TxSelect) Size 

func (m *TxSelect) Size() (n int)

func (*TxSelect) String 

func (m *TxSelect) String() string

func (*TxSelect) Unmarshal 

func (m *TxSelect) Unmarshal(dAtA []byte) error

func (*TxSelect) Write 

func (f *TxSelect) Write(writer io.Writer) (err error)

Writer

func (*TxSelect) XXX_DiscardUnknown 

func (m *TxSelect) XXX_DiscardUnknown()

func (*TxSelect) XXX_Marshal 

func (m *TxSelect) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxSelect) XXX_Merge 

func (m *TxSelect) XXX_Merge(src proto.Message)

func (*TxSelect) XXX_Size 

func (m *TxSelect) XXX_Size() int

func (*TxSelect) XXX_Unmarshal 

func (m *TxSelect) XXX_Unmarshal(b []byte) error

type TxSelectOk 

type TxSelectOk struct {
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func (*TxSelectOk) Descriptor 

func (*TxSelectOk) Descriptor() ([]byte, []int)

func (*TxSelectOk) FrameType 

func (f *TxSelectOk) FrameType() byte

func (*TxSelectOk) Marshal 

func (m *TxSelectOk) Marshal() (dAtA []byte, err error)

func (*TxSelectOk) MarshalTo 

func (m *TxSelectOk) MarshalTo(dAtA []byte) (int, error)

func (*TxSelectOk) MethodIdentifier 

func (f *TxSelectOk) MethodIdentifier() (uint16, uint16)

func (*TxSelectOk) MethodName 

func (f *TxSelectOk) MethodName() string

func (*TxSelectOk) ProtoMessage 

func (*TxSelectOk) ProtoMessage()

func (*TxSelectOk) Read 

func (f *TxSelectOk) Read(reader io.Reader, strictMode bool) (err error)

Reader

func (*TxSelectOk) Reset 

func (m *TxSelectOk) Reset()

func (*TxSelectOk) Size 

func (m *TxSelectOk) Size() (n int)

func (*TxSelectOk) String 

func (m *TxSelectOk) String() string

func (*TxSelectOk) Unmarshal 

func (m *TxSelectOk) Unmarshal(dAtA []byte) error

func (*TxSelectOk) Write 

func (f *TxSelectOk) Write(writer io.Writer) (err error)

Writer

func (*TxSelectOk) XXX_DiscardUnknown 

func (m *TxSelectOk) XXX_DiscardUnknown()

func (*TxSelectOk) XXX_Marshal 

func (m *TxSelectOk) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*TxSelectOk) XXX_Merge 

func (m *TxSelectOk) XXX_Merge(src proto.Message)

func (*TxSelectOk) XXX_Size 

func (m *TxSelectOk) XXX_Size() int

func (*TxSelectOk) XXX_Unmarshal 

func (m *TxSelectOk) XXX_Unmarshal(b []byte) error

type UnackedMessage 

type UnackedMessage struct {
	ConsumerTag          string        `protobuf:"bytes,1,opt,name=consumer_tag,json=consumerTag" json:"consumer_tag"`
	Msg                  *QueueMessage `protobuf:"bytes,2,opt,name=msg" json:"msg,omitempty"`
	QueueName            string        `protobuf:"bytes,3,opt,name=queue_name,json=queueName" json:"queue_name"`
	XXX_NoUnkeyedLiteral struct{}      `json:"-"`
	XXX_unrecognized     []byte        `json:"-"`
	XXX_sizecache        int32         `json:"-"`
}

func NewUnackedMessage 

func NewUnackedMessage(tag string, qm *QueueMessage, queueName string) *UnackedMessage

func (*UnackedMessage) Descriptor 

func (*UnackedMessage) Descriptor() ([]byte, []int)

func (*UnackedMessage) GetConsumerTag 

func (m *UnackedMessage) GetConsumerTag() string

func (*UnackedMessage) GetMsg 

func (m *UnackedMessage) GetMsg() *QueueMessage

func (*UnackedMessage) GetQueueName 

func (m *UnackedMessage) GetQueueName() string

func (*UnackedMessage) Marshal 

func (m *UnackedMessage) Marshal() (dAtA []byte, err error)

func (*UnackedMessage) MarshalTo 

func (m *UnackedMessage) MarshalTo(dAtA []byte) (int, error)

func (*UnackedMessage) ProtoMessage 

func (*UnackedMessage) ProtoMessage()

func (*UnackedMessage) Reset 

func (m *UnackedMessage) Reset()

func (*UnackedMessage) Size 

func (m *UnackedMessage) Size() (n int)

func (*UnackedMessage) String 

func (m *UnackedMessage) String() string

func (*UnackedMessage) Unmarshal 

func (m *UnackedMessage) Unmarshal(dAtA []byte) error

func (*UnackedMessage) XXX_DiscardUnknown 

func (m *UnackedMessage) XXX_DiscardUnknown()

func (*UnackedMessage) XXX_Marshal 

func (m *UnackedMessage) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*UnackedMessage) XXX_Merge 

func (m *UnackedMessage) XXX_Merge(src proto.Message)

func (*UnackedMessage) XXX_Size 

func (m *UnackedMessage) XXX_Size() int

func (*UnackedMessage) XXX_Unmarshal 

func (m *UnackedMessage) XXX_Unmarshal(b []byte) error

type WireFrame 

type WireFrame struct {
	FrameType            uint8    `protobuf:"varint,1,opt,name=frameType,casttype=uint8" json:"frameType"`
	Channel              uint16   `protobuf:"varint,2,opt,name=channel,casttype=uint16" json:"channel"`
	Payload              []byte   `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
	XXX_NoUnkeyedLiteral struct{} `json:"-"`
	XXX_sizecache        int32    `json:"-"`
}

func NewTruncatedBodyFrame 

func NewTruncatedBodyFrame(channel uint16) WireFrame

func RandomPayload 

func RandomPayload() (uint64, []*WireFrame)

func ReadFrame 

func ReadFrame(reader io.Reader) (*WireFrame, error)

func (*WireFrame) Descriptor 

func (*WireFrame) Descriptor() ([]byte, []int)

func (*WireFrame) Marshal 

func (m *WireFrame) Marshal() (dAtA []byte, err error)

func (*WireFrame) MarshalTo 

func (m *WireFrame) MarshalTo(dAtA []byte) (int, error)

func (*WireFrame) ProtoMessage 

func (*WireFrame) ProtoMessage()

func (*WireFrame) Reset 

func (m *WireFrame) Reset()

func (*WireFrame) Size 

func (m *WireFrame) Size() (n int)

func (*WireFrame) String 

func (m *WireFrame) String() string

func (*WireFrame) Unmarshal 

func (m *WireFrame) Unmarshal(dAtA []byte) error

func (*WireFrame) XXX_DiscardUnknown 

func (m *WireFrame) XXX_DiscardUnknown()

func (*WireFrame) XXX_Marshal 

func (m *WireFrame) XXX_Marshal(b []byte, deterministic bool) ([]byte, error)

func (*WireFrame) XXX_Merge 

func (m *WireFrame) XXX_Merge(src proto.Message)

func (*WireFrame) XXX_Size 

func (m *WireFrame) XXX_Size() int

func (*WireFrame) XXX_Unmarshal 

func (m *WireFrame) XXX_Unmarshal(b []byte) error

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.