qpid_proton 0.18.1 → 0.19.0

data/lib/types/array.rb

@@ -1,4 +1,3 @@
-#--
 # 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
@@ -15,158 +14,102 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 #--
 # Patch the Array class to provide methods for adding its contents
-# to a Qpid::Proton::Data instance.
+# to a Qpid::Proton::Codec::Data instance.
 #++
 
-module Qpid::Proton::Types
-
-  # Holds the information for an AMQP Array compound type.
-  #
-  # It holds the type for the array and the descriptor if the
-  # array is described.
-  #
-  # @private
-  #
-  class ArrayHeader
-    attr_reader :type
-    attr_reader :descriptor
-
-    def initialize(type, descriptor = nil)
-      @type = type
-      @descriptor = descriptor
-    end
-
-    # Returns true if the array is described.
-    def described?
-      !@descriptor.nil?
-    end
+module Qpid::Proton
+  module Types
 
-    def ==(that)
-      ((@type == that.type) && (@descriptor == that.descriptor))
+    # @deprecated use {UniformArray}
+    class ArrayHeader
+      def initialize(type, descriptor = nil)
+        Util::Deprecation.deprecated ArrayHeader, "UniformArray"
+        @type, @descriptor = Codec::Mapping[type], descriptor
+      end
+      attr_reader :type, :descriptor
+      def described?() !@descriptor.nil?; end
+      def <=>(x) [@type, @descriptor] <=> [x.type, x.descriptor]; end
+      include Comparable
     end
-  end
 
-end
+    # *Unsettled API* - An array that is converted to/from an AMQP array of uniform element type.
+    # A plain ruby +::Array+ is converted to/from an AMQP list, which can contain mixed type elements.
+    # If invalid elements are included, then {TypeError} will be raised when encoding to AMQP.
+    class UniformArray < ::Array
+
+      # Construct a uniform array, which will be converted to an AMQP array.
+      # A plain ruby +::Array+ is converted to/from an AMQP list, containing mixed type elements.
+      #
+      # @param type [Type] Elements must be convertible to this AMQP type.
+      # @param elements [Enumerator] Initial elements for the array
+      # @param descriptor [Object] Optional array descriptor
+      def initialize(type, elements=nil, descriptor=nil)
+        @type, @descriptor = type, descriptor
+        raise ArgumentError, "no type specified for array" if @type.nil?
+        super elements if elements
+      end
 
-# @private
-class Array # :nodoc:
+      # @deprecated backwards compatibility  {UniformArray}
+      def proton_array_header
+        @proton_array_header ||= ArrayHeader.new(@type, @descriptor) # Deprecated
+      end
 
-  # Used to declare an array as an AMQP array.
-  #
-  # The value, if defined, is an instance of Qpid::Proton::Types::ArrayHeader
-  attr_accessor :proton_array_header
+      # @return [Type] Array elements must be convertible to this AMQP type
+      attr_reader :type
 
-  # Returns true if the array is the a Proton described type.
-  def proton_described?
-    !@proton_array_header.nil? && @proton_array_header.described?
-  end
+      # @return [Object] Optional descriptor.
+      attr_reader :descriptor
 
-  # Puts the elements of the array into the specified Qpid::Proton::Data object.
-  def proton_put(data)
-    raise TypeError, "data object cannot be nil" if data.nil?
+      def inspect() "#{self.class.name}<#{type}>#{super}"; end
 
-    if @proton_array_header.nil?
-      proton_put_list(data)
-    else
-      proton_put_array(data)
+      def <=>(x)
+        ret = [@type, @descriptor] <=> [x.type, x.descriptor]
+        ret == 0 ? super : ret
+      end
     end
   end
+end
 
-  private
-
-  def proton_put_list(data)
-    # create a list, then enter it and add each element
-    data.put_list
-    data.enter
-    each do |element|
-      # get the proton type for the element
-      mapping = Qpid::Proton::Codec::Mapping.for_class(element.class)
-      # add the element
-      mapping.put(data, element)
-    end
-    # exit the list
-    data.exit
+# {Array} is converted to/from an AMQP list, which is allowed to hold mixed-type elements.
+# Use  {UniformArray} to convert/from an AMQP array with uniform element type.
+class ::Array
+  # @deprecated use  {UniformArray}
+  def proton_array_header
+    Qpid::Proton::Util::Deprecation.deprecated __method__, UniformArray
+    @proton_array_header
   end
 
-  def proton_put_array(data)
-    data.put_array(@proton_array_header.described?, @proton_array_header.type)
-    data.enter
-    if @proton_array_header.described?
-      data.symbol = @proton_array_header.descriptor
-    end
-
-    each do |element|
-      @proton_array_header.type.put(data, element)
-    end
-
-    data.exit
+  # @deprecated use  {UniformArray}
+  def proton_array_header=(h)
+    Qpid::Proton::Util::Deprecation.deprecated __method__, UniformArray
+    @proton_array_header= h
   end
 
-  class << self
-
-    # Gets the elements of an array or list out of the specified
-    # Qpid::Proton::Data object.
-    def proton_get(data)
-      raise TypeError, "can't convert nil into Qpid::Proton::Data" if data.nil?
-
-      type = data.type
-
-      if type == Qpid::Proton::Codec::LIST
-        result = proton_get_list(data)
-      elsif type == Qpid::Proton::Codec::ARRAY
-        result = proton_get_array(data)
-      else
-        raise TypeError, "element is not a list and not an array"
-      end
-    end
-
-    private
-
-    def proton_get_list(data)
-      size = data.list
-      raise TypeError, "not a list" unless data.enter
-      elements = []
-      (0...size).each do
-        data.next
-        type = data.type
-        raise TypeError, "missing next element in list" unless type
-        elements << type.get(data)
-      end
-      data.exit
-      return elements
-    end
-
-    def proton_get_array(data)
-      count, described, type = data.array
-
-      raise TypeError, "not an array" unless data.enter
-      elements = []
-
-      descriptor = nil
-
-      if described
-        data.next
-        descriptor = data.symbol
-      end
+  # @deprecated use  {UniformArray}
+  def proton_described?()
+    Qpid::Proton::Util::Deprecation.deprecated __method__, UniformArray
+    @proton_array_header && @proton_array_header.described?
+  end
 
-      elements.proton_array_header = Qpid::Proton::Types::ArrayHeader.new(type, descriptor)
-      (0...count).each do |which|
-        if data.next
-          etype = data.type
-          raise TypeError, "missing next element in array" unless etype
-          raise TypeError, "invalid array element: #{etype}" unless etype == type
-          elements << type.get(data)
-        end
-      end
-      data.exit
-      return elements
+  # @deprecated
+  def proton_put(data)
+    Qpid::Proton::Util::Deprecation.deprecated __method__, "Codec::Data#array=, Codec::Data#list="
+    raise TypeError, "nil data" unless data
+    if @proton_array_header && @proton_array_header.type
+      data.array = self
+    else
+      data.list = self
     end
-
   end
 
+  # @deprecated
+  def self.proton_get(data)
+    Qpid::Proton::Util::Deprecation.deprecated __method__, "Codec::Data#list"
+    data.list
+  end
 end
 

data/lib/types/described.rb

@@ -1,4 +1,3 @@
-#--
 # 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
@@ -15,49 +14,8 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
 
-module Qpid::Proton::Types
-
-  # @private
-  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::Types::Described) &&
-       (self.descriptor == that.descriptor) &&
-       (self.value == that.value))
-    end
-
-    def to_s # :nodoc:
-      "descriptor=#{descriptor} value=#{value}"
-    end
-
-  end
 
+module Qpid::Proton::Types
+  Described = Struct.new(:descriptor, :value)
 end

data/lib/types/hash.rb

@@ -1,4 +1,3 @@
-#--
 # 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
@@ -15,73 +14,37 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 #--
 # Patch the Hash class to provide methods for adding its contents
-# to a Qpid::Proton::Data instance.
+# to a Qpid::Proton::Codec::Data instance.
 #++
 
 # @private
 class Hash # :nodoc:
 
-  # Places the contents of the hash into the specified data object.
-  #
-  # ==== Arguments
-  #
-  # * data - the Qpid::Proton::Data instance
-  #
-  # ==== Examples
-  #
-  #   data = Qpid::Proton::Data.new
-  #   values = {:foo => :bar}
-  #   values.proton_data_put(data)
-  #
+  # @deprecated
   def proton_data_put(data)
-    raise TypeError, "data object cannot be nil" if data.nil?
-
-    data.put_map
-    data.enter
-
-    each_pair do |key, value|
-      type = Qpid::Proton::Codec::Mapping.for_class(key.class)
-      type.put(data, key)
-      type = Qpid::Proton::Codec::Mapping.for_class(value.class)
-      type.put(data, value)
-    end
-
-    data.exit
+    Qpid::Proton::Util::Deprecation.deprecated(__method__, "Codec::Data#map=")
+    data.map = self
   end
 
-  class << self
-
-    def proton_data_get(data)
-      raise TypeError, "data object cannot be nil" if data.nil?
-
-      type = data.type
-
-      raise TypeError, "element is not a map" unless type == Qpid::Proton::Codec::MAP
-
-      count = data.map
-      result = {}
-
-      data.enter
-
-      (0...(count/2)).each do
-        data.next
-        type = data.type
-        key = type.get(data)
-        data.next
-        type = data.type
-        value = type.get(data)
-        result[key] = value
-      end
-
-      data.exit
-
-      return result
-    end
+  # @deprecated
+  def self.proton_data_get(data)
+    Qpid::Proton::Util::Deprecation.deprecated(__method__, "Codec::Data#map")
+    data.map
+  end
+end
 
+module Qpid::Proton::Types
+  # @private
+  def self.symbol_keys(h)
+    h && h.reduce({}) { |x, (k, v)| x[k.to_sym] = v; x }
   end
 
+  # @private
+  def self.symbol_array(a)
+    a && UniformArray.new(SYMBOL, a.collect { |v| v.to_sym })
+  end
 end

data/lib/types/strings.rb

@@ -1,4 +1,3 @@
-#--
 # 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
@@ -15,7 +14,7 @@
 # KIND, either express or implied.  See the License for the
 # specific language governing permissions and limitations
 # under the License.
-#++
+
 
 module Qpid::Proton::Types
 

data/lib/types/type.rb

@@ -0,0 +1,68 @@
+#--
+# 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::Proton
+  module Types
+
+    # Represents an AMQP Type
+    class Type
+      private
+      @@builtin = {}
+      def initialize(code) @code = code; @@builtin[code] = self; end
+
+      public
+      def self.try_convert(code) code.is_a?(Type) ? code : @@builtin[code]; end
+      def self.[](code) try_convert(code) or raise IndexError, "unknown type code #{code}"; end
+
+      attr_reader :code
+      def name() Cproton.pn_type_name(@code); end
+      alias to_s name
+      def <=>(x) @code <=> x; end
+      def hash() @code.hash; end
+    end
+
+    # @!group
+    NULL       = Type.new(Cproton::PN_NULL)
+    BOOL       = Type.new(Cproton::PN_BOOL)
+    UBYTE      = Type.new(Cproton::PN_UBYTE)
+    BYTE       = Type.new(Cproton::PN_BYTE)
+    USHORT     = Type.new(Cproton::PN_USHORT)
+    SHORT      = Type.new(Cproton::PN_SHORT)
+    UINT       = Type.new(Cproton::PN_UINT)
+    INT        = Type.new(Cproton::PN_INT)
+    CHAR       = Type.new(Cproton::PN_CHAR)
+    ULONG      = Type.new(Cproton::PN_ULONG)
+    LONG       = Type.new(Cproton::PN_LONG)
+    TIMESTAMP  = Type.new(Cproton::PN_TIMESTAMP)
+    FLOAT      = Type.new(Cproton::PN_FLOAT)
+    DOUBLE     = Type.new(Cproton::PN_DOUBLE)
+    DECIMAL32  = Type.new(Cproton::PN_DECIMAL32)
+    DECIMAL64  = Type.new(Cproton::PN_DECIMAL64)
+    DECIMAL128 = Type.new(Cproton::PN_DECIMAL128)
+    UUID       = Type.new(Cproton::PN_UUID)
+    BINARY     = Type.new(Cproton::PN_BINARY)
+    STRING     = Type.new(Cproton::PN_STRING)
+    SYMBOL     = Type.new(Cproton::PN_SYMBOL)
+    DESCRIBED  = Type.new(Cproton::PN_DESCRIBED)
+    ARRAY      = Type.new(Cproton::PN_ARRAY)
+    LIST       = Type.new(Cproton::PN_LIST)
+    MAP        = Type.new(Cproton::PN_MAP)
+    #@!endgroup
+  end
+end