# encoding: binary

# THIS IS AN AUTOGENERATED FILE, DO NOT MODIFY
# IT DIRECTLY ! FOR CHANGES, PLEASE UPDATE CODEGEN.PY
# IN THE ROOT DIRECTORY OF THE AMQ-PROTOCOL REPOSITORY.

require "amq/protocol/table"
require "amq/protocol/frame"
require "amq/hacks"

module AMQ
  module Protocol
    PROTOCOL_VERSION = "0.9.1".freeze
    PREAMBLE         = "AMQP\x00\x00\x09\x01".freeze
    DEFAULT_PORT     = 5672

    # caching
    EMPTY_STRING = "".freeze

    PACK_CHAR               = "C".freeze
    PACK_UINT16             = "n".freeze
    PACK_UINT16_X2          = "n2".freeze
    PACK_UINT32             = "N".freeze
    PACK_UINT32_X2          = "N2".freeze
    PACK_INT64              = "q".freeze
    PACK_UCHAR_UINT32       = "CN".freeze
    PACK_CHAR_UINT16_UINT32 = "cnN".freeze

    # @version 0.0.1
    # @return [Array] Collection of subclasses of AMQ::Protocol::Class.
    def self.classes
      Protocol::Class.classes
    end

    # @version 0.0.1
    # @return [Array] Collection of subclasses of AMQ::Protocol::Method.
    def self.methods
      Protocol::Method.methods
    end

    class Error < StandardError
      DEFAULT_MESSAGE = "AMQP error".freeze

      def self.inherited(subclass)
        @_subclasses ||= []
        @_subclasses << subclass
      end # self.inherited(subclazz)

      def self.subclasses_with_values
        @_subclasses.select{ |k| defined?(k::VALUE) }
      end # self.subclasses_with_values

      def self.[](code) # TODO: rewrite more effectively
        if result = subclasses_with_values.detect { |klass| klass::VALUE == code }
          result
        else
          raise "No such exception class for code #{code}" unless result
        end # if
      end # self.[]

      def initialize(message = self.class::DEFAULT_MESSAGE)
        super(message)
      end
    end

    class FrameTypeError < Protocol::Error
      def initialize(types)
        super("Must be one of #{types.inspect}")
      end
    end

    class EmptyResponseError < Protocol::Error
      DEFAULT_MESSAGE = "Empty response received from the server."

      def initialize(message = self.class::DEFAULT_MESSAGE)
        super(message)
      end
    end

    class BadResponseError < Protocol::Error
      def initialize(argument, expected, actual)
        super("Argument #{argument} has to be #{expected.inspect}, was #{data.inspect}")
      end
    end

    class SoftError < Protocol::Error
      def self.inherited(subclass)
        Error.inherited(subclass)
      end # self.inherited(subclass)
    end

    class HardError < Protocol::Error
      def self.inherited(subclass)
        Error.inherited(subclass)
      end # self.inherited(subclass)
    end

    class ContentTooLarge < SoftError
      VALUE = 311
    end

    class NoRoute < SoftError
      VALUE = 312
    end

    class NoConsumers < SoftError
      VALUE = 313
    end

    class AccessRefused < SoftError
      VALUE = 403
    end

    class NotFound < SoftError
      VALUE = 404
    end

    class ResourceLocked < SoftError
      VALUE = 405
    end

    class PreconditionFailed < SoftError
      VALUE = 406
    end

    class ConnectionForced < HardError
      VALUE = 320
    end

    class InvalidPath < HardError
      VALUE = 402
    end

    class FrameError < HardError
      VALUE = 501
    end

    class SyntaxError < HardError
      VALUE = 502
    end

    class CommandInvalid < HardError
      VALUE = 503
    end

    class ChannelError < HardError
      VALUE = 504
    end

    class UnexpectedFrame < HardError
      VALUE = 505
    end

    class ResourceError < HardError
      VALUE = 506
    end

    class NotAllowed < HardError
      VALUE = 530
    end

    class NotImplemented < HardError
      VALUE = 540
    end

    class InternalError < HardError
      VALUE = 541
    end

    # We don"t instantiate the following classes,
    # as we don"t actually need any per-instance state.
    # Also, this is pretty low-level functionality,
    # hence it should have a reasonable performance.
    # As everyone knows, garbage collector in MRI performs
    # really badly, which is another good reason for
    # not creating any objects, but only use class as
    # a struct. Creating classes is quite expensive though,
    # but here the inheritance comes handy and mainly
    # as we can"t simply make a reference to a function,
    # we can"t use a hash or an object. I"ve been also
    # considering to have just a bunch of methods, but
    # here"s the problem, that after we"d require this file,
    # all these methods would become global which would
    # be a bad, bad thing to do.
    class Class
      @classes = Array.new

      def self.method_id
        @method_id
      end

      def self.name
        @name
      end

      def self.inherited(base)
        if self == Protocol::Class
          @classes << base
        end
      end

      def self.classes
        @classes
      end
    end

    class Method
      @methods = Array.new
      def self.method_id
        @method_id
      end

      def self.name
        @name
      end

      def self.index
        @index
      end

      def self.inherited(base)
        if self == Protocol::Method
          @methods << base
        end
      end

      def self.methods
        @methods
      end

      def self.split_headers(user_headers)
        properties, headers = {}, {}
        user_headers.each do |key, value|
          # key MUST be a symbol since symbols are not garbage-collected
          if Basic::PROPERTIES.include?(key)
            properties[key] = value
          else
            headers[key] = value
          end
        end

        return [properties, headers]
      end

      def self.encode_body(body, channel, frame_size)
        # Spec is broken: Our errata says that it does define
        # something, but it just doesn"t relate do method and
        # properties frames. Which makes it, well, suboptimal.
        # https://dev.rabbitmq.com/wiki/Amqp091Errata#section_11
        limit = frame_size - 7 - 1

        Array.new.tap do |array|
          while body
            payload, body = body[0, limit + 1], body[limit + 1, body.length - limit]
            # array << [0x03, payload]
            array << BodyFrame.new(payload, channel)
          end
        end
      end

      # We can return different:
      # - instantiate given subclass of Method
      # - create an OpenStruct object
      # - create a hash
      # - yield params into the block rather than just return
      # @api plugin
      def self.instantiate(*args, &block)
        self.new(*args, &block)
        # or OpenStruct.new(args.first)
        # or args.first
        # or block.call(*args)
      end
    end

    class Connection < Protocol::Class
      @name = "connection"
      @method_id = 10

      class Start < Protocol::Method
        @name = "connection.start"
        @method_id = 10
        @index = 0x000A000A # 10, 10, 655370
        @packed_indexes = [10, 10].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          version_major = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          version_minor = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          table_length = Table.length(data[offset, 4])
          server_properties = Table.decode(data[offset, table_length + 4])
          offset += table_length + 4
          length = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          mechanisms = data[offset, length]
          offset += length
          length = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          locales = data[offset, length]
          offset += length
          self.new(version_major, version_minor, server_properties, mechanisms, locales)
        end

        attr_reader :version_major, :version_minor, :server_properties, :mechanisms, :locales
        def initialize(version_major, version_minor, server_properties, mechanisms, locales)
          @version_major = version_major
          @version_minor = version_minor
          @server_properties = server_properties
          @mechanisms = mechanisms
          @locales = locales
        end

        def self.has_content?
          false
        end
      end

      class StartOk < Protocol::Method
        @name = "connection.start-ok"
        @method_id = 11
        @index = 0x000A000B # 10, 11, 655371
        @packed_indexes = [10, 11].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["client_properties = nil", "mechanism = "PLAIN"", "response = nil", "locale = "en_US""]
        def self.encode(client_properties, mechanism, response, locale)
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << AMQ::Protocol::Table.encode(client_properties)
          buffer << mechanism.bytesize.chr
          buffer << mechanism
          buffer << [response.bytesize].pack(PACK_UINT32)
          buffer << response
          buffer << locale.bytesize.chr
          buffer << locale
          MethodFrame.new(buffer, channel)
        end
      end

      class Secure < Protocol::Method
        @name = "connection.secure"
        @method_id = 20
        @index = 0x000A0014 # 10, 20, 655380
        @packed_indexes = [10, 20].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          challenge = data[offset, length]
          offset += length
          self.new(challenge)
        end

        attr_reader :challenge
        def initialize(challenge)
          @challenge = challenge
        end

        def self.has_content?
          false
        end
      end

      class SecureOk < Protocol::Method
        @name = "connection.secure-ok"
        @method_id = 21
        @index = 0x000A0015 # 10, 21, 655381
        @packed_indexes = [10, 21].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["response = nil"]
        def self.encode(response)
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [response.bytesize].pack(PACK_UINT32)
          buffer << response
          MethodFrame.new(buffer, channel)
        end
      end

      class Tune < Protocol::Method
        @name = "connection.tune"
        @method_id = 30
        @index = 0x000A001E # 10, 30, 655390
        @packed_indexes = [10, 30].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          channel_max = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          frame_max = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          heartbeat = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          self.new(channel_max, frame_max, heartbeat)
        end

        attr_reader :channel_max, :frame_max, :heartbeat
        def initialize(channel_max, frame_max, heartbeat)
          @channel_max = channel_max
          @frame_max = frame_max
          @heartbeat = heartbeat
        end

        def self.has_content?
          false
        end
      end

      class TuneOk < Protocol::Method
        @name = "connection.tune-ok"
        @method_id = 31
        @index = 0x000A001F # 10, 31, 655391
        @packed_indexes = [10, 31].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["channel_max = false", "frame_max = false", "heartbeat = false"]
        def self.encode(channel_max, frame_max, heartbeat)
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [channel_max].pack(PACK_UINT16)
          buffer << [frame_max].pack(PACK_UINT32)
          buffer << [heartbeat].pack(PACK_UINT16)
          MethodFrame.new(buffer, channel)
        end
      end

      class Open < Protocol::Method
        @name = "connection.open"
        @method_id = 40
        @index = 0x000A0028 # 10, 40, 655400
        @packed_indexes = [10, 40].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["virtual_host = "/"", "capabilities = EMPTY_STRING", "insist = false"]
        def self.encode(virtual_host)
          capabilities = EMPTY_STRING
          insist = false
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << virtual_host.bytesize.chr
          buffer << virtual_host
          buffer << capabilities.bytesize.chr
          buffer << capabilities
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if insist
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class OpenOk < Protocol::Method
        @name = "connection.open-ok"
        @method_id = 41
        @index = 0x000A0029 # 10, 41, 655401
        @packed_indexes = [10, 41].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          known_hosts = data[offset, length]
          offset += length
          self.new(known_hosts)
        end

        attr_reader :known_hosts
        def initialize(known_hosts)
          @known_hosts = known_hosts
        end

        def self.has_content?
          false
        end
      end

      class Close < Protocol::Method
        @name = "connection.close"
        @method_id = 50
        @index = 0x000A0032 # 10, 50, 655410
        @packed_indexes = [10, 50].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          reply_code = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          reply_text = data[offset, length]
          offset += length
          class_id = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          method_id = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          self.new(reply_code, reply_text, class_id, method_id)
        end

        attr_reader :reply_code, :reply_text, :class_id, :method_id
        def initialize(reply_code, reply_text, class_id, method_id)
          @reply_code = reply_code
          @reply_text = reply_text
          @class_id = class_id
          @method_id = method_id
        end

        def self.has_content?
          false
        end

        # @return
        # ["reply_code = nil", "reply_text = EMPTY_STRING", "class_id = nil", "method_id = nil"]
        def self.encode(reply_code, reply_text, class_id, method_id)
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [reply_code].pack(PACK_UINT16)
          buffer << reply_text.bytesize.chr
          buffer << reply_text
          buffer << [class_id].pack(PACK_UINT16)
          buffer << [method_id].pack(PACK_UINT16)
          MethodFrame.new(buffer, channel)
        end
      end

      class CloseOk < Protocol::Method
        @name = "connection.close-ok"
        @method_id = 51
        @index = 0x000A0033 # 10, 51, 655411
        @packed_indexes = [10, 51].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode()
          channel = 0
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end
    end

    class Channel < Protocol::Class
      @name = "channel"
      @method_id = 20

      class Open < Protocol::Method
        @name = "channel.open"
        @method_id = 10
        @index = 0x0014000A # 20, 10, 1310730
        @packed_indexes = [20, 10].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["out_of_band = EMPTY_STRING"]
        def self.encode(channel, out_of_band)
          buffer = ""
          buffer << @packed_indexes
          buffer << out_of_band.bytesize.chr
          buffer << out_of_band
          MethodFrame.new(buffer, channel)
        end
      end

      class OpenOk < Protocol::Method
        @name = "channel.open-ok"
        @method_id = 11
        @index = 0x0014000B # 20, 11, 1310731
        @packed_indexes = [20, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          channel_id = data[offset, length]
          offset += length
          self.new(channel_id)
        end

        attr_reader :channel_id
        def initialize(channel_id)
          @channel_id = channel_id
        end

        def self.has_content?
          false
        end
      end

      class Flow < Protocol::Method
        @name = "channel.flow"
        @method_id = 20
        @index = 0x00140014 # 20, 20, 1310740
        @packed_indexes = [20, 20].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          active = (bit_buffer & (1 << 0)) != 0
          self.new(active)
        end

        attr_reader :active
        def initialize(active)
          @active = active
        end

        def self.has_content?
          false
        end

        # @return
        # ["active = nil"]
        def self.encode(channel, active)
          buffer = ""
          buffer << @packed_indexes
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if active
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class FlowOk < Protocol::Method
        @name = "channel.flow-ok"
        @method_id = 21
        @index = 0x00140015 # 20, 21, 1310741
        @packed_indexes = [20, 21].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          active = (bit_buffer & (1 << 0)) != 0
          self.new(active)
        end

        attr_reader :active
        def initialize(active)
          @active = active
        end

        def self.has_content?
          false
        end

        # @return
        # ["active = nil"]
        def self.encode(channel, active)
          buffer = ""
          buffer << @packed_indexes
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if active
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class Close < Protocol::Method
        @name = "channel.close"
        @method_id = 40
        @index = 0x00140028 # 20, 40, 1310760
        @packed_indexes = [20, 40].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          reply_code = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          reply_text = data[offset, length]
          offset += length
          class_id = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          method_id = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          self.new(reply_code, reply_text, class_id, method_id)
        end

        attr_reader :reply_code, :reply_text, :class_id, :method_id
        def initialize(reply_code, reply_text, class_id, method_id)
          @reply_code = reply_code
          @reply_text = reply_text
          @class_id = class_id
          @method_id = method_id
        end

        def self.has_content?
          false
        end

        # @return
        # ["reply_code = nil", "reply_text = EMPTY_STRING", "class_id = nil", "method_id = nil"]
        def self.encode(channel, reply_code, reply_text, class_id, method_id)
          buffer = ""
          buffer << @packed_indexes
          buffer << [reply_code].pack(PACK_UINT16)
          buffer << reply_text.bytesize.chr
          buffer << reply_text
          buffer << [class_id].pack(PACK_UINT16)
          buffer << [method_id].pack(PACK_UINT16)
          MethodFrame.new(buffer, channel)
        end
      end

      class CloseOk < Protocol::Method
        @name = "channel.close-ok"
        @method_id = 41
        @index = 0x00140029 # 20, 41, 1310761
        @packed_indexes = [20, 41].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode(channel)
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end
    end

    class Exchange < Protocol::Class
      @name = "exchange"
      @method_id = 40

      class Declare < Protocol::Method
        @name = "exchange.declare"
        @method_id = 10
        @index = 0x0028000A # 40, 10, 2621450
        @packed_indexes = [40, 10].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "exchange = nil", "type = "direct"", "passive = false", "durable = false", "auto_delete = false", "internal = false", "nowait = false", "arguments = {}"]
        def self.encode(channel, exchange, type, passive, durable, auto_delete, internal, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << exchange.bytesize.chr
          buffer << exchange
          buffer << type.bytesize.chr
          buffer << type
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if passive
          bit_buffer = bit_buffer | (1 << 1) if durable
          bit_buffer = bit_buffer | (1 << 2) if auto_delete
          bit_buffer = bit_buffer | (1 << 3) if internal
          bit_buffer = bit_buffer | (1 << 4) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class DeclareOk < Protocol::Method
        @name = "exchange.declare-ok"
        @method_id = 11
        @index = 0x0028000B # 40, 11, 2621451
        @packed_indexes = [40, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Delete < Protocol::Method
        @name = "exchange.delete"
        @method_id = 20
        @index = 0x00280014 # 40, 20, 2621460
        @packed_indexes = [40, 20].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "exchange = nil", "if_unused = false", "nowait = false"]
        def self.encode(channel, exchange, if_unused, nowait)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << exchange.bytesize.chr
          buffer << exchange
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if if_unused
          bit_buffer = bit_buffer | (1 << 1) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class DeleteOk < Protocol::Method
        @name = "exchange.delete-ok"
        @method_id = 21
        @index = 0x00280015 # 40, 21, 2621461
        @packed_indexes = [40, 21].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Bind < Protocol::Method
        @name = "exchange.bind"
        @method_id = 30
        @index = 0x0028001E # 40, 30, 2621470
        @packed_indexes = [40, 30].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "destination = nil", "source = nil", "routing_key = EMPTY_STRING", "nowait = false", "arguments = {}"]
        def self.encode(channel, destination, source, routing_key, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << destination.bytesize.chr
          buffer << destination
          buffer << source.bytesize.chr
          buffer << source
          buffer << routing_key.bytesize.chr
          buffer << routing_key
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class BindOk < Protocol::Method
        @name = "exchange.bind-ok"
        @method_id = 31
        @index = 0x0028001F # 40, 31, 2621471
        @packed_indexes = [40, 31].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Unbind < Protocol::Method
        @name = "exchange.unbind"
        @method_id = 40
        @index = 0x00280028 # 40, 40, 2621480
        @packed_indexes = [40, 40].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "destination = nil", "source = nil", "routing_key = EMPTY_STRING", "nowait = false", "arguments = {}"]
        def self.encode(channel, destination, source, routing_key, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << destination.bytesize.chr
          buffer << destination
          buffer << source.bytesize.chr
          buffer << source
          buffer << routing_key.bytesize.chr
          buffer << routing_key
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class UnbindOk < Protocol::Method
        @name = "exchange.unbind-ok"
        @method_id = 51
        @index = 0x00280033 # 40, 51, 2621491
        @packed_indexes = [40, 51].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end
    end

    class Queue < Protocol::Class
      @name = "queue"
      @method_id = 50

      class Declare < Protocol::Method
        @name = "queue.declare"
        @method_id = 10
        @index = 0x0032000A # 50, 10, 3276810
        @packed_indexes = [50, 10].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "passive = false", "durable = false", "exclusive = false", "auto_delete = false", "nowait = false", "arguments = {}"]
        def self.encode(channel, queue, passive, durable, exclusive, auto_delete, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if passive
          bit_buffer = bit_buffer | (1 << 1) if durable
          bit_buffer = bit_buffer | (1 << 2) if exclusive
          bit_buffer = bit_buffer | (1 << 3) if auto_delete
          bit_buffer = bit_buffer | (1 << 4) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class DeclareOk < Protocol::Method
        @name = "queue.declare-ok"
        @method_id = 11
        @index = 0x0032000B # 50, 11, 3276811
        @packed_indexes = [50, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          queue = data[offset, length]
          offset += length
          message_count = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          consumer_count = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          self.new(queue, message_count, consumer_count)
        end

        attr_reader :queue, :message_count, :consumer_count
        def initialize(queue, message_count, consumer_count)
          @queue = queue
          @message_count = message_count
          @consumer_count = consumer_count
        end

        def self.has_content?
          false
        end
      end

      class Bind < Protocol::Method
        @name = "queue.bind"
        @method_id = 20
        @index = 0x00320014 # 50, 20, 3276820
        @packed_indexes = [50, 20].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "exchange = nil", "routing_key = EMPTY_STRING", "nowait = false", "arguments = {}"]
        def self.encode(channel, queue, exchange, routing_key, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          buffer << exchange.bytesize.chr
          buffer << exchange
          buffer << routing_key.bytesize.chr
          buffer << routing_key
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class BindOk < Protocol::Method
        @name = "queue.bind-ok"
        @method_id = 21
        @index = 0x00320015 # 50, 21, 3276821
        @packed_indexes = [50, 21].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Purge < Protocol::Method
        @name = "queue.purge"
        @method_id = 30
        @index = 0x0032001E # 50, 30, 3276830
        @packed_indexes = [50, 30].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "nowait = false"]
        def self.encode(channel, queue, nowait)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class PurgeOk < Protocol::Method
        @name = "queue.purge-ok"
        @method_id = 31
        @index = 0x0032001F # 50, 31, 3276831
        @packed_indexes = [50, 31].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          message_count = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          self.new(message_count)
        end

        attr_reader :message_count
        def initialize(message_count)
          @message_count = message_count
        end

        def self.has_content?
          false
        end
      end

      class Delete < Protocol::Method
        @name = "queue.delete"
        @method_id = 40
        @index = 0x00320028 # 50, 40, 3276840
        @packed_indexes = [50, 40].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "if_unused = false", "if_empty = false", "nowait = false"]
        def self.encode(channel, queue, if_unused, if_empty, nowait)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if if_unused
          bit_buffer = bit_buffer | (1 << 1) if if_empty
          bit_buffer = bit_buffer | (1 << 2) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class DeleteOk < Protocol::Method
        @name = "queue.delete-ok"
        @method_id = 41
        @index = 0x00320029 # 50, 41, 3276841
        @packed_indexes = [50, 41].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          message_count = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          self.new(message_count)
        end

        attr_reader :message_count
        def initialize(message_count)
          @message_count = message_count
        end

        def self.has_content?
          false
        end
      end

      class Unbind < Protocol::Method
        @name = "queue.unbind"
        @method_id = 50
        @index = 0x00320032 # 50, 50, 3276850
        @packed_indexes = [50, 50].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "exchange = nil", "routing_key = EMPTY_STRING", "arguments = {}"]
        def self.encode(channel, queue, exchange, routing_key, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          buffer << exchange.bytesize.chr
          buffer << exchange
          buffer << routing_key.bytesize.chr
          buffer << routing_key
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class UnbindOk < Protocol::Method
        @name = "queue.unbind-ok"
        @method_id = 51
        @index = 0x00320033 # 50, 51, 3276851
        @packed_indexes = [50, 51].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end
    end

    class Basic < Protocol::Class
      @name = "basic"
      @method_id = 60

      PROPERTIES = [
        :content_type, # shortstr
        :content_encoding, # shortstr
        :headers, # table
        :delivery_mode, # octet
        :priority, # octet
        :correlation_id, # shortstr
        :reply_to, # shortstr
        :expiration, # shortstr
        :message_id, # shortstr
        :timestamp, # timestamp
        :type, # shortstr
        :user_id, # shortstr
        :app_id, # shortstr
        :cluster_id, # shortstr
      ]

      # 1 << 15
      def self.encode_content_type(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [0, 0x8000, buffer]
      end

      # 1 << 14
      def self.encode_content_encoding(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [1, 0x4000, buffer]
      end

      # 1 << 13
      def self.encode_headers(value)
        buffer = ""
        buffer << AMQ::Protocol::Table.encode(value)
        [2, 0x2000, buffer]
      end

      # 1 << 12
      def self.encode_delivery_mode(value)
        buffer = ""
        buffer << [value].pack(PACK_CHAR)
        [3, 0x1000, buffer]
      end

      # 1 << 11
      def self.encode_priority(value)
        buffer = ""
        buffer << [value].pack(PACK_CHAR)
        [4, 0x0800, buffer]
      end

      # 1 << 10
      def self.encode_correlation_id(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [5, 0x0400, buffer]
      end

      # 1 << 9
      def self.encode_reply_to(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [6, 0x0200, buffer]
      end

      # 1 << 8
      def self.encode_expiration(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [7, 0x0100, buffer]
      end

      # 1 << 7
      def self.encode_message_id(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [8, 0x0080, buffer]
      end

      # 1 << 6
      def self.encode_timestamp(value)
        buffer = ""
        buffer << AMQ::Hacks.pack_64_big_endian(value)
        [9, 0x0040, buffer]
      end

      # 1 << 5
      def self.encode_type(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [10, 0x0020, buffer]
      end

      # 1 << 4
      def self.encode_user_id(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [11, 0x0010, buffer]
      end

      # 1 << 3
      def self.encode_app_id(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [12, 0x0008, buffer]
      end

      # 1 << 2
      def self.encode_cluster_id(value)
        buffer = ""
        buffer << value.bytesize.chr
        buffer << value
        [13, 0x0004, buffer]
      end

      def self.encode_properties(body_size, properties)
        pieces, flags = [], 0

        properties.each do |key, value|
          i, f, result = self.send(:"encode_#{key}", value)
          flags |= f
          pieces[i] = result
        end

        # result = [60, 0, body_size, flags].pack("n2Qn")
        result = [60, 0].pack(PACK_UINT16_X2)
        result += AMQ::Hacks.pack_64_big_endian(body_size)
        result += [flags].pack(PACK_UINT16)
        result + pieces.join(EMPTY_STRING)
      end

      # THIS DECODES ONLY FLAGS
      DECODE_PROPERTIES = {
        0x8000 => :content_type,
        0x4000 => :content_encoding,
        0x2000 => :headers,
        0x1000 => :delivery_mode,
        0x0800 => :priority,
        0x0400 => :correlation_id,
        0x0200 => :reply_to,
        0x0100 => :expiration,
        0x0080 => :message_id,
        0x0040 => :timestamp,
        0x0020 => :type,
        0x0010 => :user_id,
        0x0008 => :app_id,
        0x0004 => :cluster_id,
      }

      DECODE_PROPERTIES_TYPE = {
        0x8000 => :shortstr,
        0x4000 => :shortstr,
        0x2000 => :table,
        0x1000 => :octet,
        0x0800 => :octet,
        0x0400 => :shortstr,
        0x0200 => :shortstr,
        0x0100 => :shortstr,
        0x0080 => :shortstr,
        0x0040 => :timestamp,
        0x0020 => :shortstr,
        0x0010 => :shortstr,
        0x0008 => :shortstr,
        0x0004 => :shortstr,
      }

      # Hash doesn"t give any guarantees on keys order, we will do it in a
      # straightforward way
      DECODE_PROPERTIES_KEYS = [
        0x8000,
        0x4000,
        0x2000,
        0x1000,
        0x0800,
        0x0400,
        0x0200,
        0x0100,
        0x0080,
        0x0040,
        0x0020,
        0x0010,
        0x0008,
        0x0004,
      ]

      def self.decode_properties(data)
        offset, data_length, properties = 0, data.bytesize, {}

        compressed_index = data[offset, 2].unpack(PACK_UINT16)[0]
        offset += 2
        while data_length > offset
          DECODE_PROPERTIES_KEYS.each do |key|
            next unless compressed_index >= key
            compressed_index -= key
            name = DECODE_PROPERTIES[key] || raise(RuntimeError.new("No property found for index #{index.inspect}!"))
            case DECODE_PROPERTIES_TYPE[key]
            when :shortstr
              size = data[offset, 1].unpack(PACK_CHAR)[0]
              offset += 1
              result = data[offset, size]
            when :octet
              size = 1
              result = data[offset, size].unpack(PACK_CHAR).first
            when :timestamp
              size = 8
              result = Time.at(data[offset, size].unpack(PACK_UINT32_X2).last)
            when :table
              size = 4 + data[offset, 4].unpack(PACK_UINT32)[0]
              result = Table.decode(data[offset, size])
            end
            properties[name] = result
            offset += size
          end
        end

        properties
      end

      class Qos < Protocol::Method
        @name = "basic.qos"
        @method_id = 10
        @index = 0x003C000A # 60, 10, 3932170
        @packed_indexes = [60, 10].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["prefetch_size = false", "prefetch_count = false", "global = false"]
        def self.encode(channel, prefetch_size, prefetch_count, global)
          buffer = ""
          buffer << @packed_indexes
          buffer << [prefetch_size].pack(PACK_UINT32)
          buffer << [prefetch_count].pack(PACK_UINT16)
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if global
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class QosOk < Protocol::Method
        @name = "basic.qos-ok"
        @method_id = 11
        @index = 0x003C000B # 60, 11, 3932171
        @packed_indexes = [60, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Consume < Protocol::Method
        @name = "basic.consume"
        @method_id = 20
        @index = 0x003C0014 # 60, 20, 3932180
        @packed_indexes = [60, 20].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "consumer_tag = EMPTY_STRING", "no_local = false", "no_ack = false", "exclusive = false", "nowait = false", "arguments = {}"]
        def self.encode(channel, queue, consumer_tag, no_local, no_ack, exclusive, nowait, arguments)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          buffer << consumer_tag.bytesize.chr
          buffer << consumer_tag
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if no_local
          bit_buffer = bit_buffer | (1 << 1) if no_ack
          bit_buffer = bit_buffer | (1 << 2) if exclusive
          bit_buffer = bit_buffer | (1 << 3) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          buffer << AMQ::Protocol::Table.encode(arguments)
          MethodFrame.new(buffer, channel)
        end
      end

      class ConsumeOk < Protocol::Method
        @name = "basic.consume-ok"
        @method_id = 21
        @index = 0x003C0015 # 60, 21, 3932181
        @packed_indexes = [60, 21].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          consumer_tag = data[offset, length]
          offset += length
          self.new(consumer_tag)
        end

        attr_reader :consumer_tag
        def initialize(consumer_tag)
          @consumer_tag = consumer_tag
        end

        def self.has_content?
          false
        end
      end

      class Cancel < Protocol::Method
        @name = "basic.cancel"
        @method_id = 30
        @index = 0x003C001E # 60, 30, 3932190
        @packed_indexes = [60, 30].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["consumer_tag = nil", "nowait = false"]
        def self.encode(channel, consumer_tag, nowait)
          buffer = ""
          buffer << @packed_indexes
          buffer << consumer_tag.bytesize.chr
          buffer << consumer_tag
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class CancelOk < Protocol::Method
        @name = "basic.cancel-ok"
        @method_id = 31
        @index = 0x003C001F # 60, 31, 3932191
        @packed_indexes = [60, 31].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          consumer_tag = data[offset, length]
          offset += length
          self.new(consumer_tag)
        end

        attr_reader :consumer_tag
        def initialize(consumer_tag)
          @consumer_tag = consumer_tag
        end

        def self.has_content?
          false
        end
      end

      class Publish < Protocol::Method
        @name = "basic.publish"
        @method_id = 40
        @index = 0x003C0028 # 60, 40, 3932200
        @packed_indexes = [60, 40].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          true
        end

        # @return
        # ["ticket = 0", "exchange = EMPTY_STRING", "routing_key = EMPTY_STRING", "mandatory = false", "immediate = false", "user_headers = nil", "payload = """, "frame_size = nil"]
        def self.encode(channel, payload, user_headers, exchange, routing_key, mandatory, immediate, frame_size)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << exchange.bytesize.chr
          buffer << exchange
          buffer << routing_key.bytesize.chr
          buffer << routing_key
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if mandatory
          bit_buffer = bit_buffer | (1 << 1) if immediate
          buffer << [bit_buffer].pack(PACK_CHAR)
          frames = [MethodFrame.new(buffer, channel)]
          properties, headers = self.split_headers(user_headers)
          # TODO: what shall I do with the headers?
          if properties.nil? or properties.empty?
            raise RuntimeError.new("Properties can not be empty!") # TODO: or can they?
          end
          properties_payload = Basic.encode_properties(payload.bytesize, properties)
          frames << HeaderFrame.new(properties_payload, channel)
          frames + self.encode_body(payload, channel, frame_size)
        end
      end

      class Return < Protocol::Method
        @name = "basic.return"
        @method_id = 50
        @index = 0x003C0032 # 60, 50, 3932210
        @packed_indexes = [60, 50].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          reply_code = data[offset, 2].unpack(PACK_UINT16).first
          offset += 2
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          reply_text = data[offset, length]
          offset += length
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          exchange = data[offset, length]
          offset += length
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          routing_key = data[offset, length]
          offset += length
          self.new(reply_code, reply_text, exchange, routing_key)
        end

        attr_reader :reply_code, :reply_text, :exchange, :routing_key
        def initialize(reply_code, reply_text, exchange, routing_key)
          @reply_code = reply_code
          @reply_text = reply_text
          @exchange = exchange
          @routing_key = routing_key
        end

        def self.has_content?
          true
        end
      end

      class Deliver < Protocol::Method
        @name = "basic.deliver"
        @method_id = 60
        @index = 0x003C003C # 60, 60, 3932220
        @packed_indexes = [60, 60].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          consumer_tag = data[offset, length]
          offset += length
          delivery_tag = AMQ::Hacks.unpack_64_big_endian(data[offset, 8]).first
          offset += 8
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          redelivered = (bit_buffer & (1 << 0)) != 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          exchange = data[offset, length]
          offset += length
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          routing_key = data[offset, length]
          offset += length
          self.new(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
        end

        attr_reader :consumer_tag, :delivery_tag, :redelivered, :exchange, :routing_key
        def initialize(consumer_tag, delivery_tag, redelivered, exchange, routing_key)
          @consumer_tag = consumer_tag
          @delivery_tag = delivery_tag
          @redelivered = redelivered
          @exchange = exchange
          @routing_key = routing_key
        end

        def self.has_content?
          true
        end
      end

      class Get < Protocol::Method
        @name = "basic.get"
        @method_id = 70
        @index = 0x003C0046 # 60, 70, 3932230
        @packed_indexes = [60, 70].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["ticket = 0", "queue = EMPTY_STRING", "no_ack = false"]
        def self.encode(channel, queue, no_ack)
          ticket = 0
          buffer = ""
          buffer << @packed_indexes
          buffer << [ticket].pack(PACK_UINT16)
          buffer << queue.bytesize.chr
          buffer << queue
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if no_ack
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class GetOk < Protocol::Method
        @name = "basic.get-ok"
        @method_id = 71
        @index = 0x003C0047 # 60, 71, 3932231
        @packed_indexes = [60, 71].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          delivery_tag = AMQ::Hacks.unpack_64_big_endian(data[offset, 8]).first
          offset += 8
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          redelivered = (bit_buffer & (1 << 0)) != 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          exchange = data[offset, length]
          offset += length
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          routing_key = data[offset, length]
          offset += length
          message_count = data[offset, 4].unpack(PACK_UINT32).first
          offset += 4
          self.new(delivery_tag, redelivered, exchange, routing_key, message_count)
        end

        attr_reader :delivery_tag, :redelivered, :exchange, :routing_key, :message_count
        def initialize(delivery_tag, redelivered, exchange, routing_key, message_count)
          @delivery_tag = delivery_tag
          @redelivered = redelivered
          @exchange = exchange
          @routing_key = routing_key
          @message_count = message_count
        end

        def self.has_content?
          true
        end
      end

      class GetEmpty < Protocol::Method
        @name = "basic.get-empty"
        @method_id = 72
        @index = 0x003C0048 # 60, 72, 3932232
        @packed_indexes = [60, 72].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          length = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          cluster_id = data[offset, length]
          offset += length
          self.new(cluster_id)
        end

        attr_reader :cluster_id
        def initialize(cluster_id)
          @cluster_id = cluster_id
        end

        def self.has_content?
          false
        end
      end

      class Ack < Protocol::Method
        @name = "basic.ack"
        @method_id = 80
        @index = 0x003C0050 # 60, 80, 3932240
        @packed_indexes = [60, 80].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          delivery_tag = AMQ::Hacks.unpack_64_big_endian(data[offset, 8]).first
          offset += 8
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          multiple = (bit_buffer & (1 << 0)) != 0
          self.new(delivery_tag, multiple)
        end

        attr_reader :delivery_tag, :multiple
        def initialize(delivery_tag, multiple)
          @delivery_tag = delivery_tag
          @multiple = multiple
        end

        def self.has_content?
          false
        end

        # @return
        # ["delivery_tag = false", "multiple = false"]
        def self.encode(channel, delivery_tag, multiple)
          buffer = ""
          buffer << @packed_indexes
          buffer << AMQ::Hacks.pack_64_big_endian(delivery_tag)
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if multiple
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class Reject < Protocol::Method
        @name = "basic.reject"
        @method_id = 90
        @index = 0x003C005A # 60, 90, 3932250
        @packed_indexes = [60, 90].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["delivery_tag = nil", "requeue = true"]
        def self.encode(channel, delivery_tag, requeue)
          buffer = ""
          buffer << @packed_indexes
          buffer << AMQ::Hacks.pack_64_big_endian(delivery_tag)
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if requeue
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class RecoverAsync < Protocol::Method
        @name = "basic.recover-async"
        @method_id = 100
        @index = 0x003C0064 # 60, 100, 3932260
        @packed_indexes = [60, 100].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["requeue = false"]
        def self.encode(channel, requeue)
          buffer = ""
          buffer << @packed_indexes
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if requeue
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class Recover < Protocol::Method
        @name = "basic.recover"
        @method_id = 110
        @index = 0x003C006E # 60, 110, 3932270
        @packed_indexes = [60, 110].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # ["requeue = false"]
        def self.encode(channel, requeue)
          buffer = ""
          buffer << @packed_indexes
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if requeue
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class RecoverOk < Protocol::Method
        @name = "basic.recover-ok"
        @method_id = 111
        @index = 0x003C006F # 60, 111, 3932271
        @packed_indexes = [60, 111].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Nack < Protocol::Method
        @name = "basic.nack"
        @method_id = 120
        @index = 0x003C0078 # 60, 120, 3932280
        @packed_indexes = [60, 120].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          delivery_tag = AMQ::Hacks.unpack_64_big_endian(data[offset, 8]).first
          offset += 8
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          multiple = (bit_buffer & (1 << 0)) != 0
          requeue = (bit_buffer & (1 << 1)) != 0
          self.new(delivery_tag, multiple, requeue)
        end

        attr_reader :delivery_tag, :multiple, :requeue
        def initialize(delivery_tag, multiple, requeue)
          @delivery_tag = delivery_tag
          @multiple = multiple
          @requeue = requeue
        end

        def self.has_content?
          false
        end

        # @return
        # ["delivery_tag = false", "multiple = false", "requeue = true"]
        def self.encode(channel, delivery_tag, multiple, requeue)
          buffer = ""
          buffer << @packed_indexes
          buffer << AMQ::Hacks.pack_64_big_endian(delivery_tag)
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if multiple
          bit_buffer = bit_buffer | (1 << 1) if requeue
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end
    end

    class Tx < Protocol::Class
      @name = "tx"
      @method_id = 90

      class Select < Protocol::Method
        @name = "tx.select"
        @method_id = 10
        @index = 0x005A000A # 90, 10, 5898250
        @packed_indexes = [90, 10].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode(channel)
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end

      class SelectOk < Protocol::Method
        @name = "tx.select-ok"
        @method_id = 11
        @index = 0x005A000B # 90, 11, 5898251
        @packed_indexes = [90, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Commit < Protocol::Method
        @name = "tx.commit"
        @method_id = 20
        @index = 0x005A0014 # 90, 20, 5898260
        @packed_indexes = [90, 20].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode(channel)
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end

      class CommitOk < Protocol::Method
        @name = "tx.commit-ok"
        @method_id = 21
        @index = 0x005A0015 # 90, 21, 5898261
        @packed_indexes = [90, 21].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end

      class Rollback < Protocol::Method
        @name = "tx.rollback"
        @method_id = 30
        @index = 0x005A001E # 90, 30, 5898270
        @packed_indexes = [90, 30].pack(PACK_UINT16_X2).freeze

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode(channel)
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end

      class RollbackOk < Protocol::Method
        @name = "tx.rollback-ok"
        @method_id = 31
        @index = 0x005A001F # 90, 31, 5898271
        @packed_indexes = [90, 31].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end
      end
    end

    class Confirm < Protocol::Class
      @name = "confirm"
      @method_id = 85

      class Select < Protocol::Method
        @name = "confirm.select"
        @method_id = 10
        @index = 0x0055000A # 85, 10, 5570570
        @packed_indexes = [85, 10].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          bit_buffer = data[offset, 1].unpack(PACK_CHAR).first
          offset += 1
          nowait = (bit_buffer & (1 << 0)) != 0
          self.new(nowait)
        end

        attr_reader :nowait
        def initialize(nowait)
          @nowait = nowait
        end

        def self.has_content?
          false
        end

        # @return
        # ["nowait = false"]
        def self.encode(channel, nowait)
          buffer = ""
          buffer << @packed_indexes
          bit_buffer = 0
          bit_buffer = bit_buffer | (1 << 0) if nowait
          buffer << [bit_buffer].pack(PACK_CHAR)
          MethodFrame.new(buffer, channel)
        end
      end

      class SelectOk < Protocol::Method
        @name = "confirm.select-ok"
        @method_id = 11
        @index = 0x0055000B # 85, 11, 5570571
        @packed_indexes = [85, 11].pack(PACK_UINT16_X2).freeze

        # @return
        def self.decode(data)
          offset = 0
          self.new()
        end

        def initialize()
        end

        def self.has_content?
          false
        end

        # @return
        # []
        def self.encode(channel)
          buffer = ""
          buffer << @packed_indexes
          MethodFrame.new(buffer, channel)
        end
      end
    end

    METHODS = begin
      Method.methods.inject(Hash.new) do |hash, klass|
        hash.merge!(klass.index => klass)
      end
    end
  end
end