Removes all objects from an aggregation of the given control
Adds one insertAggregation per removed object as undo operations
@override
335278
function (oParent, sName) {
			var aOldAggregationElements = [];
			var vAggregationElements;
			if (oParent) {
				vAggregationElements = JsControlTreeModifier.getAggregation.call(this, oParent, sName);
			}

			if (vAggregationElements && vAggregationElements instanceof Array) {
				aOldAggregationElements = vAggregationElements.slice();
			} else  if (vAggregationElements && vAggregationElements instanceof Object) {
				aOldAggregationElements[0] = vAggregationElements;
			}

			JsControlTreeModifier.removeAllAggregation(oParent, sName);

			if (aOldAggregationElements){
				aOldAggregationElements.forEach(function(oElement) {
					this._saveUndoOperation("insertAggregation", [oParent, sName, oElement]);
				}, this);
			}
		}
991194
@Override
	public void removeByGroupId(long groupId) {
		for (CPRule cpRule : findByGroupId(groupId, QueryUtil.ALL_POS,
				QueryUtil.ALL_POS, null)) {
			remove(cpRule);
		}
	}
182744
@Override
	public void deleteObjectOrCancelCheckOut(String repositoryId, String objectId, Boolean allVersions, ExtensionsData extension) {
		objectService.deleteObject(repositoryId, objectId, allVersions, extension);
	}
453982
@Override
    public boolean remove(Object o) {
        Integer id = indexOf((Record) o);
        if(id == null) {
            return false;
        }
        remove(id);
        return true;
    }
135190
function(sGroup) {
        this.logger.log("Removing from group: " + sGroup);
        if (this.groups[sGroup]) {
            delete this.groups[sGroup];
        }

        this.DDM.removeDDFromGroup(this, sGroup);
    }
556943
public function removeAll()
    {
        $this->removed_objects = array_values($this->objects);
        $this->objects = array();
        $this->objects_by_index = array();
        $this->current_index = 0;
    }
799518
public void clear ()
    {
        // notify our removal observer if we have one
        if (_remobs != null) {
            for (Iterator<V> iter = _delegate.values().iterator();
                 iter.hasNext(); ) {
                _remobs.removedFromMap(this, iter.next());
            }
        }

        // then clear everything out
        _delegate.clear();
        _size = 0;
    }
494570
public boolean removeAll(Collection<?> collection) {
        boolean result = false;
        synchronized (mLock) {
            Iterator<?> it;
            if (mOriginalValues != null) {
                it = mOriginalValues.iterator();

            } else {
                it = mObjects.iterator();
            }
            while (it.hasNext()) {
                if (collection.contains(it.next())) {
                    it.remove();
                    result = true;
                }
            }
        }
        if (mNotifyOnChange) notifyDataSetChanged();
        return result;
    }
68852
function deleteDelegatedHandler(eventOptions = {}) {
    const { key } = eventOptions;
    const def = defs.get(this);

    if (key && key in def.keys) {
        triggerOne(this, '_asterisk:remove', eventOptions);
    }
}
159968
public void retractObject(final InternalFactHandle handle,
                              final PropagationContext context,
                              final ObjectTypeConf objectTypeConf,
                              final InternalWorkingMemory workingMemory) {
        if ( log.isTraceEnabled() ) {
            log.trace( "Delete {}", handle.toString()  );
        }

        workingMemory.addPropagation(new PropagationEntry.Delete(this, handle, context, objectTypeConf));
    }
833053
function removeHandler(node, eventType, handler, thisObject){
    node = getNode(node);

    var handlers = node === global ? globalEvents : node[EVENT_HOLDER];
    if (handlers)
    {
      var eventTypeHandlers = handlers[eventType];
      if (eventTypeHandlers)
      {
        for (var i = 0, item; item = eventTypeHandlers[i]; i++)
        {
          if (item.handler === handler && item.thisObject === thisObject)
          {
            // delete event handler
            eventTypeHandlers.splice(i, 1);

            // if there is no more handler for this event, clear it
            if (!eventTypeHandlers.length)
              clearHandlers(node, eventType);

            return;
          }
        }
      }
    }
  }
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)
    }
1169119
def reset_aggregations(self):
        

        temp_search = self.search.to_dict()
        if 'aggs' in temp_search.keys():
            del temp_search['aggs']
            self.search.from_dict(temp_search)
        self.parent_agg_counter = 0
        self.child_agg_counter = 0
        self.child_agg_counter_dict = defaultdict(int)
369776
@Override
    public boolean remove(Object o) {
        if (elements.remove(o)) {
            ordered.remove(o);
            return true;
        } else {
            return false;
        }

    }
748268
function updateDiff(oControl, aContexts) {
			var aDiff = aContexts.diff,
				aChildren = oControl[oAggregationInfo._sGetter]() || [],
				oDiff, oClone, oContext, i;

			// If no diff exists or aggregation is empty, fall back to default update
			if (!aDiff || aChildren.length === 0) {
				update(oControl, aContexts);
				return;
			}

			// Loop through the diff and apply it
			for (i = 0; i < aDiff.length; i++) {
				oDiff = aDiff[i];
				switch (oDiff.type) {
					case "insert":
						oContext = aContexts[oDiff.index];
						oClone = fnFactory(getIdSuffix(oControl, oDiff.index), oContext);
						oClone.setBindingContext(oContext, oBindingInfo.model);
						oControl[oAggregationInfo._sInsertMutator](oClone, oDiff.index);
						break;
					case "delete":
						oClone = oControl[oAggregationInfo._sRemoveMutator](oDiff.index);
						oClone.destroy("KeepDom");
						break;
					default:
						Log.error("Unknown diff type \"" + oDiff.type + "\"");
				}
			}

			// Loop through all children and set the binding context again. This is needed for
			// indexed contexts, where inserting/deleting entries shifts the index of all following items
			aChildren = oControl[oAggregationInfo._sGetter]() || [];
			for (i = 0; i < aChildren.length; i++) {
				aChildren[i].setBindingContext(aContexts[i]);
			}
		}
929516
function(event, model, collection, options) {
      if ((event === 'add' || event === 'remove') && collection !== this) return;
      if (event === 'destroy') this.remove(model, options);
      if (event === 'change') {
        var prevId = this.modelId(model.previousAttributes());
        var id = this.modelId(model.attributes);
        if (prevId !== id) {
          if (prevId != null) delete this._byId[prevId];
          if (id != null) this._byId[id] = model;
        }
      }
      this.trigger.apply(this, arguments);
    }
160937
protected void removeBatchBy(int removeIdx) {
        if (mGroupBasicAdapter != null) {
            Pair<Range<Integer>, Card> cardPair = mGroupBasicAdapter.getCardRange(removeIdx);
            if (cardPair != null) {
                removeBatchBy(cardPair.second);
            }
        }
    }