Delete all objects that would have been cloned
        on a clone command. This is done separately because
        there may be m2m and other relationships that
        would have not been deleted otherwise.
772533
def _delete_reverses(self):
        

        for reverse in self.clone_related:
            self._delete_reverse(reverse)

        for field in self._meta.local_many_to_many:
            if field.rel.through and \
                    field.rel.through._meta.auto_created and not \
                    field.name in self.clone_related:
                man = getattr(self, field.name)
                man.clear()
536945
def delete(self, robj, rw=None, r=None, w=None, dw=None, pr=None,
               pw=None, timeout=None):
        
        raise NotImplementedError
1205247
def remove(self):
        
        self.clean()
        if os.path.isfile(self.schema_zip_file):
            os.remove(self.schema_zip_file)
        if os.path.isdir(self.schema_root_dir) and \
                os.listdir(self.schema_root_dir) == []:
            os.rmdir(self.schema_root_dir)
1301143
def delete(self, del_objects=False):
        
        return self.manager.delete(self, del_objects=del_objects)
1354438
def delete_object(self, obj):
        
        session = self.get_db_session()
        session.delete(obj)
        session.commit()
414780
def delete(self, refobj):
        
        i = self.get_typ_interface(self.get_typ(refobj))
        i.delete(refobj)
        self.delete_refobj(refobj)
902920
def delete(self):
        
        for related_collection_name in self.related_collections:
            related_collection = getattr(self, related_collection_name)
            related_collection.remove_instance()
        return super(RelatedModel, self).delete()
1009436
def delete_object(self, obj, post_delete=False):
        
        # Collect related objects that will be deleted by cascading
        links = [rel.get_accessor_name() for rel in \
                 obj._meta.get_all_related_objects()]
        # Recursively delete each of them
        for link in links:
            objects = getattr(obj, link).all()
            for o in objects:
                self.delete_object(o, post_delete)
        # Delete the actual object
        self._delete_object(obj, post_delete)
17959
def delete(self, *args, **kwargs):
        """"""
        self.before_delete(args, kwargs)

        self.delete_object(kwargs)

        result = {'meta': {'message': 'Object successfully deleted'}}

        final_result = self.after_delete(result)

        return final_result
999531
def delete_objects!(objects, request_options = {})
      res = delete_objects(objects, request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
537754
def delete(self, obj, matches=None, mt=None, lt=None, eq=None):
        '''
        
        '''
        deleted = False
        objects = list()
        for _obj in self.get(obj):
            if not self.__criteria(_obj, matches=matches, mt=mt, lt=lt, eq=eq):
                objects.append(_obj)
            else:
                deleted = True

        self.flush(obj._TABLE)
        self.create_table_from_object(obj())
        for _obj in objects:
            self.store(_obj)

        return deleted
837206
def delete(args):
    
    with _catalog(args) as cat:
        n = len(cat)
        cat.delete(args.args[0])
        args.log.info('{0} objects deleted'.format(n - len(cat)))
        return n - len(cat)
616942
def expunge(self, instance=None):
        ''''''
        if instance is not None:
            sm = self._models.get(instance._meta)
            if sm:
                return sm.expunge(instance)
        else:
            self._models.clear()
676694
public void cleanup() {
        managers.clear();
        for (BeanManagerImpl beanManager : beanDeploymentArchives.values()) {
            beanManager.cleanup();
        }
        beanDeploymentArchives.clear();
        deploymentServices.cleanup();
        deploymentManager.cleanup();
        instance.clear(contextId);
    }
598107
def delete(self, obj):
        
        full = deepcopy(obj)
        frag = full
        parts, last = self.parts[:-1], self.parts[-1]
        for part in parts:
            if isinstance(frag, dict):
                frag = frag[part]
            elif isinstance(frag, (list, tuple)):
                frag = frag[int(part)]

        if isinstance(frag, dict):
            frag.pop(last)
        elif isinstance(frag, list):
            if last == '-':
                frag.pop()
            else:
                frag.pop(int(last))

        return full
20012
def delete(self, using=None, soft=True, *args, **kwargs):
        
        if soft:
            self.is_removed = True
            self.save(using=using)
        else:
            return super(SoftDeletableModel, self).delete(using=using, *args, **kwargs)
970479
public void removeAll()
    {
        if (m_aRecords != null)
        {
            for (int iArrayIndex = 0; iArrayIndex < MAX_RECORD_ARRAY_SIZE; iArrayIndex++)
            {   // Free the objects that are no longer used
                this.freeElement(m_aRecords[iArrayIndex]);
                m_aRecords[iArrayIndex] = null;
            }
            m_aRecords = null;
        }
        m_iRecordListStep = 1;
        m_iRecordListEnd = 0;
        m_iRecordListMax = 0; // Current size of the record list (records scanned) (-1 - unknown)
    }