Drop the given Handles.
177703
def extern_drop_handles(self, context_handle, handles_ptr, handles_len):
    """"""
    c = self._ffi.from_handle(context_handle)
    handles = self._ffi.unpack(handles_ptr, handles_len)
    c.drop_handles(handles)
1080870
private void purgeHandle(String handle) {
        write.lock();
        try {
            kamMap.remove(handle);

            Set<Entry<FilteredKAMKey, String>> entries = fltrdMap.entrySet();
            Iterator<Entry<FilteredKAMKey, String>> iter = entries.iterator();
            while (iter.hasNext()) {
                Entry<FilteredKAMKey, String> next = iter.next();
                if (handle.equals(next.getValue())) {
                    iter.remove();
                }
            }

            Set<Entry<KamInfo, String>> entries2 = unfltrdMap.entrySet();
            Iterator<Entry<KamInfo, String>> iter2 = entries2.iterator();
            while (iter2.hasNext()) {
                Entry<KamInfo, String> next = iter2.next();
                if (handle.equals(next.getValue())) {
                    iter2.remove();
                }
            }
        } finally {
            write.unlock();
        }
    }
1366282
function drop(schemas) {
  var resolver = new Resolver(schemas);
  var knex = this.knex;
  return Promise.map(schemas || [], function(schema) {
    return (schema.preDrop || _.noop)(knex);
  })
  .then(function () {
    // Reduce force sequential execution.
    return Promise.reduce(resolver.resolve().reverse(), dropSchema.bind(this), []);
  }.bind(this));
}
1129758
function drop (n, array) {
  return (n < array.length)
    ? slice(n, array.length, array)
    : []
}
1098528
def drop_all(self, **kwargs):
        
        conn = self.__get_conn__(**kwargs)
        conn.update_query("DROP ALL")
        self.loaded = []
        self.loaded_times = {}
2788
def drop(self, names):
        """"""
        
        # drop lower dimension data
        self._data = self._data.drop(names, axis=0)
        # drop higher dimension data
        for name in names:
            if name in self._ho_data:
                _ = self._ho_data.pop(name)
1214137
private void purgeAllConnections() {
        synchronized (m_dbConns) {
            Iterator<DBConn> iter = m_dbConns.iterator();
            while (iter.hasNext()) {
                DBConn dbConn = iter.next();
                dbConn.close();
                iter.remove();
            }
        }
    }
7935
private void discardIdleConnections() {
        List<Connection<CL>> connections = Lists.newArrayList();
        availableConnections.drainTo(connections);
        activeCount.addAndGet(-connections.size());

        for (Connection<CL> connection : connections) {
            try {
                closedConnections.incrementAndGet();
                connection.close(); // This is usually an async operation
            }
            catch (Throwable t) {
                // TODO
            }
        }
    }
458386
public void dropTables() {
        try (Connection connection = getConnection();
             Statement statement = connection.createStatement()) {
            ArrayList<Type<?>> reversed = sortTypes();
            Collections.reverse(reversed);
            executeDropStatements(statement, reversed);
        } catch (SQLException e) {
            throw new TableModificationException(e);
        }
    }
1266407
def drop_empty_tables(self):
        """"""
        # Count number of rows in each table
        counts = self.count_rows_all()
        drops = []

        # Loop through each table key and validate that rows count is not 0
        for table, count in counts.items():
            if count < 1:
                # Drop table if it contains no rows
                self.drop(table)
                drops.append(table)
        return drops
316988
function clearDrops(sense) {
        sense.dropsStarted = [];
        sense.dropOver = null;
        sense.dropEvt = {
            dataType: 'text/plain',
            dataTransfer: ''
        };
    }
1176149
void unregister(AbstractAppHandle handle) {
    for (Map.Entry<String, AbstractAppHandle> e : secretToPendingApps.entrySet()) {
      if (e.getValue().equals(handle)) {
        String secret = e.getKey();
        secretToPendingApps.remove(secret);
        break;
      }
    }

    unref();
  }
424274
def drop(self):
        
        with self.db.lock:
            if self.exists:
                self._threading_warn()
                self.table.drop(self.db.executable, checkfirst=True)
                self._table = None
781824
private int unregisterHandles() {
        int cancelledHandles = 0;
        for (;;) {
            AcceptorOperationFuture future = cancelQueue.poll();
            if (future == null) {
                break;
            }

            // close the channels
            for (SocketAddress a : future.getLocalAddresses()) {
                H handle = boundHandles.remove(a);
                
                if (handle == null) {
                    continue;
                }

                try {
                    close(handle);
                    wakeup(); // wake up again to trigger thread death
                } catch (Throwable e) {
                    ExceptionMonitor.getInstance().exceptionCaught(e);
                } finally {
                    cancelledHandles++;
                }
            }

            future.setDone();
        }

        return cancelledHandles;
    }
535247
public void discardBody() {
        try (InputStream in = body) {
            InputStreams.discardAll(in);
        } catch (IOException e) {
            throw new RequestsException(e);
        } finally {
            close();
        }
    }
372135
def drop_namespaces(self):
        """"""
        self.session.query(NamespaceEntry).delete()
        self.session.query(Namespace).delete()
        self.session.commit()
253256
public void removeHandlers() {
    Iterator<HandlerRegistration> it = registrations.iterator();
    while (it.hasNext()) {
      HandlerRegistration r = it.next();

      /*
       * must remove before we call removeHandler. Might have come from nested
       * ResettableEventBus
       */
      it.remove();

      r.removeHandler();
    }
  }