class OpenStruct

def ==(other)
  return false unless other.kind_of?(OpenStruct)
  @table == other.table!
end

def [](name)
  @table[name.to_sym]
end

def []=(name, value)
  name = name.to_sym
  new_ostruct_member!(name)
  @table[name] = value
end

def delete_field(name, &block)
  sym = name.to_sym
  begin
    singleton_class.remove_method(sym, "#{sym}=")
  rescue NameError
  end
  @table.delete(sym) do
    return yield if block
    raise! NameError.new("no field '#{sym}' in #{self}", sym)
  end
end

def dig(name, *names)
  begin
    name = name.to_sym
  rescue NoMethodError
    raise! TypeError, "#{name} is not a symbol nor a string"
  end
  @table.dig(name, *names)
end

def each_pair
  return to_enum(__method__) { @table.size } unless defined?(yield)
  @table.each_pair{|p| yield p}
  self
end

def encode_with(coder) # :nodoc:
  @table.each_pair do |key, value|
    coder[key.to_s] = value
  end
  if @table.size == 1 && @table.key?(:table) # support for legacy format
    # in the very unlikely case of a single entry called 'table'
    coder['legacy_support!'] = true # add a bogus second entry
  end
end

def eql?(other)
  return false unless other.kind_of?(OpenStruct)
  @table.eql?(other.table!)
end

def freeze
  @table.freeze
  super
end

def hash # :nodoc:
  @table.hash
end

def init_with(coder) # :nodoc:
  h = coder.map
  if h.size == 1 # support for legacy format
    key, val = h.first
    if key == 'table'
      h = val
    end
  end
  update_to_values!(h)
end

def initialize(hash=nil)
  if HAS_PERFORMANCE_WARNINGS && Warning[:performance]
     warn "OpenStruct use is discouraged for performance reasons", uplevel: 1, category: :performance
  end
  if hash
    update_to_values!(hash)
  else
    @table = {}
  end
end

def initialize_clone(orig) # :nodoc:
# clones the singleton class for us
 = @table.dup unless @table.frozen?

def initialize_dup(orig) # :nodoc:
_to_values!(@table)

def inspect
  ids = (Thread.current[InspectKey] ||= [])
  if ids.include?(object_id)
    detail = ' ...'
  else
    ids << object_id
    begin
      detail = @table.map do |key, value|
        " #{key}=#{value.inspect}"
      end.join(',')
    ensure
      ids.pop
    end
  end
  ['#<', self.class!, detail, '>'].join
end

def is_method_protected!(name) # :nodoc:
spond_to?(name, true)
e
name.match?(/!$/)

r = method!(name).owner
wner.class == ::Class
ner < ::OpenStruct

lf.class!.ancestors.any? do |mod|
return false if mod == ::OpenStruct
mod == owner
d

def marshal_dump # :nodoc:
  @table
end

def method_missing(mid, *args) # :nodoc:
args.length
me = mid[/.*(?==\z)/m]
en != 1
ise! ArgumentError, "wrong number of arguments (given #{len}, expected 1)", caller(1)
ostruct_member_value!(mname, args[0])
len == 0
le[mid]
n
per
ue NoMethodError => err
r.backtrace.shift
ise!

def new_ostruct_member!(name) # :nodoc:
  unless @table.key?(name) || is_method_protected!(name)
    if defined?(::Ractor)
      getter_proc = nil.instance_eval{ Proc.new { @table[name] } }
      setter_proc = nil.instance_eval{ Proc.new {|x| @table[name] = x} }
      ::Ractor.make_shareable(getter_proc)
      ::Ractor.make_shareable(setter_proc)
    else
      getter_proc = Proc.new { @table[name] }
      setter_proc = Proc.new {|x| @table[name] = x}
    end
    define_singleton_method!(name, &getter_proc)
    define_singleton_method!("#{name}=", &setter_proc)
  end
end

def to_h(&block)
  if block
    @table.to_h(&block)
  else
    @table.dup
  end
end

def to_h(&block)
  if block
    @table.map(&block).to_h
  else
    @table.dup
  end
end

def update_to_values!(hash) # :nodoc:
 = {}
ach_pair do |k, v|
ostruct_member_value!(k, v)