class MessagePack::Factory

Public Instance Methods

dump(v, *rest) click to toggle source
# File lib/msgpack/factory.rb, line 113
def dump(v, *rest)
  packer = packer(*rest)
  packer.write(v)
  packer.full_pack
end
Also aliased as: pack
load(src, param = nil) click to toggle source
# File lib/msgpack/factory.rb, line 99
def load(src, param = nil)
  unpacker = nil

  if src.is_a? String
    unpacker = unpacker(param)
    unpacker.feed(src)
  else
    unpacker = unpacker(src, param)
  end

  unpacker.full_unpack
end
Also aliased as: unpack
pack(v, *rest)
Alias for: dump
pool(size = 1, **options) click to toggle source
# File lib/msgpack/factory.rb, line 120
def pool(size = 1, **options)
  Pool.new(
    frozen? ? self : dup.freeze,
    size,
    options.empty? ? nil : options,
  )
end
register_type(type, klass, options = { packer: :to_msgpack_ext, unpacker: :from_msgpack_ext }) click to toggle source

see ext for other methods

# File lib/msgpack/factory.rb, line 5
def register_type(type, klass, options = { packer: :to_msgpack_ext, unpacker: :from_msgpack_ext })
  raise FrozenError, "can't modify frozen MessagePack::Factory" if frozen?

  if options
    options = options.dup
    case packer = options[:packer]
    when nil, Proc
      # all good
    when String, Symbol
      options[:packer] = packer.to_sym.to_proc
    when Method
      options[:packer] = packer.to_proc
    when packer.respond_to?(:call)
      options[:packer] = packer.method(:call).to_proc
    else
      raise ::TypeError, "expected :packer argument to be a callable object, got: #{packer.inspect}"
    end

    case unpacker = options[:unpacker]
    when nil, Proc
      # all good
    when String, Symbol
      options[:unpacker] = klass.method(unpacker).to_proc
    when Method
      options[:unpacker] = unpacker.to_proc
    when packer.respond_to?(:call)
      options[:unpacker] = unpacker.method(:call).to_proc
    else
      raise ::TypeError, "expected :unpacker argument to be a callable object, got: #{unpacker.inspect}"
    end
  end

  register_type_internal(type, klass, options)
end
registered_types(selector=:both) click to toggle source
{type: id, class: Class(or nil), packer: arg, unpacker: arg}, …
# File lib/msgpack/factory.rb, line 41
def registered_types(selector=:both)
  packer, unpacker = registered_types_internal
  # packer: Class -> [tid, proc, _flags]
  # unpacker: tid -> [klass, proc, _flags]

  list = []

  case selector
  when :both
    packer.each_pair do |klass, ary|
      type = ary[0]
      packer_proc = ary[1]
      unpacker_proc = nil
      if unpacker.has_key?(type)
        unpacker_proc = unpacker.delete(type)[1]
      end
      list << {type: type, class: klass, packer: packer_proc, unpacker: unpacker_proc}
    end

    # unpacker definition only
    unpacker.each_pair do |type, ary|
      list << {type: type, class: ary[0], packer: nil, unpacker: ary[1]}
    end

  when :packer
    packer.each_pair do |klass, ary|
      if ary[1]
        list << {type: ary[0], class: klass, packer: ary[1]}
      end
    end

  when :unpacker
    unpacker.each_pair do |type, ary|
      if ary[1]
        list << {type: type, class: ary[0], unpacker: ary[1]}
      end
    end

  else
    raise ArgumentError, "invalid selector #{selector}"
  end

  list.sort{|a, b| a[:type] <=> b[:type] }
end
type_registered?(klass_or_type, selector=:both) click to toggle source
# File lib/msgpack/factory.rb, line 86
def type_registered?(klass_or_type, selector=:both)
  case klass_or_type
  when Class
    klass = klass_or_type
    registered_types(selector).any?{|entry| klass <= entry[:class] }
  when Integer
    type = klass_or_type
    registered_types(selector).any?{|entry| type == entry[:type] }
  else
    raise ArgumentError, "class or type id"
  end
end
unpack(src, param = nil)
Alias for: load