qpid_proton 0.9.0 → 0.10

data/lib/qpid_proton/described.rb

@@ -1,66 +0,0 @@
-#--
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#++
-
-module Qpid # :nodoc:
-
-  module Proton # :nodoc:
-
-    class Described
-
-      attr_reader :descriptor
-      attr_reader :value
-
-      def initialize(descriptor, value)
-        @descriptor = descriptor
-        @value = value
-      end
-
-      # Puts the description into the Data object.
-      #
-      # ==== Arguments
-      #
-      # * data - the Qpid::Proton::Data instance
-      #
-      # ==== Examples
-      #
-      #   described = Qpid::Proton::Described.new("my-descriptor", "the value")
-      #   data = Qpid::Proton::Data.new
-      #   ...
-      #   described.put(data)
-      #
-      def put(data)
-        data.symbol = @descriptor
-        data.string = @value
-      end
-
-      def ==(that) # :nodoc:
-        (that.is_a?(Qpid::Proton::Described) &&
-         (self.descriptor == that.descriptor) &&
-         (self.value == that.value))
-      end
-
-      def to_s # :nodoc:
-        "descriptor=#{descriptor} value=#{value}"
-      end
-
-    end
-
-  end
-
-end

data/lib/qpid_proton/exception_handling.rb

@@ -1,127 +0,0 @@
-#--
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#++
-
-module Qpid # :nodoc:
-
-  module Proton # :nodoc:
-
-    # Provides mixin functionality for dealing with exception conditions.
-    #
-    module ExceptionHandling
-
-      def self.included(base)
-        base.extend(self)
-
-        unless defined? base.to_be_wrapped
-          class << base
-            @@to_be_wrapped = []
-          end
-        end
-
-        define_method :method_added do |name|
-          if (!@@to_be_wrapped.nil?) && (@@to_be_wrapped.include? name)
-            @@to_be_wrapped.delete name
-            create_exception_handler_wrapper(name)
-          end
-        end
-      end
-
-      def can_raise_exception(method_names)
-        # coerce the names to be an array
-        Array(method_names).each do |method_name|
-          # if the method doesn't already exist then queue this aliasing
-          unless self.method_defined? method_name
-            @@to_be_wrapped ||= []
-            @@to_be_wrapped << method_name
-          else
-            create_exception_handler_wrapper(method_name)
-          end
-        end
-      end
-
-      def create_exception_handler_wrapper(method_name)
-        original_method_name = method_name.to_s
-        wrapped_method_name = "_excwrap_#{original_method_name}"
-        alias_method wrapped_method_name, original_method_name
-        define_method original_method_name do |*args, &block|
-          # need to get a reference to the method object itself since
-          # calls to Class.send interfere with Messenger.send
-          method = self.method(wrapped_method_name.to_sym)
-          rc = method.call(*args, &block)
-          check_for_error(rc)
-        end
-      end
-
-      # Raises an Proton-specific error if a return code is non-zero.
-      #
-      # Expects the class to provide an +error+ method.
-      def check_for_error(code)
-
-        raise ::ArgumentError.new("Invalid error code: #{code}") if code.nil?
-
-        return code if code > 0
-
-        case(code)
-
-        when Qpid::Proton::Error::NONE
-          return
-
-        when Qpid::Proton::Error::EOS
-          raise Qpid::Proton::EOSError.new(self.error)
-
-        when Qpid::Proton::Error::ERROR
-          raise Qpid::Proton::ProtonError.new(self.error)
-
-        when Qpid::Proton::Error::OVERFLOW
-          raise Qpid::Proton::OverflowError.new(self.error)
-
-        when Qpid::Proton::Error::UNDERFLOW
-          raise Qpid::Proton::UnderflowError.new(self.error)
-
-        when Qpid::Proton::Error::ARGUMENT
-          raise Qpid::Proton::ArgumentError.new(self.error)
-
-        when Qpid::Proton::Error::STATE
-          raise Qpid::Proton::StateError.new(self.error)
-
-        when Qpid::Proton::Error::TIMEOUT
-          raise Qpid::Proton::TimeoutError.new(self.error)
-
-        when Qpid::Proton::Error::INPROGRESS
-          return
-
-        when Qpid::Proton::Error::INTERRUPTED
-          raise Qpid::Proton::InterruptedError.new(self.error)
-
-        when Qpid::Proton::Error::INPROGRESS
-          raise Qpid::Proton::InProgressError.new(self.error)
-
-        else
-
-          raise ::ArgumentError.new("Unknown error code: #{code}")
-
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/qpid_proton/filters.rb

@@ -1,67 +0,0 @@
-#--
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#++
-
-module Qpid # :nodoc:
-
-  module Proton # :nodoc:
-
-    module Filters
-
-      def self.included(base)
-        base.class_eval do
-          extend ClassMethods
-        end
-      end
-
-      module ClassMethods
-
-        def method_added(method_name)
-          @@hooked_methods ||= []
-          return if @@hooked_methods.include?(method_name)
-          @@hooked_methods << method_name
-          hooks = @@before_hooks[method_name]
-          return if hooks.nil?
-          orig_method = instance_method(method_name)
-          define_method(method_name) do |*args, &block|
-            hooks = @@before_hooks[method_name]
-            hooks.each do |hook|
-              method(hook).call
-            end
-
-            orig_method.bind(self).call(*args, &block)
-          end
-        end
-
-        def call_before(before_method, *methods)
-          @@before_hooks ||= {}
-          methods.each do |method|
-            hooks = @@before_hooks[method] || []
-            raise "Repeat filter: #{before_method}" if hooks.include? before_method
-            hooks << before_method
-            @@before_hooks[method] = hooks
-          end
-        end
-
-      end
-
-    end
-
-  end
-
-end

data/lib/qpid_proton/mapping.rb

@@ -1,170 +0,0 @@
-#--
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#++
-
-module Qpid # :nodoc:
-
-  module Proton # :nodoc:
-
-    # Maps between Proton types and their Ruby native language counterparts.
-    #
-    class Mapping
-
-      attr_reader :code
-      attr_reader :put_method
-      attr_reader :get_method
-
-      # Creates a new mapping.
-      #
-      # ==== Arguments
-      #
-      # * code    - the AMQP code for this type
-      # * name    - the AMQP name for this type
-      # * klasses - the Ruby classes for this type
-      # * getter  - overrides the get method for the type
-      def initialize(code, name, klasses = nil, getter = nil)
-
-        @debug = (name == "bool")
-
-        @code = code
-        @name = name
-
-        @@by_preferred ||= {}
-        @@by_code ||= {}
-        @@by_code["#{code}"] = self
-        @@by_name ||= {}
-        @@by_name[name] = self
-        @@by_class ||= {}
-
-        unless klasses.nil?
-          klasses.each do |klass|
-            raise "entry exists for #{klass}" if @@by_class.keys.include? klass
-            @@by_class[klass] = self unless klass.nil?
-          end
-        end
-
-        @put_method = (name + "=").intern
-
-        if getter.nil?
-          @get_method = name.intern
-        else
-          @get_method = getter.intern
-        end
-      end
-
-      def to_s; @name; end
-
-      def put(data, value)
-        data.send(@put_method, value)
-      end
-
-      def get(data)
-        data.send(@get_method)
-      end
-
-      def self.for_class(klass) # :nodoc:
-        @@by_class[klass]
-      end
-
-      def self.for_code(code)
-        @@by_code["#{code}"]
-      end
-
-    end
-
-    NULL       = Mapping.new(Cproton::PN_NULL, "null", [NilClass], "nil?")
-    BOOL       = Mapping.new(Cproton::PN_BOOL, "bool", [TrueClass, FalseClass], "bool")
-    UBYTE      = Mapping.new(Cproton::PN_UBYTE, "ubyte")
-    BYTE       = Mapping.new(Cproton::PN_BYTE, "byte")
-    USHORT     = Mapping.new(Cproton::PN_USHORT, "ushort")
-    SHORT      = Mapping.new(Cproton::PN_SHORT, "short")
-    UINT       = Mapping.new(Cproton::PN_UINT, "uint")
-    INT        = Mapping.new(Cproton::PN_INT, "int")
-    CHAR       = Mapping.new(Cproton::PN_CHAR, "char")
-    ULONG      = Mapping.new(Cproton::PN_ULONG, "ulong")
-    LONG       = Mapping.new(Cproton::PN_LONG, "long", [Fixnum, Bignum])
-    TIMESTAMP  = Mapping.new(Cproton::PN_TIMESTAMP, "timestamp", [Date, Time])
-    FLOAT      = Mapping.new(Cproton::PN_FLOAT, "float")
-    DOUBLE     = Mapping.new(Cproton::PN_DOUBLE, "double", [Float])
-    DECIMAL32  = Mapping.new(Cproton::PN_DECIMAL32, "decimal32")
-    DECIMAL64  = Mapping.new(Cproton::PN_DECIMAL64, "decimal64")
-    DECIMAL128 = Mapping.new(Cproton::PN_DECIMAL128, "decimal128")
-    UUID       = Mapping.new(Cproton::PN_UUID, "uuid")
-    BINARY     = Mapping.new(Cproton::PN_BINARY, "binary")
-    STRING     = Mapping.new(Cproton::PN_STRING, "string", [String, Symbol,
-                                                           UTFString,
-                                                           BinaryString])
-
-    class << STRING # :nodoc:
-      def put(data, value)
-        # if we have a symbol then convert it to a string
-        value = value.to_s if value.is_a?(Symbol)
-
-        isutf = false
-
-        if value.is_a?(Qpid::Proton::UTFString)
-          isutf = true
-        else
-          # For Ruby 1.8 we will just treat all strings as binary.
-          # For Ruby 1.9+ we can check the encoding first to see what it is
-          if RUBY_VERSION >= "1.9"
-            # If the string is ASCII-8BIT then treat is as binary. Otherwise,
-            # try to convert it to UTF-8 and, if successful, send as that.
-            if value.encoding != Encoding::ASCII_8BIT &&
-                value.encode(Encoding::UTF_8).valid_encoding?
-              isutf = true
-            end
-          end
-        end
-
-        data.string = value if isutf
-        data.binary = value if !isutf
-
-      end
-    end
-
-    SYMBOL     = Mapping.new(Cproton::PN_SYMBOL, "symbol")
-    DESCRIBED  = Mapping.new(Cproton::PN_DESCRIBED, "described", [Qpid::Proton::Described], "get_described")
-    ARRAY      = Mapping.new(Cproton::PN_ARRAY, "array", nil, "get_array")
-    LIST       = Mapping.new(Cproton::PN_LIST, "list", [::Array], "get_array")
-    MAP        = Mapping.new(Cproton::PN_MAP, "map", [::Hash], "get_map")
-
-    class << MAP # :nodoc:
-      def put(data, map, options = {})
-        data.put_map
-        data.enter
-        map.each_pair do |key, value|
-          if options[:keys] == :SYMBOL
-            SYMBOL.put(data, key)
-          else
-            Mapping.for_class(key.class).put(data, key)
-          end
-
-          if value.nil?
-            data.null
-          else
-            Mapping.for_class(value.class).put(data, value)
-          end
-        end
-        data.exit
-      end
-    end
-
-  end
-
-end

data/lib/qpid_proton/message.rb

@@ -1,621 +0,0 @@
-#--
-# Licensed to the Apache Software Foundation (ASF) under one
-# or more contributor license agreements.  See the NOTICE file
-# distributed with this work for additional information
-# regarding copyright ownership.  The ASF licenses this file
-# to you under the Apache License, Version 2.0 (the
-# "License"); you may not use this file except in compliance
-# with the License.  You may obtain a copy of the License at
-#
-#   http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing,
-# software distributed under the License is distributed on an
-# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
-# KIND, either express or implied.  See the License for the
-# specific language governing permissions and limitations
-# under the License.
-#++
-
-module Qpid # :nodoc:
-
-  module Proton # :nodoc:
-
-    # A Message represents an addressable quantity of data.
-    #
-    # ==== Message Body
-    #
-    # The message body can be set using the #body= method. The message will
-    # then attempt to determine how exactly to encode the content.
-    #
-    # ==== Examples
-    #
-    # To create a message for sending:
-    #
-    #   # send a simple text message
-    #   msg = Qpid::Proton::Message.new
-    #   msg.body = "STATE: update"
-    #
-    #   # send a binary chunk of data
-    #   data = File.binread("/home/qpid/binfile.tar.gz")
-    #   msg = Qpid::Proton::Message.new
-    #   msg.body = Qpid::Proton::BinaryString.new(data)
-    #
-    class Message
-
-      # Decodes a message from supplied AMQP data and returns the number
-      # of bytes consumed.
-      #
-      # ==== Options
-      #
-      # * encoded - the encoded data
-      #
-      def decode(encoded)
-        check(Cproton.pn_message_decode(@impl, encoded, encoded.length))
-
-        post_decode
-      end
-
-      def post_decode # :nodoc:
-        # decode elements from the message
-        @properties = {}
-        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
-        if props.next
-          @properties = props.type.get(props)
-        end
-        @instructions = nil
-        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
-        if insts.next
-          @instructions = insts.type.get(insts)
-        end
-        @annotations = nil
-        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
-        if annts.next
-          @annotations = annts.type.get(annts)
-        end
-        @body = nil
-        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
-        if body.next
-          @body = body.type.get(body)
-        end
-      end
-
-      # Encodes the message.
-      def encode
-        pre_encode
-        size = 16
-        loop do
-          error, data = Cproton::pn_message_encode(@impl, size)
-          if error == Qpid::Proton::Error::OVERFLOW
-            size *= 2
-          else
-            check(error)
-            return data
-          end
-        end
-      end
-
-      def pre_encode # :nodoc:
-        # encode elements from the message
-        props = Qpid::Proton::Data.new(Cproton::pn_message_properties(@impl))
-        props.clear
-        Qpid::Proton::Mapping.for_class(@properties.class).put(props, @properties) unless @properties.empty?
-        insts = Qpid::Proton::Data.new(Cproton::pn_message_instructions(@impl))
-        insts.clear
-        if !@instructions.nil?
-          mapping = Qpid::Proton::Mapping.for_class(@instructions.class)
-          mapping.put(insts, @instructions)
-        end
-        annts = Qpid::Proton::Data.new(Cproton::pn_message_annotations(@impl))
-        annts.clear
-        if !@annotations.nil?
-          mapping = Qpid::Proton::Mapping.for_class(@annotations.class)
-          mapping.put(annts, @annotations, :keys => :SYMBOL)
-        end
-        body = Qpid::Proton::Data.new(Cproton::pn_message_body(@impl))
-        body.clear
-        if !@body.nil?
-          mapping = Qpid::Proton::Mapping.for_class(@body.class)
-          mapping.put(body, @body)
-        end
-      end
-
-      # Creates a new +Message+ instance.
-      def initialize
-        @impl = Cproton.pn_message
-        ObjectSpace.define_finalizer(self, self.class.finalize!(@impl))
-        @properties = {}
-        @instructions = {}
-        @annotations = {}
-        @body = nil
-      end
-
-      def to_s
-        tmp = Cproton.pn_string("")
-        Cproton.pn_inspect(@impl, tmp)
-        result = Cproton.pn_string_get(tmp)
-        Cproton.pn_free(tmp)
-        return result
-      end
-
-      # Invoked by garbage collection to clean up resources used
-      # by the underlying message implementation.
-      def self.finalize!(impl) # :nodoc:
-        proc {
-          Cproton.pn_message_free(impl)
-        }
-      end
-
-      # Returns the underlying message implementation.
-      def impl # :nodoc:
-        @impl
-      end
-
-      # Clears the state of the +Message+. This allows a single instance of
-      # +Message+ to be reused.
-      #
-      def clear
-        Cproton.pn_message_clear(@impl)
-        @properties.clear unless @properties.nil?
-        @instructions.clear unless @instructions.nil?
-        @annotations.clear unless @annotations.nil?
-        @body = nil
-      end
-
-      # Returns the most recent error number.
-      #
-      def errno
-        Cproton.pn_message_errno(@impl)
-      end
-
-      # Returns the most recent error message.
-      #
-      def error
-        Cproton.pn_error_text(Cproton.pn_message_error(@impl))
-      end
-
-      # Returns whether there is currently an error reported.
-      #
-      def error?
-        !Cproton.pn_message_errno(@impl).zero?
-      end
-
-      # Sets the durable flag.
-      #
-      # See ::durable for more details on message durability.
-      #
-      # ==== Options
-      #
-      # * state - the durable state
-      #
-      def durable=(state)
-        raise TypeError.new("state cannot be nil") if state.nil?
-        Cproton.pn_message_set_durable(@impl, state)
-      end
-
-      # Returns the durable property.
-      #
-      # The durable property indicates that the emessage should be held durably
-      # by any intermediaries taking responsibility for the message.
-      #
-      # ==== Examples
-      #
-      #  msg = Qpid::Proton::Message.new
-      #  msg.durable = true
-      #
-      def durable
-        Cproton.pn_message_is_durable(@impl)
-      end
-
-      # Sets the priority.
-      #
-      # +NOTE:+ Priority values are limited to the range [0,255].
-      #
-      # ==== Options
-      #
-      # * priority - the priority value
-      #
-      def priority=(priority)
-        raise TypeError.new("invalid priority: #{priority}") if priority.nil? || !([Float, Fixnum].include?(priority.class))
-        raise RangeError.new("priority out of range: #{priority}") if ((priority > 255) || (priority < 0))
-        Cproton.pn_message_set_priority(@impl, priority.floor)
-      end
-
-      # Returns the priority.
-      #
-      def priority
-        Cproton.pn_message_get_priority(@impl)
-      end
-
-      # Sets the time-to-live for the message.
-      #
-      # ==== Options
-      #
-      # * time - the time in milliseconds
-      #
-      def ttl=(time)
-        raise TypeError.new("invalid ttl: #{time}") if time.nil? || !([Float, Fixnum].include?(time.class))
-        raise RangeError.new("time out of range: #{time}") if ((time < 0))
-        Cproton.pn_message_set_ttl(@impl, time.floor)
-      end
-
-      # Returns the time-to-live, in milliseconds.
-      #
-      def ttl
-        Cproton.pn_message_get_ttl(@impl)
-      end
-
-      # Sets whether this is the first time the message was acquired.
-      #
-      # See ::first_acquirer? for more details.
-      #
-      # ==== Options
-      #
-      # * state - true if claiming the message
-      #
-      def first_acquirer=(state)
-        raise TypeError.new("invalid state: #{state}") if state.nil? || !([TrueClass, FalseClass].include?(state.class))
-        Cproton.pn_message_set_first_acquirer(@impl, state)
-      end
-
-      # Sets the delivery count for the message.
-      #
-      # See ::delivery_count for more details.
-      #
-      # ==== Options
-      #
-      # * count - the delivery count
-      #
-      def delivery_count=(count)
-        raise ArgumentError.new("invalid count: #{count}") if count.nil? || !([Float, Fixnum].include?(count.class))
-        raise RangeError.new("count out of range: #{count}") if count < 0
-
-        Cproton.pn_message_set_delivery_count(@impl, count.floor)
-      end
-
-      # Returns the delivery count for the message.
-      #
-      # This is the number of delivery attempts for the given message.
-      #
-      def delivery_count
-        Cproton.pn_message_get_delivery_count(@impl)
-      end
-
-      # Returns whether this is the first acquirer.
-      #
-      #
-      def first_acquirer?
-        Cproton.pn_message_is_first_acquirer(@impl)
-      end
-
-      # Sets the message id.
-      #
-      # ==== Options
-      #
-      # * id = the id
-      #
-      def id=(id)
-        Cproton.pn_message_set_id(@impl, id)
-      end
-
-      # Returns the message id.
-      #
-      def id
-        Cproton.pn_message_get_id(@impl)
-      end
-
-      # Sets the user id.
-      #
-      # ==== Options
-      #
-      # * id - the user id
-      #
-      def user_id=(id)
-        Cproton.pn_message_set_user_id(@impl, id)
-      end
-
-      # Returns the user id.
-      #
-      def user_id
-        Cproton.pn_message_get_user_id(@impl)
-      end
-
-      # Sets the destination address.
-      #
-      # ==== Options
-      #
-      # * address - the address
-      #
-      def address=(address)
-        Cproton.pn_message_set_address(@impl, address)
-      end
-
-      # Returns the destination address.
-      #
-      def address
-        Cproton.pn_message_get_address(@impl)
-      end
-
-      # Sets the subject.
-      #
-      # ==== Options
-      #
-      # * subject - the subject
-      #
-      def subject=(subject)
-        Cproton.pn_message_set_subject(@impl, subject)
-      end
-
-      # Returns the subject
-      #
-      def subject
-        Cproton.pn_message_get_subject(@impl)
-      end
-
-      # Sets the reply-to address.
-      #
-      # ==== Options
-      #
-      # * address - the reply-to address
-      #
-      def reply_to=(address)
-        Cproton.pn_message_set_reply_to(@impl, address)
-      end
-
-      # Returns the reply-to address
-      #
-      def reply_to
-        Cproton.pn_message_get_reply_to(@impl)
-      end
-
-      # Sets the correlation id.
-      #
-      # ==== Options
-      #
-      # * id - the correlation id
-      #
-      def correlation_id=(id)
-        Cproton.pn_message_set_correlation_id(@impl, id)
-      end
-
-      # Returns the correlation id.
-      #
-      def correlation_id
-        Cproton.pn_message_get_correlation_id(@impl)
-      end
-
-      # Sets the message format.
-      #
-      # See MessageFormat for more details on formats.
-      #
-      # *Warning:* This method has been deprecated.
-      #
-      # ==== Options
-      #
-      # * format - the format
-      #
-      def format=(format)
-        raise TypeError.new("invalid message format: #{format}") if (format.nil? || !format.kind_of?(Qpid::Proton::MessageFormat))
-        Cproton.pn_message_set_format(@impl, format.value)
-      end
-
-      # Returns the message format
-      #
-      # *Warning:* This method has been deprecated.
-      #
-      # ==== Note
-      #
-      # This method is now deprecated.
-      #
-      def format
-        Qpid::Proton::MessageFormat.by_value(Cproton.pn_message_get_format(@impl))
-      end
-
-      # Sets the content type.
-      #
-      # ==== Options
-      #
-      # * content_type - the content type
-      #
-      def content_type=(content_type)
-        Cproton.pn_message_set_content_type(@impl, content_type)
-      end
-
-      # Returns the content type
-      #
-      def content_type
-        Cproton.pn_message_get_content_type(@impl)
-      end
-
-      # Sets the content encoding type.
-      #
-      # ==== Options
-      #
-      # * encoding - the content encoding
-      #
-      def content_encoding=(encoding)
-        Cproton.pn_message_set_content_encoding(@impl, encoding)
-      end
-
-      # Returns the content encoding type.
-      #
-      def content_encoding
-        Cproton.pn_message_get_content_encoding(@impl)
-      end
-
-      # Sets the expiration time.
-      #
-      # ==== Options
-      #
-      # * time - the expiry time
-      #
-      def expires=(time)
-        raise TypeError.new("invalid expiry time: #{time}") if time.nil?
-        raise ArgumentError.new("expiry time cannot be negative: #{time}") if time < 0
-        Cproton.pn_message_set_expiry_time(@impl, time)
-      end
-
-      # Returns the expiration time.
-      #
-      def expires
-        Cproton.pn_message_get_expiry_time(@impl)
-      end
-
-      # Sets the creation time.
-      #
-      # ==== Options
-      #
-      # * time - the creation time
-      #
-      def creation_time=(time)
-        raise TypeError.new("invalid time: #{time}") if time.nil?
-        raise ArgumentError.new("time cannot be negative") if time < 0
-        Cproton.pn_message_set_creation_time(@impl, time)
-      end
-
-      # Returns the creation time.
-      #
-      def creation_time
-        Cproton.pn_message_get_creation_time(@impl)
-      end
-
-      # Sets the group id.
-      #
-      # ==== Options
-      #
-      # * id - the group id
-      #
-      def group_id=(id)
-        Cproton.pn_message_set_group_id(@impl, id)
-      end
-
-      # Returns the group id.
-      #
-      def group_id
-        Cproton.pn_message_get_group_id(@impl)
-      end
-
-      # Sets the group sequence number.
-      #
-      # ==== Options
-      #
-      # * seq - the sequence number
-      #
-      def group_sequence=(seq)
-        raise TypeError.new("invalid seq: #{seq}") if seq.nil?
-        Cproton.pn_message_set_group_sequence(@impl, seq)
-      end
-
-      # Returns the group sequence number.
-      #
-      def group_sequence
-        Cproton.pn_message_get_group_sequence(@impl)
-      end
-
-      # Sets the reply-to group id.
-      #
-      # ==== Options
-      #
-      # * id - the id
-      #
-      def reply_to_group_id=(id)
-        Cproton.pn_message_set_reply_to_group_id(@impl, id)
-      end
-
-      # Returns the reply-to group id.
-      #
-      def reply_to_group_id
-        Cproton.pn_message_get_reply_to_group_id(@impl)
-      end
-
-      # Returns the list of property names for associated with this message.
-      #
-      # ==== Examples
-      #
-      #   msg.properties.each do |name|
-      #   end
-      #
-      def properties
-        @properties
-      end
-
-      # Replaces the entire set of properties with the specified hash.
-      #
-      def properties=(properties)
-        @properties = properties
-      end
-
-      # Assigns the value given to the named property.
-      #
-      # ==== Arguments
-      #
-      # * name - the property name
-      # * value - the property value
-      #
-      def []=(name, value)
-        @properties[name] = value
-      end
-
-      # Retrieves the value for the specified property name. If not found, then
-      # it returns nil.
-      #
-      def [](name)
-        @properties[name]
-      end
-
-      # Deletes the named property.
-      #
-      def delete_property(name)
-        @properties.delete(name)
-      end
-
-      # Returns the instructions for this message.
-      #
-      def instructions
-        @instructions
-      end
-
-      # Assigns instructions to this message.
-      #
-      def instructions=(instr)
-        @instructions = instr
-      end
-
-      # Returns the annotations for this message.
-      #
-      def annotations
-        @annotations
-      end
-
-      # Assigns annotations to this message.
-      #
-      def annotations=(annotations)
-        @annotations = annotations
-      end
-
-      # Returns the body property of the message.
-      #
-      def body
-        @body
-      end
-
-      # Assigns a new value to the body of the message.
-      #
-      def body=(body)
-        @body = body
-      end
-
-      private
-
-      def check(err) # :nodoc:
-        if err < 0
-          raise DataError, "[#{err}]: #{Cproton.pn_message_error(@impl)}"
-        else
-          return err
-        end
-      end
-    end
-
-  end
-
-end