class Protobuf::Message

Public Class Methods

new(fields = {}) { |self| ... } click to toggle source

Constructor

# File lib/protobuf/message.rb, line 38
def initialize(fields = {})
  @values = {}
  fields.to_hash.each do |name, value|
    set_field(name, value, true)
  end

  yield self if block_given?
end
to_json() click to toggle source

Class Methods

# File lib/protobuf/message.rb, line 30
def self.to_json
  name
end

Public Instance Methods

==(other) click to toggle source
# File lib/protobuf/message.rb, line 144
def ==(other)
  return false unless other.is_a?(self.class)
  each_field do |field, value|
    return false unless value == other[field.name]
  end
  true
end
[](name) click to toggle source
# File lib/protobuf/message.rb, line 152
def [](name)
  field = self.class.get_field(name, true)

  fail ArgumentError, "invalid field name=#{name.inspect}" unless field

  if field.repeated?
    @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
  elsif @values.key?(field.fully_qualified_name)
    @values[field.fully_qualified_name]
  else
    field.default_value
  end
end
[]=(name, value) click to toggle source
# File lib/protobuf/message.rb, line 166
def []=(name, value)
  set_field(name, value, true)
end
clear!() click to toggle source

Public Instance Methods

# File lib/protobuf/message.rb, line 51
def clear!
  @values.delete_if do |_, value|
    if value.is_a?(::Protobuf::Field::FieldArray)
      value.clear
      false
    else
      true
    end
  end
  self
end
clone() click to toggle source
Calls superclass method
# File lib/protobuf/message.rb, line 63
def clone
  copy_to(super, :clone)
end
dup() click to toggle source
Calls superclass method
# File lib/protobuf/message.rb, line 67
def dup
  copy_to(super, :dup)
end
each_field() { |field, value| ... } click to toggle source

Iterate over every field, invoking the given block

# File lib/protobuf/message.rb, line 73
def each_field
  return to_enum(:each_field) unless block_given?

  self.class.all_fields.each do |field|
    value = self[field.name]
    yield(field, value)
  end
end
each_field_for_serialization() { |field, value| ... } click to toggle source
# File lib/protobuf/message.rb, line 82
def each_field_for_serialization
  self.class.all_fields.each do |field|
    value = @values[field.fully_qualified_name]
    if value.nil?
      fail ::Protobuf::SerializationError, "Required field #{self.class.name}##{field.name} does not have a value." if field.required?
      next
    end

    yield(field, value)
  end
end
field?(name) click to toggle source
# File lib/protobuf/message.rb, line 94
def field?(name)
  field = self.class.get_field(name, true)
  return false if field.nil?
  if field.repeated?
    @values.key?(field.fully_qualified_name) && @values[field.fully_qualified_name].present?
  else
    @values.key?(field.fully_qualified_name)
  end
end
inspect() click to toggle source
# File lib/protobuf/message.rb, line 105
def inspect
  attrs = self.class.fields.map do |field|
    [field.name, self[field.name].inspect].join('=')
  end.join(' ')

  "#<#{self.class} #{attrs}>"
end
respond_to_and_has?(key)
Alias for: respond_to_has?
respond_to_and_has_and_present?(key)
respond_to_and_has_present?(key)
respond_to_has?(key) click to toggle source
# File lib/protobuf/message.rb, line 113
def respond_to_has?(key)
  respond_to?(key) && field?(key)
end
respond_to_has_and_present?(key) click to toggle source
# File lib/protobuf/message.rb, line 117
def respond_to_has_and_present?(key)
  respond_to_has?(key) &&
    (self[key].present? || [true, false].include?(self[key]))
end
respond_to_has_present?(key)
responds_to_and_has?(key)
Alias for: respond_to_has?
responds_to_and_has_and_present?(key)
responds_to_and_has_present?(key)
responds_to_has?(key)
Alias for: respond_to_has?
responds_to_has_present?(key)
to_hash() click to toggle source

Return a hash-representation of the given fields for this message type.

# File lib/protobuf/message.rb, line 123
def to_hash
  result = {}

  @values.each_key do |field_name|
    value = self[field_name]
    field = self.class.get_field(field_name, true)
    hashed_value = value.respond_to?(:to_hash_value) ? value.to_hash_value : value
    result[field.name] = hashed_value
  end

  result
end
Also aliased as: to_hash_value, to_proto_hash
to_hash_value()

Instance Aliases

Alias for: to_hash
to_json(options = {}) click to toggle source
# File lib/protobuf/message.rb, line 136
def to_json(options = {})
  to_hash.to_json(options)
end
to_proto() click to toggle source
# File lib/protobuf/message.rb, line 140
def to_proto
  self
end
to_proto_hash()
Alias for: to_hash
unknown() click to toggle source

Includes & Extends

# File lib/protobuf/message.rb, line 22
extend ::Protobuf::Message::Fields

Private Instance Methods

copy_to(object, method) click to toggle source
# File lib/protobuf/message.rb, line 229
def copy_to(object, method)
  duplicate = proc do |obj|
    case obj
    when Message, String then obj.__send__(method)
    else                      obj
    end
  end

  object.__send__(:initialize)
  @values.each do |name, value|
    if value.is_a?(::Protobuf::Field::FieldArray)
      object[name].replace(value.map { |v| duplicate.call(v) })
    else
      object[name] = duplicate.call(value)
    end
  end
  object
end
set_field(name, value, ignore_nil_for_repeated) click to toggle source

Private Instance Methods

# File lib/protobuf/message.rb, line 191
    def set_field(name, value, ignore_nil_for_repeated)
      if (field = self.class.get_field(name, true))
        if field.repeated?
          if value.nil? && ignore_nil_for_repeated
            ::Protobuf.deprecator.deprecation_warning("#{self.class}#[#{name}]=nil", "use an empty array instead of nil")
            return
          end
          unless value.is_a?(Array)
            fail TypeError, <<-TYPE_ERROR
                Expected repeated value of type '#{field.type_class}'
                Got '#{value.class}' for repeated protobuf field #{field.name}
            TYPE_ERROR
          end

          value = value.compact

          if value.empty?
            @values.delete(field.fully_qualified_name)
          else
            @values[field.fully_qualified_name] ||= ::Protobuf::Field::FieldArray.new(field)
            @values[field.fully_qualified_name].replace(value)
          end
        else
          if value.nil? # rubocop:disable Style/IfInsideElse
            @values.delete(field.fully_qualified_name)
          elsif field.acceptable?(value)
            @values[field.fully_qualified_name] = field.coerce!(value)
          else
            fail TypeError, "Unacceptable value #{value} for field #{field.name} of type #{field.type_class}"
          end
        end
      else
        unless ::Protobuf.ignore_unknown_fields?
          fail ::Protobuf::FieldNotDefinedError, name
        end
      end
    end