@Override public void reset() { synchronized (mutex) { index = -1; currentKeyMemory = Memory.CONST_INT_M1; currentKey = currentKeyMemory; iterator = stack.iterator(); } } };
private List<String> getAllCurrentGroups() { List<String> allCurrentGroups = new LinkedList<>(); Iterator<List<String>> it = groupStack.iterator(); while(it.hasNext()) { for (String groupName : it.next()) { if (!allCurrentGroups.contains(groupName)) { allCurrentGroups.add(groupName); } } } return allCurrentGroups; } }
/** * Returns a {@code List} of all the opened/active activities. * * @return a {@code List} of all the opened/active activities */ public ArrayList<Activity> getAllOpenedActivities() { ArrayList<Activity> activities = new ArrayList<Activity>(); Iterator<WeakReference<Activity>> activityStackIterator = activityStack.iterator(); while(activityStackIterator.hasNext()){ Activity activity = activityStackIterator.next().get(); if(activity!=null) activities.add(activity); } return activities; }
/** * Removes a given activity from the activity stack * * @param activity the activity to remove */ private void removeActivityFromStack(Activity activity){ Iterator<WeakReference<Activity>> activityStackIterator = activityStack.iterator(); while(activityStackIterator.hasNext()){ Activity activityFromWeakReference = activityStackIterator.next().get(); if(activityFromWeakReference == null){ activityStackIterator.remove(); } if(activity != null && activityFromWeakReference != null && activityFromWeakReference.equals(activity)){ activityStackIterator.remove(); } } }
/** * Clears any objects sitting idle in the pool. Silently swallows any * exceptions thrown by {@link PoolableObjectFactory#destroyObject(Object)}. */ @Override public synchronized void clear() { if(null != _factory) { Iterator<T> it = _pool.iterator(); while(it.hasNext()) { try { _factory.destroyObject(it.next()); } catch(Exception e) { // ignore error, keep destroying the rest } } } _pool.clear(); }
/** * Destroys all instances in the stack and clears the stack. * * @param key key passed to factory when destroying instances * @param stack stack to destroy */ private synchronized void destroyStack(K key, Stack<V> stack) { if(null == stack) { return; } else { if(null != _factory) { Iterator<V> it = stack.iterator(); while(it.hasNext()) { try { _factory.destroyObject(key,it.next()); } catch(Exception e) { // ignore error, keep destroying the rest } } } _totIdle -= stack.size(); _activeCount.remove(key); stack.clear(); } }
public void dispose(boolean force) { /////////////////////////////////////////////////////////////////////// // // Dispose local intermediate operations // /////////////////////////////////////////////////////////////////////// final Iterator<RenderedImage> it = intermediateOps.iterator(); while (it.hasNext()) { final PlanarImage image = PlanarImage.wrapRenderedImage((RenderedImage) it.next()); image.dispose(); } super.dispose(force); }
@SuppressWarnings("unchecked") public <T extends Edge> Iterator<T> getEdgeIterator() { return (Iterator<T>) edgePath.iterator(); }
/** * {@inheritDoc} */ public Iterator renderStackIterator() { return _renderStack.iterator(); }
Object get(Object key) { if (pairs == null) { return null; } for (Iterator i = pairs.iterator(); i.hasNext();) { KeyValuePair pair = (KeyValuePair)i.next(); if (pair.key == key) { return pair.value; } } return null; }
Object get(Object key) { if (pairs == null) { return null; } for (Iterator i = pairs.iterator(); i.hasNext();) { KeyValuePair pair = (KeyValuePair)i.next(); if (pair.key == key) { return pair.value; } } return null; }
public boolean containsValue(Object value) { for (Iterator it = stack.iterator(); it.hasNext();) { if (((Map)it.next()).containsValue(value)) return true; } return false; }
private static String toBundleName(final Stack<String> path) { final StringBuilder sb = new StringBuilder(); final Iterator<String> iterator = path.iterator(); while (iterator.hasNext()) { sb.append(iterator.next()); if (iterator.hasNext()) { sb.append("."); } } return sb.toString(); }
protected String getElementXpath(Stack<String> elementStack) { StringBuilder xPath = new StringBuilder(); Iterator<String> itr = elementStack.iterator(); while (itr.hasNext()) { xPath.append(itr.next()); if (itr.hasNext()) { xPath.append("/"); } } return xPath.toString(); }
private static String makePath(Stack<String> propertyPath) { StringBuilder sb = new StringBuilder(); for (Iterator<String> iterator = propertyPath.iterator(); iterator.hasNext(); ) { String s = iterator.next(); sb.append(s); if (iterator.hasNext()) { sb.append("."); } } return sb.toString(); }
protected String getContext() { StringBuffer buf = new StringBuffer(); for (Iterator iter = contextStack.iterator(); iter.hasNext();) { String ctx = (String) iter.next(); buf.append(ctx).append("/"); } if (buf.length() > 0) { buf.setLength(buf.length() - 1); } return buf.toString(); }
private String getContext() { StringBuffer buf = new StringBuffer(); for (Iterator iter = context.iterator(); iter.hasNext();) { String ctx = (String) iter.next(); buf.append(ctx).append("/"); } if (buf.length() > 0) { buf.setLength(buf.length() - 1); } return buf.toString(); }
public Map<String, SymbolType> flat() { Map<String, SymbolType> result = new LinkedHashMap<String, SymbolType>(); Iterator<Scope> it = indexStructure.iterator(); while (it.hasNext()) { Scope scope = it.next(); List<Symbol<?>> symbols = scope.getSymbols(); for (Symbol<?> s : symbols) { result.put(s.getName(), s.getType()); } } return result; }
public void clearProblems() { getDefaultLogger().clearProblems(); for (Iterator iter = getLoggerStack().iterator(); iter.hasNext();) { MessageLogger l = (MessageLogger) iter.next(); l.clearProblems(); } problems.clear(); errors.clear(); warns.clear(); }
public void setShowProgress(boolean progress) { getDefaultLogger().setShowProgress(progress); // updates all loggers in the stack for (Iterator iter = getLoggerStack().iterator(); iter.hasNext();) { MessageLogger l = (MessageLogger) iter.next(); l.setShowProgress(progress); } }