Module: Thrift::Struct

Defined in:
lib/thrift/struct.rb

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.field_accessor(klass, field_info) ⇒ Object 



153
154
155
156
157
158
159
160
 
# File 'lib/thrift/struct.rb', line 153

def self.field_accessor(klass, field_info)
  field_name_sym = field_info[:name].to_sym
  klass.send :attr_reader, field_name_sym
  klass.send :define_method, "#{field_info[:name]}=" do |value|
    Thrift.check_type(value, field_info, field_info[:name]) if Thrift.type_checking
    instance_variable_set("@#{field_name_sym}", value)
  end
end

.generate_accessors(klass) ⇒ Object 



162
163
164
165
166
167
 
# File 'lib/thrift/struct.rb', line 162

def self.generate_accessors(klass)
  klass::FIELDS.values.each do |field_info|
    field_accessor(klass, field_info)
    qmark_isset_method(klass, field_info)
  end
end

.qmark_isset_method(klass, field_info) ⇒ Object 



169
170
171
172
173
 
# File 'lib/thrift/struct.rb', line 169

def self.qmark_isset_method(klass, field_info)
  klass.send :define_method, "#{field_info[:name]}?" do
    !self.send(field_info[:name].to_sym).nil?
  end
end

Instance Method Details

#<=>(other) ⇒ Object 



175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
 
# File 'lib/thrift/struct.rb', line 175

def <=>(other)
  if self.class == other.class
    each_field do |fid, field_info|
      v1 = self.send(field_info[:name])
      v1_set = !v1.nil?
      v2 = other.send(field_info[:name])
      v2_set = !v2.nil?
      if v1_set && !v2_set
        return -1
      elsif !v1_set && v2_set
        return 1
      elsif v1_set && v2_set
        cmp = v1 <=> v2
        if cmp != 0
          return cmp
        end
      end
    end
    0
  else
    self.class <=> other.class
  end
end

#==(other) ⇒ Object 



116
117
118
119
120
121
122
123
 
# File 'lib/thrift/struct.rb', line 116

def ==(other)
  return false if other.nil?
  each_field do |fid, field_info|
    name = field_info[:name]
    return false unless other.respond_to?(name) && self.send(name) == other.send(name)
  end
  true
end

#differences(other) ⇒ Object 



140
141
142
143
144
145
146
147
148
149
150
151
 
# File 'lib/thrift/struct.rb', line 140

def differences(other)
  diffs = []
  unless other.is_a?(self.class)
    diffs << "Different class!"
  else
    each_field do |fid, field_info|
      name = field_info[:name]
      diffs << "#{name} differs!" unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}")
    end
  end
  diffs
end

#eql?(other) ⇒ Boolean

Returns:

  • (Boolean) 


125
126
127
 
# File 'lib/thrift/struct.rb', line 125

def eql?(other)
  self.class == other.class && self == other
end

#fields_with_default_values ⇒ Object 



57
58
59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/thrift/struct.rb', line 57

def fields_with_default_values
  fields_with_default_values = self.class.instance_variable_get(:@fields_with_default_values)
  unless fields_with_default_values
    fields_with_default_values = {}
    struct_fields.each do |fid, field_def|
      unless field_def[:default].nil?
        fields_with_default_values[field_def[:name]] = field_def[:default]
      end
    end
    self.class.instance_variable_set(:@fields_with_default_values, fields_with_default_values)
  end
  fields_with_default_values
end

#hash ⇒ Object

This implementation of hash() is inspired by Apache’s Java HashCodeBuilder class.



130
131
132
133
134
135
136
137
138
 
# File 'lib/thrift/struct.rb', line 130

def hash
  total = 17
  each_field do |fid, field_info|
    name = field_info[:name]
    value = self.send(name)
    total = (total * 37 + value.hash) & 0xffffffff
  end
  total
end

#initialize(d = {}) {|_self| ... } ⇒ Object

Yields:

  • (_self)

Yield Parameters:



24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
# File 'lib/thrift/struct.rb', line 24

def initialize(d={}, &block)
  # get a copy of the default values to work on, removing defaults in favor of arguments
  fields_with_defaults = fields_with_default_values.dup
  
  # check if the defaults is empty, or if there are no parameters for this 
  # instantiation, and if so, don't bother overriding defaults.
  unless fields_with_defaults.empty? || d.empty?
    d.each_key do |name|
      fields_with_defaults.delete(name.to_s)
    end
  end
  
  # assign all the user-specified arguments
  unless d.empty?
    d.each do |name, value|
      unless name_to_id(name.to_s)
        raise Exception, "Unknown key given to #{self.class}.new: #{name}"
      end
      Thrift.check_type(value, struct_fields[name_to_id(name.to_s)], name) if Thrift.type_checking
      instance_variable_set("@#{name}", value)
    end
  end
  
  # assign all the default values
  unless fields_with_defaults.empty?
    fields_with_defaults.each do |name, default_value|
      instance_variable_set("@#{name}", (default_value.dup rescue default_value))
    end
  end
  
  yield self if block_given?
end

#inspect(skip_optional_nulls = true) ⇒ Object 



71
72
73
74
75
76
77
78
79
80
81
 
# File 'lib/thrift/struct.rb', line 71

def inspect(skip_optional_nulls = true)
  fields = []
  each_field do |fid, field_info|
    name = field_info[:name]
    value = instance_variable_get("@#{name}")
    unless skip_optional_nulls && field_info[:optional] && value.nil?
      fields << "#{name}:#{inspect_field(value, field_info)}"
    end
  end
  "<#{self.class} #{fields.join(", ")}>"
end

#read(iprot) ⇒ Object 



83
84
85
86
87
88
89
90
91
92
93
 
# File 'lib/thrift/struct.rb', line 83

def read(iprot)
  iprot.read_struct_begin
  loop do
    fname, ftype, fid = iprot.read_field_begin
    break if (ftype == Types::STOP)
    handle_message(iprot, fid, ftype)
    iprot.read_field_end
  end
  iprot.read_struct_end
  validate
end

#write(oprot) ⇒ Object 



95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/thrift/struct.rb', line 95

def write(oprot)
  validate
  oprot.write_struct_begin(self.class.name)
  each_field do |fid, field_info|
    name = field_info[:name]
    type = field_info[:type]
    value = instance_variable_get("@#{name}")
    unless value.nil?
      if is_container? type
        oprot.write_field_begin(name, type, fid)
        write_container(oprot, value, field_info)
        oprot.write_field_end
      else
        oprot.write_field(field_info, fid, value)
      end
    end
  end
  oprot.write_field_stop
  oprot.write_struct_end
end