class ActiveModel::AttributeSet

:nodoc:

def ==(other)

def ==(other)
  other.is_a?(AttributeSet) && attributes == other.send(:attributes)
end

def [](name)

def [](name)
  @attributes[name] || default_attribute(name)
end

def []=(name, value)

def []=(name, value)
  @attributes[name] = value
end

def accessed

def accessed
  attributes.each_key.select { |name| self[name].has_been_read? }
end

def cast_types

def cast_types
  attributes.transform_values(&:type)
end

def deep_dup

def deep_dup
  AttributeSet.new(attributes.transform_values(&:deep_dup))
end

def default_attribute(name)

def default_attribute(name)
  Attribute.null(name)
end

def fetch_value(name, &block)

def fetch_value(name, &block)
  self[name].value(&block)
end

def freeze

def freeze
  attributes.freeze
  super
end

def initialize(attributes)

def initialize(attributes)
  @attributes = attributes
end

def initialize_clone(_)

def initialize_clone(_)
  @attributes = @attributes.clone
  super
end

def initialize_dup(_)

def initialize_dup(_)
  @attributes = @attributes.dup
  super
end

def key?(name)

def key?(name)
  attributes.key?(name) && self[name].initialized?
end

def keys

def keys
  attributes.each_key.select { |name| self[name].initialized? }
end

def map(&block)

def map(&block)
  new_attributes = attributes.transform_values(&block)
  AttributeSet.new(new_attributes)
end

def reset(key)

def reset(key)
  if key?(key)
    write_from_database(key, nil)
  end
end

def reverse_merge!(target_attributes)

def reverse_merge!(target_attributes)
  attributes.reverse_merge!(target_attributes.attributes) && self
end

def to_hash

def to_hash
  keys.index_with { |name| self[name].value }
end

def values_before_type_cast

def values_before_type_cast
  attributes.transform_values(&:value_before_type_cast)
end

def values_for_database

def values_for_database
  attributes.transform_values(&:value_for_database)
end

def write_cast_value(name, value)

def write_cast_value(name, value)
  @attributes[name] = self[name].with_cast_value(value)
end

def write_from_database(name, value)

def write_from_database(name, value)
  @attributes[name] = self[name].with_value_from_database(value)
end

def write_from_user(name, value)

def write_from_user(name, value)
  raise FrozenError, "can't modify frozen attributes" if frozen?
  @attributes[name] = self[name].with_value_from_user(value)
  value
end