/** * Clear all bindings in this context builder, while keeping it active. */ public void clear() { this.boundObjects.clear(); }
/** This call will clear all logger definitions from the internal hashtable. Invoking this method will irrevocably mess up the logger hierarchy. <p>You should <em>really</em> know what you are doing before invoking this method. @since 0.9.0 */ public void clear() { //System.out.println("\n\nAbout to clear internal hash table."); ht.clear(); }
public void clear() { map.clear(); }
public static void clear() { objectMethods.clear(); }
public void clear() { counterTable.clear(); } }
/** * Clear all parameters set with setParameter. */ public void clearParameters() { if (null == m_params) return; m_params.clear(); }
/** * Clear all bindings in this context builder, while keeping it active. */ public void clear() { this.boundObjects.clear(); }
@Override public void clear() { map.clear(); nulls.clear(); }
/** * Sets the stream handler factory for this VM. * * @throws Error if a URLStreamHandlerFactory has already been installed * for the current VM. */ public static synchronized void setURLStreamHandlerFactory(URLStreamHandlerFactory factory) { if (streamHandlerFactory != null) { throw new Error("Factory already set"); } streamHandlers.clear(); streamHandlerFactory = factory; }
/** * Release any internal references to previously created * {@link org.apache.commons.logging.Log} * instances returned by this factory. This is useful in environments * like servlet containers, which implement application reloading by * throwing away a ClassLoader. Dangling references to objects in that * class loader would prevent garbage collection. */ public void release() { logDiagnostic("Releasing all known loggers"); instances.clear(); }
private void clear0() { if(!java1 && tlm != null) { Hashtable ht = (Hashtable) ((ThreadLocalMap)tlm).get(); if(ht != null) { ht.clear(); } if(removeMethod != null) { // java 1.3/1.4 does not have remove - will suffer from a memory leak try { removeMethod.invoke(tlm, null); } catch (IllegalAccessException e) { // should not happen } catch (InvocationTargetException e) { // should not happen } } } }
/** * Close the class pool */ public void close() { this.removeClassPath(classPath); classes.clear(); softcache.clear(); }
/** * Release any internal references to previously created * {@link org.apache.commons.logging.Log} * instances returned by this factory. This is useful in environments * like servlet containers, which implement application reloading by * throwing away a ClassLoader. Dangling references to objects in that * class loader would prevent garbage collection. */ public void release() { logDiagnostic("Releasing all known loggers"); instances.clear(); }
/** * Close the class pool */ public void close() { this.removeClassPath(classPath); classes.clear(); softcache.clear(); }
final void reset() { this.count = 0; this.m_namespaces.clear(); this.m_nodeStack.clear(); initNamespaces(); }
/** * Close the class pool */ public void close() { this.removeClassPath(classPath); classPath.close(); classes.clear(); softcache.clear(); }
void clearURLHandlers() throws Exception { final Field handlersFields = URL.class.getDeclaredField("handlers"); if (handlersFields != null) { if (!handlersFields.isAccessible()) { handlersFields.setAccessible(true); } @SuppressWarnings("unchecked") final Hashtable<String, URLStreamHandler> handlers = (Hashtable<String, URLStreamHandler>) handlersFields .get(null); if (handlers != null) { handlers.clear(); } } }
public void addAllToSelection() { // Just remove it all from both lists // Then add input[] to the destination list... // This is much faster. wListSource.removeAll(); wListDest.removeAll(); selection.clear(); for ( int i = 0; i < input.length; i++ ) { wListDest.add( input[i] ); selection.put( Integer.valueOf( i ), input[i] ); } setPageComplete( canFlipToNextPage() ); }
/** * Close the class pool */ public void close() { this.removeClassPath(classPath); classPath.close(); classes.clear(); softcache.clear(); }
public void removeAllFromSelection() { // Just remove it all from both lists // Then add input[] to the source list... // This is much faster. wListSource.removeAll(); wListDest.removeAll(); selection.clear(); for ( int i = 0; i < input.length; i++ ) { wListSource.add( input[i] ); } setPageComplete( canFlipToNextPage() ); }