void addLogListener(LogListener listener, LogFilter filter) { listenersLock.writeLock(); try { ArrayMap<LogListener, Object[]> listenersCopy = new ArrayMap<LogListener, Object[]>(listeners.getKeys(), listeners.getValues()); Object[] listenerObjects = listenersCopy.get(listener); if (listenerObjects == null) { // Only create a task queue for non-SynchronousLogListeners SerializedTaskQueue taskQueue = (listener instanceof SynchronousLogListener) ? null : new SerializedTaskQueue(listener.toString()); listenerObjects = new Object[] {filter, taskQueue}; } else if (filter != listenerObjects[0]) { // update the filter listenerObjects[0] = filter; } listenersCopy.put(listener, listenerObjects); recalculateFilters(listenersCopy); listeners = listenersCopy; } finally { listenersLock.writeUnlock(); } }
public void sort(Comparator<K> comparator) { List<K> sortedKeys = new ArrayList<K>(keys); Collections.sort(sortedKeys, comparator); List<V> sortedValues = new ArrayList<V>(sortedKeys.size()); for (K key : sortedKeys) { sortedValues.add(getByIdentity(key)); } clear(); for (int i = 0; i < sortedKeys.size(); i++) { put(sortedKeys.get(i), sortedValues.get(i)); } }
private void recalculateFilters(ArrayMap<LogListener, Object[]> listenersCopy) { List<LogFilter> filtersList = new ArrayList<LogFilter>(); int size = listenersCopy.size(); for (int i = 0; i < size; i++) { Object[] listenerObjects = listenersCopy.getValue(i); LogFilter filter = (LogFilter) listenerObjects[0]; if (filter == NULL_LOGGER_FILTER) { filters = ALWAYS_LOG; return; } filtersList.add(filter); } if (filtersList.isEmpty()) filters = null; filters = filtersList.toArray(new LogFilter[filtersList.size()]); }
void removeLogListener(LogListener listener) { listenersLock.writeLock(); try { ArrayMap<LogListener, Object[]> listenersCopy = new ArrayMap<LogListener, Object[]>(listeners.getKeys(), listeners.getValues()); listenersCopy.remove(listener); recalculateFilters(listenersCopy); listeners = listenersCopy; } finally { listenersLock.writeUnlock(); } }
/** * Finds a library for the bundle represented by this class path managert * @param libname the library name * @return The absolution path to the library or null if not found */ public String findLibrary(String libname) { synchronized (this) { if (loadedLibraries == null) loadedLibraries = new ArrayMap<String, String>(1); } synchronized (loadedLibraries) { // we assume that each classloader will load a small number of of libraries // instead of wasting space with a map we iterate over our collection of found libraries // each element is a String[2], each array is {"libname", "libpath"} String libpath = loadedLibraries.get(libname); if (libpath != null) return libpath; libpath = classloader.getDelegate().findLibrary(libname); if (libpath != null) loadedLibraries.put(libname, libpath); return libpath; } }
void logPrivileged(Bundle bundle, String name, Object context, int level, String message, Throwable exception) { LogEntry logEntry = new ExtendedLogEntryImpl(bundle, name, context, level, message, exception); listenersLock.readLock(); try { int size = listeners.size(); for (int i = 0; i < size; i++) { Object[] listenerObjects = listeners.getValue(i); LogFilter filter = (LogFilter) listenerObjects[0]; if (safeIsLoggable(filter, bundle, name, level)) { LogListener listener = listeners.getKey(i); SerializedTaskQueue taskQueue = (SerializedTaskQueue) listenerObjects[1]; if (taskQueue != null) { taskQueue.put(new LogTask(logEntry, listener)); } else { // log synchronously safeLogged(listener, logEntry); } } } } finally { listenersLock.readUnlock(); } }
private ArrayMap<BundleCapability, BaseDescription> asArrayMap(List<BaseDescription> descriptions, String namespace) { List<BundleCapability> capabilities = new ArrayList<BundleCapability>(descriptions.size()); for (BaseDescription description : descriptions) capabilities.add(((BaseDescriptionImpl) description).getCapability(namespace)); return new ArrayMap<BundleCapability, BaseDescription>(capabilities, descriptions); }
for (ResolverBundle bundle : resolvableBundles) resolvableRevisions.add(bundle.getBundleDescription()); ArrayMap<BundleRevision, ResolverBundle> resolvable = new ArrayMap<BundleRevision, ResolverBundle>(resolvableRevisions, resolvableBundles); int size = resolvableBundles.size(); hook.filterResolvable(resolvable); if (resolvable.size() < size) { hookDisabled = new ArrayList<ResolverBundle>(unresolvedBundles); hookDisabled.removeAll(resolvableBundles);
void addLogListener(LogListener listener, LogFilter filter) { listenersLock.writeLock(); try { Object[] listenerObjects = listeners.get(listener); if (listenerObjects == null) { // Only create a task queue for non-SynchronousLogListeners SerializedTaskQueue taskQueue = (listener instanceof SynchronousLogListener) ? null : new SerializedTaskQueue(listener.toString()); listenerObjects = new Object[] {filter, taskQueue}; } else if (filter != listenerObjects[0]) { // update the filter listenerObjects[0] = filter; } listeners.put(listener, listenerObjects); recalculateFilters(); } finally { listenersLock.writeUnlock(); } }
public boolean removeAll(Collection<?> c) { boolean result = false; for (Object key : c) result |= remove(key); return result; }
public synchronized BundleFile getBundleFile(Object content, boolean base) { return base ? bundleFile : (bundleFiles == null) ? null : bundleFiles.get(content); }
private V getByIdentity(K key) { int index = 0; for (K existing : keys) { if (existing == key) return getValue(index); index++; } return null; } }
/** * Finds a library for the bundle represented by this class path managert * @param libname the library name * @return The absolution path to the library or null if not found */ public String findLibrary(String libname) { synchronized (this) { if (loadedLibraries == null) loadedLibraries = new ArrayMap<String, String>(1); } synchronized (loadedLibraries) { // we assume that each classloader will load a small number of of libraries // instead of wasting space with a map we iterate over our collection of found libraries // each element is a String[2], each array is {"libname", "libpath"} String libpath = loadedLibraries.get(libname); if (libpath != null) return libpath; libpath = classloader.getDelegate().findLibrary(libname); if (libpath != null) loadedLibraries.put(libname, libpath); return libpath; } }
if (incrementNestedCount() >= MAX_RECURSIONS) return; int size = listenersCopy.size(); for (int i = 0; i < size; i++) { Object[] listenerObjects = listenersCopy.getValue(i); LogFilter filter = (LogFilter) listenerObjects[0]; if (safeIsLoggable(filter, bundle, name, level)) { LogListener listener = listenersCopy.getKey(i); SerializedTaskQueue taskQueue = (SerializedTaskQueue) listenerObjects[1]; if (taskQueue != null) {
private ArrayMap<BundleCapability, BaseDescription> asArrayMap(List<BaseDescription> descriptions, String namespace) { List<BundleCapability> capabilities = new ArrayList<BundleCapability>(descriptions.size()); for (BaseDescription description : descriptions) capabilities.add(((BaseDescriptionImpl) description).getCapability(namespace)); return new ArrayMap<BundleCapability, BaseDescription>(capabilities, descriptions); }
for (ResolverBundle bundle : resolvableBundles) resolvableRevisions.add(bundle.getBundleDescription()); ArrayMap<BundleRevision, ResolverBundle> resolvable = new ArrayMap<BundleRevision, ResolverBundle>(resolvableRevisions, resolvableBundles); int size = resolvableBundles.size(); hook.filterResolvable(resolvable); if (resolvable.size() < size) { hookDisabled = new ArrayList<ResolverBundle>(unresolvedBundles); hookDisabled.removeAll(resolvableBundles);