class Aws::Structure


#=> {:name=>“John”, :age=>40, :friend=>{:name=>“Jane”, :age=>40}}
person.to_h
)
friend: Structure.new(name: “Jane”, age: 40, friend: nil)
age: 40,
name: “John”,
person = Structure.new(
conversion of Structure objects into hashes.
Calling {#to_h} or {#to_hash} on a Structure object performs a deep
## Hash Conversion
person1.class == person2.class
person2 = Structure.new(name: ‘Jane Doe’, age: 40)
person1 = Structure.new(name: ‘John Doe’, age: 40)
automatically.
In addition to simpler object construction, struct classes are re-used
## Structure Classes
#=> #<struct>
struct = Structure.new({})
Structure solves this by introducing the EmptyStructure class.
The stdlib Struct class does not work with empty member lists.
## Empty Structures
#=> #<struct name=“John Doe”, age=40>
person = Structure.new(name: ‘John Doe’, age: 40)
You can construct a Structure with a simple hash.
## Construction
A utilty class that makes it easier to work with Struct objects.

def from_hash(value)

Other tags:
    Api: - private 
def from_hash(value)
  case value
  when Hash
    data = value.each.with_object({}) do |(key, value), hash|
      hash[key] = from_hash(value)
    end
    Symbol === data.keys.first ? new(data) : data
  when Array
    value.map { |v| from_hash(v) }
  else value
  end
end

def new(*args)

Returns:
  • (EmptyStructure) -
  • (Struct) -
  • (Struct) -
  • (Struct) -

Overloads:
  • new()
  • new(members)
  • new(*member_names)
  • new(member_names)

Parameters:
  • members (Hash) -- A hash of member names
  • member_names (Symbol) -- A list of member names.
  • member_names (Array) -- An array of member names. 
def new(*args)
  members, values = parse_args(args)
  if members.empty? && self == Structure
    EmptyStructure.new
  else
    struct_class = @@classes[members]
    if struct_class.nil?
      @@classes_mutex.synchronize do
        struct_class = members.empty? ? super(:_) : super(*members)
        @@classes[members] = struct_class
      end
    end
    struct_class.new(*values)
  end
end

def parse_args(args) 

def parse_args(args)
  case args.count
  when 0 then [[], []]
  when 1 then parse_single_arg(args.first)
  else [args, []]
  end
end

def parse_single_arg(arg) 

def parse_single_arg(arg)
  case arg
  when Array then [arg, []]
  when Hash then [arg.keys, arg.values]
  else [[arg], []]
  end
end

def to_h(obj = self)

Returns:
  • (Hash) - 
def to_h(obj = self)
  case obj
  when Struct
    obj.members.each.with_object({}) do |member, hash|
      value = obj[member]
      hash[member] = to_hash(value) unless value.nil?
    end
  when Hash
    obj.each.with_object({}) do |(key, value), hash|
      hash[key] = to_hash(value)
    end
  when Array
    obj.collect { |value| to_hash(value) }
  else
    obj
  end
end