@Override public void update(int tick) { sortEntities(); @SuppressWarnings("unchecked") List<Entity> sorted = (List<Entity>) entities.clone(); Collections.reverse(sorted); for (Entity entity : sorted) { entity.update(tick); if (entity.isDead()) { if (entity.equals(selectedEntity)) selectedEntity = null; entities.remove(entity); } } for (Projectile p : projectiles) { p.update(tick); if (p.isDead()) projectiles.remove(p); } for (Animation a : animations) { a.update(tick); if (a.isDead()) animations.remove(a); } }
/** * Einen Listener wieder austragen * * @param listen */ public void removeListener(HeartListener listen) { // remove the listener from the three lists // actually, it's contained in only one of them, but we don't know which one highFrequencyListeners.remove(listen); mediumFrequencyListeners.remove(listen); lowFrequencyListeners.remove(listen); }
/** * Disconnects consumer from this pipe. Fires pipe connection event. * * @param consumer Consumer that should be removed * @return <code>true</code> on success, <code>false</code> otherwise */ public boolean unsubscribe(IConsumer consumer) { if (consumers.remove(consumer)) { fireConsumerConnectionEvent(consumer, PipeConnectionEvent.CONSUMER_DISCONNECT, null); listeners.remove(consumer); return true; } else { return false; } }
/** * Disconnects provider from this pipe. Fires pipe connection event. * * @param provider Provider that should be removed * @return <code>true</code> on success, <code>false</code> otherwise */ public boolean unsubscribe(IProvider provider) { if (providers.remove(provider)) { fireProviderConnectionEvent(provider, PipeConnectionEvent.PROVIDER_DISCONNECT, null); listeners.remove(provider); return true; } else { return false; } }
private void addToHistory( final List<? extends PsiElement> elements, final FindUsagesOptions findUsagesOptions) { SearchData data = createSearchData(elements, findUsagesOptions); myFindUsagesHistory.remove(data); myFindUsagesHistory.add(data); // todo configure history depth limit if (myFindUsagesHistory.size() > 15) { myFindUsagesHistory.remove(0); } }
/** * Removes the specified driver from the {@code DriverManager}'s list of registered drivers. * * <p>If a {@code null} value is specified for the driver to be removed, then no action is taken. * * <p>If a security manager exists and its {@code checkPermission} denies permission, then a * {@code SecurityException} will be thrown. * * <p>If the specified driver is not found in the list of registered drivers, then no action is * taken. If the driver was found, it will be removed from the list of registered drivers. * * <p>If a {@code DriverAction} instance was specified when the JDBC driver was registered, its * deregister method will be called prior to the driver being removed from the list of registered * drivers. * * @param driver the JDBC Driver to remove * @exception SQLException if a database access error occurs * @throws SecurityException if a security manager exists and its {@code checkPermission} method * denies permission to deregister a driver. * @see SecurityManager#checkPermission */ @CallerSensitive public static synchronized void deregisterDriver(Driver driver) throws SQLException { if (driver == null) { return; } SecurityManager sec = System.getSecurityManager(); if (sec != null) { sec.checkPermission(DEREGISTER_DRIVER_PERMISSION); } println("DriverManager.deregisterDriver: " + driver); DriverInfo aDriver = new DriverInfo(driver, null); if (registeredDrivers.contains(aDriver)) { if (isDriverAllowed(driver, Reflection.getCallerClass())) { DriverInfo di = registeredDrivers.get(registeredDrivers.indexOf(aDriver)); // If a DriverAction was specified, Call it to notify the // driver that it has been deregistered if (di.action() != null) { di.action().deregister(); } registeredDrivers.remove(aDriver); } else { // If the caller does not have permission to load the driver then // throw a SecurityException. throw new SecurityException(); } } else { println(" couldn't find driver to unload"); } }
/** * Removes the given role change listener from be called for changes in roles. * * @param listener the listener to unregister, cannot be <code>null</code>. * @throws IllegalArgumentException in case the given listener was <code>null</code>. */ public void removeRoleChangeListener(RoleChangeListener listener) { if (listener == null) { throw new IllegalArgumentException("RoleChangeListener cannot be null!"); } m_listeners.remove(listener); }
protected void advanceInitializers(IOFSwitchExt sw) { CopyOnWriteArrayList<IOFInitializerListener> initializers = initializerMap.get(sw); // Remove first initializer if it exists Iterator<IOFInitializerListener> it = initializers.iterator(); if (it.hasNext()) { IOFInitializerListener initializer = it.next(); initializers.remove(initializer); log.debug("Remaining initializers for switch {}: {}", sw, initializers); } if (it.hasNext()) { IOFInitializerListener initializer = it.next(); queueInitializer(sw, initializer); } else { /** * Must synchronize here to ensure we don't transition into active while simultaneously being * disconnected. */ synchronized (sw) { if (!OFSwitchState.DISCONNECTED.equals(sw.getState())) { sw.transitionToState(OFSwitchState.ACTIVE); // Add switch to active list addActiveSwitch(sw); } initializerMap.remove(sw); } } }
public void remove(E e) { for (int i = 0; i < replicas; ++i) { Long hash = Long.valueOf(func.hash(e.toString() + i)); circle.remove(hash); } values.remove(e); }
/** Called by {@link Executor} to kill excessive executors from this computer. */ /*package*/ synchronized void removeExecutor(Executor e) { executors.remove(e); addNewExecutorIfNecessary(); if (!isAlive()) { AbstractCIBase ciBase = Jenkins.getInstance(); ciBase.removeComputer(this); } }
private void doOperations() { for (RobotOperation operation : operationList) { if (operation.isFinished()) { operation.onFinish(robot); operationList.remove(operation); } else operation.tick(robot); } }
/* * @see org.gamegineer.table.net.ITableNetwork#removeTableNetworkListener(org.gamegineer.table.net.ITableNetworkListener) */ @Override public void removeTableNetworkListener(final ITableNetworkListener listener) { assertArgumentLegal( listeners_.remove(listener), "listener", NonNlsMessages .TableNetwork_removeTableNetworkListener_listener_notRegistered); //$NON-NLS-1$ }
/** * Unregisters a display transaction listener to provide the client a chance to update its * surfaces within the same transaction as any display layout updates. * * @param listener The listener to unregister. */ public void unregisterDisplayTransactionListener(DisplayTransactionListener listener) { if (listener == null) { throw new IllegalArgumentException("listener must not be null"); } // List is self-synchronized copy-on-write. mDisplayTransactionListeners.remove(listener); }
public void remove(String item) { for (Item i : inventory) { if (i.getName() == item) { inventory.remove(i); System.out.println("Item " + item + " removed from inventory."); } } }
/** * Undeploy the aop config * * @param url the url */ protected void undeploy(URL url) { try { log.debug("Undeploying " + url); urls.remove(url); AspectXmlLoader.undeployXML(url); } catch (Exception e) { log.warn("Ignored error undeploying " + url, e); } }
public void removeDialog(Dialog d) { for (int i = 0; i < dialogs.size(); i++) { DialogWrapper p = dialogs.get(i); if (p.getDialog().equals(d)) { p.release(); dialogs.remove(i); return; } } }
public void rerunAndRecallFromHistory(@NotNull SearchData searchData) { myFindUsagesHistory.remove(searchData); PsiElement[] elements = restorePsiElements(searchData, true); if (elements == null || elements.length == 0) return; UsageInfoToUsageConverter.TargetElementsDescriptor descriptor = new UsageInfoToUsageConverter.TargetElementsDescriptor(elements); final FindUsagesHandler handler = getFindUsagesHandler(elements[0], false); if (handler == null) return; findUsages(descriptor, handler, false, false, searchData.myOptions); }
/** * Disassociates given {@link View}. If view is not associated, nothing happens. * * @param view View to be disassociated */ public void removeView(final View view) { for (int i = 0; i < mViewList.size(); i++) { final ViewWeakReference reference = mViewList.get(i); final View item = reference.get(); if (item == null || item == view) { // Always remove null references to reduce Set size mViewList.remove(reference); } } }
/** * Associates given {@link View}. If view has been already added, nothing happens. * * @param view View to be associated */ public void addView(final View view) { for (int i = 0; i < mViewList.size(); i++) { final ViewWeakReference reference = mViewList.get(i); final View item = reference.get(); if (item == null) { // Always remove null references to reduce Set size mViewList.remove(reference); } } mViewList.addIfAbsent(new ViewWeakReference(view)); }
@Override public synchronized Layer remove(int index) { mDirtyLayers = true; Layer remove = mLayerList.remove(index); if (remove instanceof UpdateListener) mMap.events.unbind((UpdateListener) remove); if (remove instanceof InputListener) mMap.input.unbind((InputListener) remove); return remove; }
private boolean executePhase(CommandPhase phase, CopyOnWriteArrayList<Command> commands) { for (Command command : commands) { if (phase.equals(command.getPhase())) { commands.remove(command); if (command instanceof FurnaceDependent) ((FurnaceDependent) command).setFurnace(furnace); CommandResult result = command.execute(); if (CommandResult.EXIT.equals(result)) return false; } } return true; }
/** {@inheritDoc} */ public void removeItem(int index) { if (index < 0 || index >= items.size()) { return; } items.remove(index); if (index < currentItemIndex) { // item was removed before the currently playing currentItemIndex--; } else if (index == currentItemIndex) { // TODO: the currently playing item is removed - this should be handled differently currentItemIndex--; } }
@Override public void unscheduleDrawable(final Drawable who, final Runnable what) { for (int i = 0; i < mViewList.size(); i++) { final ViewWeakReference reference = mViewList.get(i); final View view = reference.get(); if (view != null) { view.unscheduleDrawable(who); } else { // Always remove null references to reduce Set size mViewList.remove(reference); } } }
/* * Remove this class, that is stored in a class variable in CommunicationServlet, called connections */ private void removeConnection() { Enumeration<String> keys = CommunicationWebsocketServlet.connections.keys(); while (keys.hasMoreElements()) { String key = keys.nextElement(); CopyOnWriteArrayList<CommunicationWebsocketBusiness> conn = CommunicationWebsocketServlet.connections.get(key); for (int i = 0; i < conn.size(); i++) { CommunicationWebsocketBusiness c = conn.get(i); if (c.connection == this.connection) { conn.remove(c); System.out.println("Closed conn"); } } } }
private void releaseDialogs(boolean finish) { // clean up dialogs when activity is pausing or finishing for (Iterator<DialogWrapper> iter = dialogs.iterator(); iter.hasNext(); ) { DialogWrapper p = iter.next(); Dialog dialog = p.getDialog(); boolean persistent = p.getPersistent(); // if the activity is pausing but not finishing, clean up dialogs only if // they are non-persistent if (finish || !persistent) { if (dialog != null && dialog.isShowing()) { dialog.dismiss(); } dialogs.remove(p); } } }
/** * Remove a value from the bag. This method should only be called with objects obtained by <code> * borrow(long, TimeUnit)</code> or <code>reserve(T)</code> * * @param bagEntry the value to remove * @return true if the entry was removed, false otherwise * @throws IllegalStateException if an attempt is made to remove an object from the bag that was * not borrowed or reserved first */ public boolean remove(final T bagEntry) { if (!bagEntry.compareAndSet(STATE_IN_USE, STATE_REMOVED) && !bagEntry.compareAndSet(STATE_RESERVED, STATE_REMOVED) && !closed) { LOGGER.warn( "Attempt to remove an object from the bag that was not borrowed or reserved: {}", bagEntry); return false; } final boolean removed = sharedList.remove(bagEntry); if (!removed && !closed) { LOGGER.warn("Attempt to remove an object from the bag that does not exist: {}", bagEntry); } // synchronizer.signal(); return removed; }
public void unregisterEventListener(String event, GeckoEventListener listener) { synchronized (mEventListeners) { CopyOnWriteArrayList<GeckoEventListener> listeners = mEventListeners.get(event); if (listeners == null) { Log.w(LOGTAG, "unregisterEventListener: event '" + event + "' has no listeners"); return; } if (!listeners.remove(listener)) { Log.w( LOGTAG, "unregisterEventListener: tried to remove an unregistered listener " + "for event '" + event + "'"); } if (listeners.size() == 0) { mEventListeners.remove(event); } } }
@Override public Object remove(final int index) { return copyOnWriteArrayList.remove(index); }
@Override public boolean remove(final Object o) { return copyOnWriteArrayList.remove(o); }
@Override public void removeThingLogicManagerListener(IThingLogicManagerListener l) { listeners.remove(l); }