class ActiveFedora::Associations::BelongsToAssociation

:nodoc:

def decrement_counters # :nodoc:

:nodoc:
def decrement_counters # :nodoc:
  # noop
end

def find_target?

def find_target?
  !loaded? && foreign_key_present? && klass
end

def foreign_key_present?

def foreign_key_present?
  owner[reflection.foreign_key]
end

def handle_dependency

:nodoc:
def handle_dependency
  target.send(options[:dependent]) if load_target
end

def increment_counters # :nodoc:

:nodoc:
def increment_counters # :nodoc:
  # noop
end

def invertible_for?(_)

belongs_to is not invertible (unless we implement has_one, then make an exception here)
def invertible_for?(_)
  false
end

def remove_keys

def remove_keys
  owner[reflection.foreign_key] = nil
end

def replace(record)

def replace(record)
  if record
    raise_on_type_mismatch!(record)
    update_counters_on_replace(record)
    replace_keys(record)
    set_inverse_instance(record)
    @updated = true
  else
    decrement_counters
    remove_keys
  end
  self.target = record
end

def replace_keys(record)

def replace_keys(record)
  owner[reflection.foreign_key] = record.id
end

def reset

def reset
  super
  @updated = false
end

def stale_state

def stale_state
  owner[reflection.foreign_key]
end

def update_counters_on_replace(_record)

def update_counters_on_replace(_record)
  # noop
end

def updated?

def updated?
  @updated
end