Removes the reference of the given instance from the attribute of this record.

 @param [Symbol] attribute the name of the child attribute from which to remove a child
 @param [Record] instance a child record to be removed from this instance
343445
def delete_child(attribute, instance=nil)
      if self.send(attribute).is_a?(Array)
        deleted = self.send(attribute).delete(instance)
        deleted.parent = nil if deleted
      else
        self.send(attribute).parent = nil if self.send(attribute)
        self.instance_variable_set("@#{attribute}", nil)
      end
    end
509909
def stop_instance(self, instance_id):
        
        instance = self._load_instance(instance_id)
        instance.terminate()
        del self._instances[instance_id]
398170
def destroy_key attribute, key
      raise "invalid attribute #{attribute}" unless self.class.column_names.include?(attribute.to_s)
      new_value = send(attribute)
      new_value.delete(key.to_s)
      send("#{attribute}=", new_value)
      self
    end
1127584
def remove_callback(self, name, callback):
        

        if self.is_callback_property(name):
            prop = getattr(type(self), name)
            try:
                prop.remove_callback(self, callback)
            except ValueError:  # pragma: nocover
                pass  # Be forgiving if callback was already removed before
        else:
            raise TypeError("attribute '{0}' is not a callback property".format(name))
835063
def deregister(cls, attr_name):
        
        try:
            field = cls.get_field_by_fieldname(attr_name)
        except InvalidField:
            raise ValueError("'%s' is not registered" % attr_name)
        if not isinstance(field, ExtendedPropertyField):
            raise ValueError("'%s' is not registered as an ExtendedProperty" % attr_name)
        cls.remove_field(field)
74533
public void removeAttribute(String attributeName) {
        synchronized (_iSession) {
            if (!_iSession.isValid())
                throw new IllegalStateException();
            Object object = _iSession.removeAttribute(attributeName);
        }
    }
834601
def removeID(self, attr):
        
        if attr is None: attr__o = None
        else: attr__o = attr._o
        ret = libxml2mod.xmlRemoveID(self._o, attr__o)
        return ret
256421
def delete_instance(model, instance_id, _commit=True):
    
    try:
        model = get_model(model)
    except ImportError:
        return

    instance = model.query.get(instance_id)
    if not instance:
        return

    db.session.delete(instance)
    try:
        if _commit:
            db.session.commit()
        else:
            db.session.flush()
    except Exception as exception:
        db.session.rollback()
        raise exception
710964
def remove_structure(instance_or_number)
      raise ArgumentError, "Invalid argument 'instance_or_number'. Expected a ROI Instance or an Integer (ROI Number). Got #{instance_or_number.class}." unless [ROI, Integer].include?(instance_or_number.class)
      s_instance = instance_or_number
      if instance_or_number.is_a?(Integer)
        s_instance = structure(instance_or_number)
      end
      index = @structures.index(s_instance)
      if index
        @structures.delete_at(index)
        s_instance.remove_references
      end
    end
924490
public void removeAttribute(CBORObject label) throws CoseException {
        if (objProtected.ContainsKey(label)) {
            if (rgbProtected != null) throw new CoseException("Operation would modify integrity protected attributes");
            objProtected.Remove(label);
        }
        if (objUnprotected.ContainsKey(label)) objUnprotected.Remove(label);
        if (objDontSend.ContainsKey(label)) objDontSend.Remove(label);
    }
927480
def del_object_from_parent(self):
        
        if self.parent:
            self.parent.objects.pop(self.ref)
909528
def delete_instance(self, instance, using_transactions=True, dry_run=False):
        
        self.before_delete_instance(instance, dry_run)
        if not using_transactions and dry_run:
            # we don't have transactions and we want to do a dry_run
            pass
        else:
            instance.delete()
        self.after_delete_instance(instance, dry_run)
650164
def removeRef(self, attr):
        
        if attr is None: attr__o = None
        else: attr__o = attr._o
        ret = libxml2mod.xmlRemoveRef(self._o, attr__o)
        return ret
1246643
def unbind(self, instance_id: str, binding_id: str, details: UnbindDetails):
        
        
        # Find the instance
        instance = self._backend.find(instance_id)
        
        # Find the binding
        binding = self._backend.find(binding_id, instance)
        if not binding.isProvisioned():
            # The binding does not exist
            raise ErrBindingDoesNotExist()
        
        # Delete the binding
        self._backend.unbind(binding)
758854
def remove(self, attr, item):
        
        return self.set(attr, operation.Remove([item]))
223979
def clear_db_attribute(self, table, record, column):
        
        command = ovs_vsctl.VSCtlCommand('clear', (table, record, column))
        self.run_command([command])
1267988
def remove_child_object(identifier)
      found_child = children.find {|child| child.identifier == identifier }
      @properties['children'].delete identifier
      save!
      found_child
    end