Removes all the elements from the vector QueryControllerEntity
327521
public void removeAllQueriesAndGroups() {
		List<QueryControllerEntity> elements = getElements();
		for (QueryControllerEntity treeElement : elements) {
			fireElementRemoved(treeElement);
		}
		entities.clear();
	}
953282
public void removeAll() {
        int size = size();
        if (size == 0) {
            return;
        }
        for (int i = 0, listSize = lists.size(); i < listSize; i++) {
            List<? extends T> list = lists.get(i);
            if (list instanceof ObservableList) {
                ((ObservableList) list).removeOnListChangedCallback(callback);
            }
        }
        lists.clear();
        modCount += 1;
        listeners.notifyRemoved(this, 0, size);
    }
313018
public void removeAllElements()
  {

    if (null == m_map)
      return;

    for (int i = 0; i < m_firstFree; i++)
    {
      m_map[i] = DTM.NULL;
    }

    m_firstFree = 0;
  }
1136362
private void removeMapping() {
		int[] indexes = mappingList.getSelectedIndices();
		if (indexes == null) {
			return;
		}
		int confirm = JOptionPane.showConfirmDialog(
				this, 
				"Proceed deleting " + indexes.length + " mappings?", "Conform",
				JOptionPane.WARNING_MESSAGE, JOptionPane.YES_NO_OPTION);
		if (confirm == JOptionPane.CANCEL_OPTION || confirm == JOptionPane.CLOSED_OPTION) {
			return;
		}
		
		// The manager panel can handle multiple deletions.
		Object[] values = mappingList.getSelectedValues();

		OBDAModel controller = apic;
		URI srcuri = selectedSource.getSourceID();

		for (int i = 0; i < values.length; i++) {
			SQLPPTriplesMap mapping = (SQLPPTriplesMap) values[i];
			if (mapping!=null)
			controller.removeTriplesMap(srcuri, mapping.getId());
		}
		mappingList.clearSelection();
	}
642320
def clear(self):
        
        del self._statements_and_parameters[:]
        self.keyspace = None
        self.routing_key = None
        if self.custom_payload:
            self.custom_payload.clear()
127677
private void removeChildrenItems(JDBCStorageConnection conn, ResultSet resultSet) throws SQLException, IllegalNameException,
      IllegalStateException, UnsupportedOperationException, InvalidItemStateException, RepositoryException
   {
      String parentId = resultSet.getString(DBConstants.COLUMN_ID);
      String selectStatement = "select * from " + iTable + " where I_CLASS = 1 and PARENT_ID = '" + parentId + "'";
      String deleteStatement = "delete from " + iTable + " where I_CLASS = 1 and PARENT_ID = '" + parentId + "'";

      // traversing down to the bottom of the tree
      PreparedStatement statement = conn.getJdbcConnection().prepareStatement(selectStatement);
      ResultSet selResult = statement.executeQuery();
      try
      {
         while (selResult.next())
         {
            removeChildrenItems(conn, selResult);
         }
      }
      finally
      {
         JDBCUtils.freeResources(selResult, statement, null);
      }
      
      // remove properties
      NodeData node = createNodeData(resultSet);
      for (PropertyData prop : conn.getChildPropertiesData(node))
      {
         conn.delete(prop, new SimpleChangedSizeHandler());
      }

      // remove nodes
      statement = conn.getJdbcConnection().prepareStatement(deleteStatement);
      try
      {
         statement.execute();
      }
      finally
      {
         JDBCUtils.freeResources(null, statement, null);
      }
   }
681551
public void free()
    {
        // Remove all the objects if this is the primary key
        if (this.getPTable().getPKeyArea(Constants.MAIN_KEY_AREA) == this)
        {
            for (int i = m_VectorObjects.size() - 1 ; i >= 0 ;i--)
            {
                BaseBuffer buffer = (BaseBuffer)m_VectorObjects.elementAt(i);
                buffer.free();
            }
        }
        m_VectorObjects.removeAllElements();
        m_VectorObjects = null;

        super.free();
    }
189988
public void removeEjbBindings()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(tc, "removeEjbBindings called");

        // Just loop through the values, not the keys, as the simple-binding-name
        // key may have a # in front of it when the bean was not simple, and that
        // won't match what is in the ServerContextBindingMap.           d457053.1

        for (String bindingName : ivEjbContextBindingMap.values())
        {
            removeFromServerContextBindingMap(bindingName, true);
        }

        ivEjbContextBindingMap.clear();
    }
268879
private void cleanupQueryStates() {
        finishedDecoding();
        queryInfoObservable = null;
        queryRowObservable = null;
        queryErrorObservable = null;
        queryStatusObservable = null;
        querySignatureObservable = null;
        queryProfileInfoObservable = null;
        queryParsingState = QUERY_STATE_INITIAL;
        queryRowClosingPositionProcessor = null;
        queryRowClosingProcessorIndex = 0;
    }
644686
function(entity, options) {
      delete this._byId[entity.cid];
      var id = this.entityId(entity.attributes);
      if (id != null) delete this._byId[id];
      if (this === entity.collection) delete entity.collection;
      entity.off('all', this._onEntityEvent, this);
    }
293622
function () {
                var res = [];
                this._removeAllToArray(this._objectKeys, res);
                this._objectKeys = null;
                this._removeAllToArray(this._stringKeys, res);
                this._stringKeys = null;
                this._removeAllToArray(this._numberKeys, res);
                this._numberKeys = null;
                this._removeAllToArray(this._otherKeys, res);
                this._otherKeys = null;
                return res;
            }
895147
public function clear()
    {
        $this->identityMap =
        $this->entityIdentifiers =
        $this->entityChangeSets =
        $this->entityStates =
        $this->scheduledForDirtyCheck =
        $this->entityInsertions =
        $this->entityUpdates =
        $this->entityDeletions = array();
    }
889938
void removeAll(BaseRow sortKey) {
		Collection<BaseRow> list = treeMap.get(sortKey);
		if (list != null) {
			currentTopNum -= list.size();
			treeMap.remove(sortKey);
		}
	}
446353
private void cleanupQueryStates() {
        completeRequestSpan(currentRequest());
        finishedDecoding();
        queryInfoObservable = null;
        queryRowObservable = null;
        queryErrorObservable = null;
        queryStatusObservable = null;
        querySignatureObservable = null;
        queryParsingState = QUERY_STATE_INITIAL;
    }
211212
@Override
	public void clearCache() {
		entityCache.clearCache(CPDefinitionOptionValueRelImpl.class);

		finderCache.clearCache(FINDER_CLASS_NAME_ENTITY);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
		finderCache.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
	}
1288484
private void dropAllEntities() {

        for (final MappedEntity mappedEntity : ImmutableList.copyOf(entities.values())) {
            try {
                dropEntity(mappedEntity.getEntity());
            } catch (final DatabaseEngineException ex) {
                logger.debug(String.format("Failed to drop entity '%s'", mappedEntity.getEntity().getName()), ex);
            }
        }
    }
519778
protected void removeUnnecessaryOperations() {

        for (Class<? extends Entity> entityClass : deletedObjects.keySet()) {

            // Collect ids of deleted entities + remove duplicates
            Set<String> ids = new HashSet<String>();
            Iterator<Entity> entitiesToDeleteIterator = deletedObjects.get(entityClass).values().iterator();
            while (entitiesToDeleteIterator.hasNext()) {
                Entity entityToDelete = entitiesToDeleteIterator.next();
                if (!ids.contains(entityToDelete.getId())) {
                    ids.add(entityToDelete.getId());
                } else {
                    entitiesToDeleteIterator.remove(); // Removing duplicate deletes
                }
            }

            // Now we have the deleted ids, we can remove the inserted objects (as they cancel each other)
            for (String id : ids) {
                if (insertedObjects.containsKey(entityClass) && insertedObjects.get(entityClass).containsKey(id)) {
                    insertedObjects.get(entityClass).remove(id);
                    deletedObjects.get(entityClass).remove(id);
                }
            }
        }
    }