public void removePhaseListener(PhaseListener listener) {
if (listener == null) throw new NullPointerException();
synchronized (_phaseList) {
_phaseList.remove(listener);
_phaseListeners = new PhaseListener[_phaseList.size()];
_phaseList.toArray(_phaseListeners);
}
}
protected synchronized Message receiveMessage() throws IOException {
if (messageBuffer.size() > 0) {
Message m = (Message) messageBuffer.get(0);
messageBuffer.remove(0);
return m;
}
try {
InetSocketAddress remoteAddress = (InetSocketAddress) channel.receive(receiveBuffer);
if (remoteAddress != null) {
int len = receiveBuffer.position();
receiveBuffer.rewind();
receiveBuffer.get(buf, 0, len);
try {
IP address = IP.fromInetAddress(remoteAddress.getAddress());
int port = remoteAddress.getPort();
extractor.appendData(buf, 0, len, new SocketDescriptor(address, port));
receiveBuffer.clear();
extractor.updateAvailableMessages();
return extractor.nextMessage();
} catch (EOFException exc) {
exc.printStackTrace();
System.err.println(buf.length + ", " + len);
} catch (InvocationTargetException exc) {
exc.printStackTrace();
} catch (IllegalAccessException exc) {
exc.printStackTrace();
} catch (InstantiationException exc) {
exc.printStackTrace();
} catch (IllegalArgumentException e) {
e.printStackTrace();
} catch (InvalidCompressionMethodException e) {
e.printStackTrace();
}
}
} catch (ClosedChannelException exc) {
if (isKeepAlive()) {
throw exc;
}
}
return null;
}
/*
* Non-recursive version of object descend. This consumes more memory than recursive in-depth
* traversal but prevents stack overflows on long chains of objects
* or complex graphs (a max. recursion depth on my machine was ~5000 objects linked in a chain
* so not too much).
*/
private static long measureObjectSize(Object root) {
// Objects seen so far.
final IdentityHashSet<Object> seen = new IdentityHashSet<Object>();
// Class cache with reference Field and precalculated shallow size.
final IdentityHashMap<Class<?>, ClassCache> classCache =
new IdentityHashMap<Class<?>, ClassCache>();
// Stack of objects pending traversal. Recursion caused stack overflows.
final ArrayList<Object> stack = new ArrayList<Object>();
stack.add(root);
long totalSize = 0;
while (!stack.isEmpty()) {
final Object ob = stack.remove(stack.size() - 1);
if (ob == null || seen.contains(ob)) {
continue;
}
seen.add(ob);
final Class<?> obClazz = ob.getClass();
if (obClazz.isArray()) {
/*
* Consider an array, possibly of primitive types. Push any of its references to
* the processing stack and accumulate this array's shallow size.
*/
long size = NUM_BYTES_ARRAY_HEADER;
final int len = Array.getLength(ob);
if (len > 0) {
Class<?> componentClazz = obClazz.getComponentType();
if (componentClazz.isPrimitive()) {
size += (long) len * primitiveSizes.get(componentClazz);
} else {
size += (long) NUM_BYTES_OBJECT_REF * len;
// Push refs for traversal later.
for (int i = len; --i >= 0; ) {
final Object o = Array.get(ob, i);
if (o != null && !seen.contains(o)) {
stack.add(o);
}
}
}
}
totalSize += alignObjectSize(size);
} else {
/*
* Consider an object. Push any references it has to the processing stack
* and accumulate this object's shallow size.
*/
try {
ClassCache cachedInfo = classCache.get(obClazz);
if (cachedInfo == null) {
classCache.put(obClazz, cachedInfo = createCacheEntry(obClazz));
}
for (Field f : cachedInfo.referenceFields) {
// Fast path to eliminate redundancies.
final Object o = f.get(ob);
if (o != null && !seen.contains(o)) {
stack.add(o);
}
}
totalSize += cachedInfo.alignedShallowInstanceSize;
} catch (IllegalAccessException e) {
// this should never happen as we enabled setAccessible().
throw new RuntimeException("Reflective field access failed?", e);
}
}
}
// Help the GC (?).
seen.clear();
stack.clear();
classCache.clear();
return totalSize;
}
/* Removes descriptor from the list and returns it. Returns {@code null}
if descriptor is not found */
private static Descriptor remove(ArrayList<Descriptor> list, Descriptor item) {
if (list.remove(item)) return item;
else return null;
}
public void clearBackPointerR8008To(ComponentVisibility_c target) {
synchronized (backPointer_MadeUpOfComponentVisibilityMadeUpOf_R8008) {
backPointer_MadeUpOfComponentVisibilityMadeUpOf_R8008.remove(target);
}
}
public void clearBackPointerR628To(ActualParameter_c target) {
synchronized (backPointer_TakesActualParameterTakes_R628) {
backPointer_TakesActualParameterTakes_R628.remove(target);
}
}