Class: Mongo::Protocol::Message Abstract

# File 'lib/mongo/protocol/message.rb', line 432

def self.deserialize_array(message, io, field, options = {})
  elements = []
  count = message.instance_variable_get(field[:multi])
  count.times { elements << field[:type].deserialize(io, options) }
  message.instance_variable_set(field[:name], elements)
end

# File 'lib/mongo/protocol/message.rb', line 450

def self.deserialize_field(message, io, field, options = {})
  message.instance_variable_set(
    field[:name],
    field[:type].deserialize(io, options)
  )
end

# File 'lib/mongo/protocol/message.rb', line 388

def self.deserialize_header(io)
  Header.deserialize(io)
end

# File 'lib/mongo/protocol/message.rb', line 407

def self.field(name, type, multi = false)
  fields << {
    :name => "@#{name}".intern,
    :type => type,
    :multi => multi
  }

  attr_reader name
end

# File 'lib/mongo/protocol/message.rb', line 340

def self.fields
  @fields ||= []
end

# File 'lib/mongo/protocol/message.rb', line 86

attr_reader :request_id

# File 'lib/mongo/protocol/message.rb', line 127

private def compress_if_possible(command_name, compressor, zlib_compression_level)
  if compressor && compression_allowed?(command_name)
    Compressed.new(self, compressor, zlib_compression_level)
  else
    self
  end
end

# File 'lib/mongo/protocol/message.rb', line 303

alias_method :eql?, :==

# File 'lib/mongo/protocol/message.rb', line 333

def fields
  self.class.fields
end

# File 'lib/mongo/protocol/message.rb', line 308

def hash
  fields.map { |field| instance_variable_get(field[:name]) }.hash
end

# File 'lib/mongo/protocol/message.rb', line 173

def maybe_add_server_api(server_api)
  raise Error::ServerApiNotSupported, "Server API parameters cannot be sent to pre-3.6 MongoDB servers. Please remove the :server_api parameter from Client options or use MongoDB 3.6 or newer"
end

# File 'lib/mongo/protocol/message.rb', line 112

def maybe_compress(compressor, zlib_compression_level = nil)
  self
end

# File 'lib/mongo/protocol/message.rb', line 152

def maybe_decrypt(context)
  # TODO determine if we should be decrypting data coming from pre-4.2
  # servers, potentially using legacy wire protocols. If so we need
  # to implement decryption for those wire protocols as our current
  # encryption/decryption code is OP_MSG-specific.
  self
end

# File 'lib/mongo/protocol/message.rb', line 168

def maybe_encrypt(connection, context)
  # Do nothing if the Message subclass has not implemented this method
  self
end

# File 'lib/mongo/protocol/message.rb', line 142

def maybe_inflate
  self
end

# File 'lib/mongo/protocol/message.rb', line 177

private def merge_sections
  cmd = if @sections.length > 1
    cmd = @sections.detect { |section| section[:type] == 0 }[:payload]
    identifier = @sections.detect { |section| section[:type] == 1}[:payload][:identifier]
    cmd.merge(identifier.to_sym =>
      @sections.select { |section| section[:type] == 1 }.
        map { |section| section[:payload][:sequence] }.
        inject([]) { |arr, documents| arr + documents }
    )
  elsif @sections.first[:payload]
    @sections.first[:payload]
  else
    @sections.first
  end
  if cmd.nil?
    raise "The command should never be nil here"
  end
  cmd
end

# File 'lib/mongo/protocol/message.rb', line 326

def number_returned; 0; end

# File 'lib/mongo/protocol/message.rb', line 201

def serialize(buffer = BSON::ByteBuffer.new, max_bson_size = nil, bson_overhead = nil)
  max_size =
    if max_bson_size && bson_overhead
      max_bson_size + bson_overhead
    elsif max_bson_size
      max_bson_size
    else
      nil
    end

  start = buffer.length
  serialize_header(buffer)
  serialize_fields(buffer, max_size)
  buffer.replace_int32(start, buffer.length - start)
end

# File 'lib/mongo/protocol/message.rb', line 348

def serialize_fields(buffer, max_bson_size = nil)
  fields.each do |field|
    value = instance_variable_get(field[:name])
    if field[:multi]
      value.each do |item|
        if field[:type].respond_to?(:size_limited?)
          field[:type].serialize(buffer, item, max_bson_size)
        else
          field[:type].serialize(buffer, item)
        end
      end
    else
      if field[:type].respond_to?(:size_limited?)
        field[:type].serialize(buffer, value, max_bson_size)
      else
        field[:type].serialize(buffer, value)
      end
    end
  end
end

# File 'lib/mongo/protocol/message.rb', line 380

def serialize_header(buffer)
  Header.serialize(buffer, [0, request_id, 0, op_code])
end

# File 'lib/mongo/protocol/message.rb', line 317

def set_request_id
  @request_id = self.class.next_id
end

# File 'lib/mongo/protocol/message.rb', line 217

alias_method :to_s, :serialize