Thrift::Struct_Union

Constants

CONTAINER_TYPES

Public Instance Methods

each_field() click to toggle source
# File lib/thrift/struct_union.rb, line 44
def each_field
  sorted_field_ids.each do |fid|
    data = struct_fields[fid]
    yield fid, data
  end
end
field_info(field) click to toggle source
# File lib/thrift/struct_union.rb, line 151
def field_info(field)
  { :type => field[:type],
    :class => field[:class],
    :key => field[:key],
    :value => field[:value],
    :element => field[:element] }
end
inspect_collection(collection, field_info) click to toggle source
# File lib/thrift/struct_union.rb, line 184
def inspect_collection(collection, field_info)
  buf = []
  collection.each do |k|
    buf << inspect_field(k, field_info[:element])
  end
  "[" + buf.join(", ") + "]"      
end
inspect_field(value, field_info) click to toggle source
# File lib/thrift/struct_union.rb, line 159
def inspect_field(value, field_info)
  if enum_class = field_info[:enum_class]
    "#{enum_class.const_get(:VALUE_MAP)[value]} (#{value})"
  elsif value.is_a? Hash 
    if field_info[:type] == Types::MAP
      map_buf = []
      value.each do |k, v|
        map_buf << inspect_field(k, field_info[:key]) + ": " + inspect_field(v, field_info[:value])
      end
      "{" + map_buf.join(", ") + "}"
    else
      # old-style set
      inspect_collection(value.keys, field_info)
    end
  elsif value.is_a? Array
    inspect_collection(value, field_info)
  elsif value.is_a? Set
    inspect_collection(value, field_info)
  elsif value.is_a?(String) && field_info[:binary]
    value.unpack("H*").first
  else
    value.inspect
  end
end
is_container?(type) click to toggle source
# File lib/thrift/struct_union.rb, line 147
def is_container?(type)
  CONTAINER_TYPES[type]
end
name_to_id(name) click to toggle source
# File lib/thrift/struct_union.rb, line 23
def name_to_id(name)
  names_to_ids = self.class.instance_variable_get(:@names_to_ids)
  unless names_to_ids
    names_to_ids = {}
    struct_fields.each do |fid, field_def|
      names_to_ids[field_def[:name]] = fid
    end
    self.class.instance_variable_set(:@names_to_ids, names_to_ids)
  end
  names_to_ids[name]
end
read_field(iprot, field = {}) click to toggle source
# File lib/thrift/struct_union.rb, line 51
def read_field(iprot, field = {})
  case field[:type]
  when Types::STRUCT
    value = field[:class].new
    value.read(iprot)
  when Types::MAP
    key_type, val_type, size = iprot.read_map_begin
    # Skip the map contents if the declared key or value types don't match the expected ones.
    if (size != 0 && (key_type != field[:key][:type] || val_type != field[:value][:type]))
      size.times do
        iprot.skip(key_type)
        iprot.skip(val_type)
      end
      value = nil
    else
      value = {}
      size.times do
        k = read_field(iprot, field_info(field[:key]))
        v = read_field(iprot, field_info(field[:value]))
        value[k] = v
      end
    end
    iprot.read_map_end
  when Types::LIST
    e_type, size = iprot.read_list_begin
    # Skip the list contents if the declared element type doesn't match the expected one.
    if (e_type != field[:element][:type])
      size.times do
        iprot.skip(e_type)
      end
      value = nil
    else
      value = Array.new(size) do |n|
        read_field(iprot, field_info(field[:element]))
      end
    end
    iprot.read_list_end
  when Types::SET
    e_type, size = iprot.read_set_begin
    # Skip the set contents if the declared element type doesn't match the expected one.
    if (e_type != field[:element][:type])
      size.times do
        iprot.skip(e_type)
      end
    else
      value = Set.new
      size.times do
        element = read_field(iprot, field_info(field[:element]))
        value << element
      end
    end
    iprot.read_set_end
  else
    value = iprot.read_type(field[:type])
  end
  value
end
sorted_field_ids() click to toggle source
# File lib/thrift/struct_union.rb, line 35
def sorted_field_ids
  sorted_field_ids = self.class.instance_variable_get(:@sorted_field_ids)
  unless sorted_field_ids
    sorted_field_ids = struct_fields.keys.sort
    self.class.instance_variable_set(:@sorted_field_ids, sorted_field_ids)
  end
  sorted_field_ids
end
write_container(oprot, value, field = {}) click to toggle source
# File lib/thrift/struct_union.rb, line 117
def write_container(oprot, value, field = {})
  case field[:type]
  when Types::MAP
    oprot.write_map_begin(field[:key][:type], field[:value][:type], value.size)
    value.each do |k, v|
      write_data(oprot, k, field[:key])
      write_data(oprot, v, field[:value])
    end
    oprot.write_map_end
  when Types::LIST
    oprot.write_list_begin(field[:element][:type], value.size)
    value.each do |elem|
      write_data(oprot, elem, field[:element])
    end
    oprot.write_list_end
  when Types::SET
    oprot.write_set_begin(field[:element][:type], value.size)
    value.each do |v,| # the , is to preserve compatibility with the old Hash-style sets
      write_data(oprot, v, field[:element])
    end
    oprot.write_set_end
  else
    raise "Not a container type: #{field[:type]}"
  end
end
write_data(oprot, value, field) click to toggle source
# File lib/thrift/struct_union.rb, line 109
def write_data(oprot, value, field)
  if is_container? field[:type]
    write_container(oprot, value, field)
  else
    oprot.write_type(field[:type], value)
  end
end

[Validate]

Generated with the Darkfish Rdoc Generator 2.