rabbitmq 0.2.3 → 0.2.4

data/lib/rabbitmq/ffi/gen/connection_open.rb

@@ -0,0 +1,41 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionOpen < ::FFI::Struct
+      layout(
+        :virtual_host, Bytes,
+        :capabilities, Bytes,
+        :insist, Boolean
+      )
+      
+      def self.id
+        :connection_open
+      end
+      
+      def id
+        :connection_open
+      end
+      
+      def apply(virtual_host: nil, capabilities: nil, insist: nil)
+        self[:virtual_host] = Bytes.from_s(virtual_host.to_s) if virtual_host
+        self[:capabilities] = Bytes.from_s(capabilities.to_s) if capabilities
+        self[:insist] = insist unless insist.nil?
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          virtual_host: self[:virtual_host].to_s(free),
+          capabilities: self[:capabilities].to_s(free),
+          insist: self[:insist]
+        }
+      end
+      
+      def free!
+        self[:virtual_host].free!
+        self[:capabilities].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_open_ok.rb

@@ -0,0 +1,30 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionOpenOk < ::FFI::Struct
+      layout(:known_hosts, Bytes)
+      
+      def self.id
+        :connection_open_ok
+      end
+      
+      def id
+        :connection_open_ok
+      end
+      
+      def apply(known_hosts: nil)
+        self[:known_hosts] = Bytes.from_s(known_hosts.to_s) if known_hosts
+        self
+      end
+      
+      def to_h(free=false)
+        {known_hosts: self[:known_hosts].to_s(free)}
+      end
+      
+      def free!
+        self[:known_hosts].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_secure.rb

@@ -0,0 +1,30 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionSecure < ::FFI::Struct
+      layout(:challenge, Bytes)
+      
+      def self.id
+        :connection_secure
+      end
+      
+      def id
+        :connection_secure
+      end
+      
+      def apply(challenge: nil)
+        self[:challenge] = Bytes.from_s(challenge.to_s) if challenge
+        self
+      end
+      
+      def to_h(free=false)
+        {challenge: self[:challenge].to_s(free)}
+      end
+      
+      def free!
+        self[:challenge].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_secure_ok.rb

@@ -0,0 +1,30 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionSecureOk < ::FFI::Struct
+      layout(:response, Bytes)
+      
+      def self.id
+        :connection_secure_ok
+      end
+      
+      def id
+        :connection_secure_ok
+      end
+      
+      def apply(response: nil)
+        self[:response] = Bytes.from_s(response.to_s) if response
+        self
+      end
+      
+      def to_h(free=false)
+        {response: self[:response].to_s(free)}
+      end
+      
+      def free!
+        self[:response].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_start.rb

@@ -0,0 +1,48 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionStart < ::FFI::Struct
+      layout(
+        :version_major, :uint8,
+        :version_minor, :uint8,
+        :server_properties, Table,
+        :mechanisms, Bytes,
+        :locales, Bytes
+      )
+      
+      def self.id
+        :connection_start
+      end
+      
+      def id
+        :connection_start
+      end
+      
+      def apply(version_major: nil, version_minor: nil, server_properties: nil, mechanisms: nil, locales: nil)
+        self[:version_major] = Integer(version_major) if version_major
+        self[:version_minor] = Integer(version_minor) if version_minor
+        self[:server_properties] = Table.from(server_properties) if server_properties
+        self[:mechanisms] = Bytes.from_s(mechanisms.to_s) if mechanisms
+        self[:locales] = Bytes.from_s(locales.to_s) if locales
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          version_major: self[:version_major],
+          version_minor: self[:version_minor],
+          server_properties: self[:server_properties].to_h(free),
+          mechanisms: self[:mechanisms].to_s(free),
+          locales: self[:locales].to_s(free)
+        }
+      end
+      
+      def free!
+        self[:server_properties].free!
+        self[:mechanisms].free!
+        self[:locales].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_start_ok.rb

@@ -0,0 +1,46 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionStartOk < ::FFI::Struct
+      layout(
+        :client_properties, Table,
+        :mechanism, Bytes,
+        :response, Bytes,
+        :locale, Bytes
+      )
+      
+      def self.id
+        :connection_start_ok
+      end
+      
+      def id
+        :connection_start_ok
+      end
+      
+      def apply(client_properties: nil, mechanism: nil, response: nil, locale: nil)
+        self[:client_properties] = Table.from(client_properties) if client_properties
+        self[:mechanism] = Bytes.from_s(mechanism.to_s) if mechanism
+        self[:response] = Bytes.from_s(response.to_s) if response
+        self[:locale] = Bytes.from_s(locale.to_s) if locale
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          client_properties: self[:client_properties].to_h(free),
+          mechanism: self[:mechanism].to_s(free),
+          response: self[:response].to_s(free),
+          locale: self[:locale].to_s(free)
+        }
+      end
+      
+      def free!
+        self[:client_properties].free!
+        self[:mechanism].free!
+        self[:response].free!
+        self[:locale].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_tune.rb

@@ -0,0 +1,39 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionTune < ::FFI::Struct
+      layout(
+        :channel_max, :uint16,
+        :frame_max, :uint32,
+        :heartbeat, :uint16
+      )
+      
+      def self.id
+        :connection_tune
+      end
+      
+      def id
+        :connection_tune
+      end
+      
+      def apply(channel_max: nil, frame_max: nil, heartbeat: nil)
+        self[:channel_max] = Integer(channel_max) if channel_max
+        self[:frame_max] = Integer(frame_max) if frame_max
+        self[:heartbeat] = Integer(heartbeat) if heartbeat
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          channel_max: self[:channel_max],
+          frame_max: self[:frame_max],
+          heartbeat: self[:heartbeat]
+        }
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_tune_ok.rb

@@ -0,0 +1,39 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionTuneOk < ::FFI::Struct
+      layout(
+        :channel_max, :uint16,
+        :frame_max, :uint32,
+        :heartbeat, :uint16
+      )
+      
+      def self.id
+        :connection_tune_ok
+      end
+      
+      def id
+        :connection_tune_ok
+      end
+      
+      def apply(channel_max: nil, frame_max: nil, heartbeat: nil)
+        self[:channel_max] = Integer(channel_max) if channel_max
+        self[:frame_max] = Integer(frame_max) if frame_max
+        self[:heartbeat] = Integer(heartbeat) if heartbeat
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          channel_max: self[:channel_max],
+          frame_max: self[:frame_max],
+          heartbeat: self[:heartbeat]
+        }
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/connection_unblocked.rb

@@ -0,0 +1,28 @@
+
+module RabbitMQ
+  module FFI
+    class ConnectionUnblocked < ::FFI::Struct
+      layout(:dummy, :char)
+      
+      def self.id
+        :connection_unblocked
+      end
+      
+      def id
+        :connection_unblocked
+      end
+      
+      def apply(dummy: nil)
+        self
+      end
+      
+      def to_h(free=false)
+        {}
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/exchange_bind.rb

@@ -0,0 +1,52 @@
+
+module RabbitMQ
+  module FFI
+    class ExchangeBind < ::FFI::Struct
+      layout(
+        :ticket, :uint16,
+        :destination, Bytes,
+        :source, Bytes,
+        :routing_key, Bytes,
+        :nowait, Boolean,
+        :arguments, Table
+      )
+      
+      def self.id
+        :exchange_bind
+      end
+      
+      def id
+        :exchange_bind
+      end
+      
+      def apply(ticket: nil, destination: nil, source: nil, routing_key: nil, nowait: nil, arguments: nil)
+        self[:ticket] = Integer(ticket) if ticket
+        self[:destination] = Bytes.from_s(destination.to_s) if destination
+        self[:source] = Bytes.from_s(source.to_s) if source
+        self[:routing_key] = Bytes.from_s(routing_key.to_s) if routing_key
+        self[:nowait] = nowait unless nowait.nil?
+        self[:arguments] = Table.from(arguments) if arguments
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          ticket: self[:ticket],
+          destination: self[:destination].to_s(free),
+          source: self[:source].to_s(free),
+          routing_key: self[:routing_key].to_s(free),
+          nowait: self[:nowait],
+          arguments: self[:arguments].to_h(free)
+        }
+      end
+      
+      def free!
+        self[:destination].free!
+        self[:source].free!
+        self[:routing_key].free!
+        self[:arguments].free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/exchange_bind_ok.rb

@@ -0,0 +1,28 @@
+
+module RabbitMQ
+  module FFI
+    class ExchangeBindOk < ::FFI::Struct
+      layout(:dummy, :char)
+      
+      def self.id
+        :exchange_bind_ok
+      end
+      
+      def id
+        :exchange_bind_ok
+      end
+      
+      def apply(dummy: nil)
+        self
+      end
+      
+      def to_h(free=false)
+        {}
+      end
+      
+      def free!
+      end
+      
+    end
+  end
+end

data/lib/rabbitmq/ffi/gen/exchange_declare.rb

@@ -0,0 +1,60 @@
+
+module RabbitMQ
+  module FFI
+    class ExchangeDeclare < ::FFI::Struct
+      layout(
+        :ticket, :uint16,
+        :exchange, Bytes,
+        :type, Bytes,
+        :passive, Boolean,
+        :durable, Boolean,
+        :auto_delete, Boolean,
+        :internal, Boolean,
+        :nowait, Boolean,
+        :arguments, Table
+      )
+      
+      def self.id
+        :exchange_declare
+      end
+      
+      def id
+        :exchange_declare
+      end
+      
+      def apply(ticket: nil, exchange: nil, type: nil, passive: nil, durable: nil, auto_delete: nil, internal: nil, nowait: nil, arguments: nil)
+        self[:ticket] = Integer(ticket) if ticket
+        self[:exchange] = Bytes.from_s(exchange.to_s) if exchange
+        self[:type] = Bytes.from_s(type.to_s) if type
+        self[:passive] = passive unless passive.nil?
+        self[:durable] = durable unless durable.nil?
+        self[:auto_delete] = auto_delete unless auto_delete.nil?
+        self[:internal] = internal unless internal.nil?
+        self[:nowait] = nowait unless nowait.nil?
+        self[:arguments] = Table.from(arguments) if arguments
+        self
+      end
+      
+      def to_h(free=false)
+        {
+          ticket: self[:ticket],
+          exchange: self[:exchange].to_s(free),
+          type: self[:type].to_s(free),
+          passive: self[:passive],
+          durable: self[:durable],
+          auto_delete: self[:auto_delete],
+          internal: self[:internal],
+          nowait: self[:nowait],
+          arguments: self[:arguments].to_h(free)
+        }
+      end
+      
+      def free!
+        self[:exchange].free!
+        self[:type].free!
+        self[:arguments].free!
+      end
+      
+    end
+  end
+end