| # |
| # Licensed to the Apache Software Foundation (ASF) under one |
| # or more contributor license agreements. See the NOTICE file |
| # distributed with this work for additional information |
| # regarding copyright ownership. The ASF licenses this file |
| # to you under the Apache License, Version 2.0 (the |
| # "License"); you may not use this file except in compliance |
| # with the License. You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, |
| # software distributed under the License is distributed on an |
| # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| # KIND, either express or implied. See the License for the |
| # specific language governing permissions and limitations |
| # under the License. |
| # |
| |
| require 'set' |
| |
| module Thrift |
| module Struct |
| def initialize(d={}) |
| # 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 |
| end |
| |
| 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 |
| |
| 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 |
| |
| def each_field |
| struct_fields.keys.sort.each do |fid| |
| data = struct_fields[fid] |
| yield fid, data |
| end |
| end |
| |
| 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}:#{value.inspect}" |
| end |
| end |
| "<#{self.class} #{fields.join(", ")}>" |
| end |
| |
| 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 |
| |
| 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] |
| if (value = instance_variable_get("@#{name}")) |
| 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(name, type, fid, value) |
| end |
| end |
| end |
| oprot.write_field_stop |
| oprot.write_struct_end |
| end |
| |
| def ==(other) |
| each_field do |fid, field_info| |
| name = field_info[:name] |
| return false unless self.instance_variable_get("@#{name}") == other.instance_variable_get("@#{name}") |
| end |
| true |
| end |
| |
| def eql?(other) |
| self.class == other.class && self == other |
| end |
| |
| # for the time being, we're ok with a naive hash. this could definitely be improved upon. |
| def hash |
| 0 |
| end |
| |
| 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 |
| |
| def self.field_accessor(klass, *fields) |
| fields.each do |field| |
| klass.send :attr_reader, field |
| klass.send :define_method, "#{field}=" do |value| |
| Thrift.check_type(value, klass::FIELDS.values.find { |f| f[:name].to_s == field.to_s }, field) if Thrift.type_checking |
| instance_variable_set("@#{field}", value) |
| end |
| end |
| end |
| |
| protected |
| |
| def self.append_features(mod) |
| if mod.ancestors.include? ::Exception |
| mod.send :class_variable_set, :'@@__thrift_struct_real_initialize', mod.instance_method(:initialize) |
| super |
| # set up our custom initializer so `raise Xception, 'message'` works |
| mod.send :define_method, :struct_initialize, mod.instance_method(:initialize) |
| mod.send :define_method, :initialize, mod.instance_method(:exception_initialize) |
| else |
| super |
| end |
| end |
| |
| def exception_initialize(*args, &block) |
| if args.size == 1 and args.first.is_a? Hash |
| # looks like it's a regular Struct initialize |
| method(:struct_initialize).call(args.first) |
| else |
| # call the Struct initializer first with no args |
| # this will set our field default values |
| method(:struct_initialize).call() |
| # now give it to the exception |
| self.class.send(:class_variable_get, :'@@__thrift_struct_real_initialize').bind(self).call(*args, &block) if args.size > 0 |
| # self.class.instance_method(:initialize).bind(self).call(*args, &block) |
| end |
| end |
| |
| def handle_message(iprot, fid, ftype) |
| field = struct_fields[fid] |
| if field and field[:type] == ftype |
| value = read_field(iprot, field) |
| instance_variable_set("@#{field[:name]}", value) |
| else |
| iprot.skip(ftype) |
| end |
| end |
| |
| 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 |
| value = {} |
| size.times do |
| k = read_field(iprot, field_info(field[:key])) |
| v = read_field(iprot, field_info(field[:value])) |
| value[k] = v |
| end |
| iprot.read_map_end |
| when Types::LIST |
| e_type, size = iprot.read_list_begin |
| value = Array.new(size) do |n| |
| read_field(iprot, field_info(field[:element])) |
| end |
| iprot.read_list_end |
| when Types::SET |
| e_type, size = iprot.read_set_begin |
| value = Set.new |
| size.times do |
| element = read_field(iprot, field_info(field[:element])) |
| value << element |
| end |
| iprot.read_set_end |
| else |
| value = iprot.read_type(field[:type]) |
| end |
| value |
| end |
| |
| 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 |
| |
| 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 |
| |
| CONTAINER_TYPES = [] |
| CONTAINER_TYPES[Types::LIST] = true |
| CONTAINER_TYPES[Types::MAP] = true |
| CONTAINER_TYPES[Types::SET] = true |
| def is_container?(type) |
| CONTAINER_TYPES[type] |
| end |
| |
| def field_info(field) |
| { :type => field[:type], |
| :class => field[:class], |
| :key => field[:key], |
| :value => field[:value], |
| :element => field[:element] } |
| end |
| end |
| end |