Attachment #164433 for bug #308650

Some Eclipse Foundation services are deprecated, or will be soon. Please ensure you've read this important communication.

Lines 10-15 Link Here

(-)src/org/eclipse/e4/core/internal/contexts/ContextObjectSupplier.java (-9 / +43 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.e4.core.internal.contexts;	11	package org.eclipse.e4.core.internal.contexts;
12		12
		13	import java.lang.reflect.InvocationTargetException;
		14
13	import javax.inject.Named;	15	import javax.inject.Named;
14		16
15	import org.eclipse.e4.core.contexts.ContextChangeEvent;	17	import org.eclipse.e4.core.contexts.ContextChangeEvent;
Lines 19-24 Link Here
19	import org.eclipse.e4.core.di.IInjector;	21	import org.eclipse.e4.core.di.IInjector;
20	import org.eclipse.e4.core.di.IObjectDescriptor;	22	import org.eclipse.e4.core.di.IObjectDescriptor;
21	import org.eclipse.e4.core.di.IRequestor;	23	import org.eclipse.e4.core.di.IRequestor;
		24	import org.eclipse.e4.core.di.InjectionException;
22		25
23	public class ContextObjectSupplier extends AbstractObjectSupplier {	26	public class ContextObjectSupplier extends AbstractObjectSupplier {
24		27
Lines 36-42 Link Here
36	this.context = context;	39	this.context = context;
37	}	40	}
38		41
39	public boolean notify(ContextChangeEvent event) {	42	public boolean notify(ContextChangeEvent event, final IContextRecorder recorder) {
40	if (event.getEventType() == ContextChangeEvent.INITIAL) {	43	if (event.getEventType() == ContextChangeEvent.INITIAL) {
41	// needs to be done inside runnable to establish dependencies	44	// needs to be done inside runnable to establish dependencies
42	for (int i = 0; i < keys.length; i++) {	45	for (int i = 0; i < keys.length; i++) {
Lines 50-56 Link Here
50	}	53	}
51	return true;	54	return true;
52	}	55	}
53		56
54	IInjector injector = requestor.getInjector();	57	IInjector injector = requestor.getInjector();
55	if (event.getEventType() == ContextChangeEvent.DISPOSE) {	58	if (event.getEventType() == ContextChangeEvent.DISPOSE) {
56	IEclipseContext originatingContext = event.getContext();	59	IEclipseContext originatingContext = event.getContext();
Lines 67-76 Link Here
67	return false;	70	return false;
68	}	71	}
69	} else {	72	} else {
70	injector.update(new IRequestor[] { requestor }, requestor.getPrimarySupplier());	73	boolean resolved = injector.resolveArguments(requestor, requestor.getPrimarySupplier());
		74	if (resolved) {
		75	if (recorder != null)
		76	recorder.stopAccessRecording();
		77
		78	try {
		79	requestor.execute();
		80	} catch (InvocationTargetException e) {
		81	logError("Injection failed for the object \""
		82	+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
		83	+ requestor.toString() + "\"");
		84	return false;
		85	} catch (InstantiationException e) {
		86	logError("Injection failed for the object \""
		87	+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
		88	+ requestor.toString() + "\"");
		89	return false;
		90	} finally {
		91	if (recorder != null)
		92	recorder.startAcessRecording();
		93	}
		94	}
71	}	95	}
72	return true;	96	return true;
73	}	97	}
		98
		99	public boolean notify(ContextChangeEvent event) {
		100	return notify(event, null);
		101	}
74		102
75	@Override	103	@Override
76	public int hashCode() {	104	public int hashCode() {
Lines 103-117 Link Here
103	return true;	131	return true;
104	}	132	}
105		133
106	public Object getObject() {
107	// XXX remove?
108	// TODO Auto-generated method stub
109	return null;
110	}
111
112	public boolean batchProcess() {	134	public boolean batchProcess() {
113	return requestor.shouldGroupUpdates();	135	return requestor.shouldGroupUpdates();
114	}	136	}
		137
115	}	138	}
116		139
117	final static private String ECLIPSE_CONTEXT_NAME = IEclipseContext.class.getName();	140	final static private String ECLIPSE_CONTEXT_NAME = IEclipseContext.class.getName();
Lines 186-190 Link Here
186	context.set(key, objectSupplier);	209	context.set(key, objectSupplier);
187	return objectSupplier;	210	return objectSupplier;
188	}	211	}
		212	// TBD implement logging
		213	static protected void logError(String msg) {
		214	logError(msg, new InjectionException());
		215	}
		216
		217	static protected void logError(String msg, Throwable e) {
		218	if (msg != null)
		219	System.err.println(msg);
		220	if (e != null)
		221	e.printStackTrace();
		222	}
189		223
190	}	224	}




		}
	}

	static class TrackableComputationExt extends Computation implements IRunAndTrack, IContextRecorder {

		private ContextChangeEvent cachedEvent;


			this.runnable = runnable;
		}

		public Object getObject() {
			if (runnable instanceof IRunAndTrackObject)
				return ((IRunAndTrackObject) runnable).getObject();
			return null;
		}

		final protected void doHandleInvalid(ContextChangeEvent event, List<Scheduled> scheduledList) {
			int eventType = event.getEventType();
			if (eventType == ContextChangeEvent.INITIAL || eventType == ContextChangeEvent.DISPOSE) {

					cachedEvent = event;
					EclipseContext eventsContext = (EclipseContext) event.getContext();
					eventsContext.addWaiting(this);
					// eventsContext.getRoot().waiting.add(this);
					return true;
				}
			}

			boolean result = true;
			try {
				if (cachedEvent != null) {
					if (runnable instanceof IRunAndTrackObject)
						result = ((IRunAndTrackObject)runnable).notify(event, this);
					else
						result = runnable.notify(cachedEvent);
					cachedEvent = null;
				}
				if (eventType != ContextChangeEvent.UPDATE) {
					if (runnable instanceof IRunAndTrackObject)
						result = ((IRunAndTrackObject)runnable).notify(event, this);
					else
						result = runnable.notify(event);
				}
			} finally {
				currentComputation.set(oldComputation);
			}

		public String toString() {
			return "TrackableComputationExt(" + runnable + ')'; //$NON-NLS-1$
		}

		public void startAcessRecording() {
			currentComputation.set(this);
		}

		public void stopAccessRecording() {
			currentComputation.set(null);
		}
	}

	static class Scheduled {




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/

package org.eclipse.e4.core.internal.contexts;


public interface IContextRecorder {

	public void startAcessRecording();

	public void stopAccessRecording();
}





package org.eclipse.e4.core.internal.contexts;

import org.eclipse.e4.core.contexts.ContextChangeEvent;
import org.eclipse.e4.core.contexts.IRunAndTrack;

public interface IRunAndTrackObject extends IRunAndTrack {

	public Object getObject();

	public boolean batchProcess();
	
	public boolean notify(ContextChangeEvent event, IContextRecorder recorder);

}





	public boolean injectStatic(Class<?> clazz, AbstractObjectSupplier objectSupplier);

	public boolean update(IRequestor[] requestors, AbstractObjectSupplier objectSupplier);

	public boolean disposed(AbstractObjectSupplier objectSupplier);

	public IBinding addBinding(Class<?> clazz);

	public IBinding addBinding(IBinding binding);

	public boolean resolveArguments(IRequestor requestor, AbstractObjectSupplier objectSupplier);
}

Lines 10-15 Link Here

(-)src/org/eclipse/e4/core/di/IRequestor.java (+3 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.e4.core.di;	11	package org.eclipse.e4.core.di;
12		12
		13	import java.lang.reflect.InvocationTargetException;
		14
13	// TBD this is really a "feedback" object.	15	// TBD this is really a "feedback" object.
14	/**	16	/**
15	* @noimplement This interface is not intended to be implemented by clients.	17	* @noimplement This interface is not intended to be implemented by clients.
Lines 31-34 Link Here
31		33
32	public boolean shouldGroupUpdates();	34	public boolean shouldGroupUpdates();
33		35
		36	public abstract Object execute() throws InvocationTargetException, InstantiationException;
34	}	37	}




		return true;
	}

	public boolean resolveArguments(IRequestor requestor, AbstractObjectSupplier objectSupplier) {
		ArrayList<Requestor> list = new ArrayList<Requestor>(1);
		list.add((Requestor)requestor);
			list.add((Requestor) requestor);
		}
		resolveRequestorArgs(list, objectSupplier, true);

		// Call requestors in order
		for (IRequestor requestor : requestors) {
			try {
				((Requestor) requestor).execute();
			} catch (InvocationTargetException e) {
				logError("Injection failed for the object \""
						+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
						+ requestor.toString() + "\"");
				return false;
			} catch (InstantiationException e) {
				logError("Injection failed for the object \""
						+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
						+ requestor.toString() + "\"");
				return false;
			}
		}
		return true;
	}


Lines 11-17 Link Here

(-)src/org/eclipse/e4/core/internal/di/Requestor.java (-3 lines)
11	package org.eclipse.e4.core.internal.di;	11	package org.eclipse.e4.core.internal.di;
12		12
13	import java.lang.ref.WeakReference;	13	import java.lang.ref.WeakReference;
14	import java.lang.reflect.InvocationTargetException;
15		14
16	import org.eclipse.e4.core.di.AbstractObjectSupplier;	15	import org.eclipse.e4.core.di.AbstractObjectSupplier;
17	import org.eclipse.e4.core.di.IInjector;	16	import org.eclipse.e4.core.di.IInjector;
Lines 39-46 Link Here
39		38
40	public abstract IObjectDescriptor[] getDependentObjects();	39	public abstract IObjectDescriptor[] getDependentObjects();
41		40
42	public abstract Object execute() throws InvocationTargetException, InstantiationException;
43
44	public Requestor(IInjector injector, AbstractObjectSupplier primarySupplier, Object requestingObject, boolean track, boolean groupUpdates,	41	public Requestor(IInjector injector, AbstractObjectSupplier primarySupplier, Object requestingObject, boolean track, boolean groupUpdates,
45	boolean isOptional) {	42	boolean isOptional) {
46	this.injector = injector;	43	this.injector = injector;




 *******************************************************************************/
package org.eclipse.e4.core.di.internal.extensions;

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;

import org.eclipse.e4.core.di.IInjector;
import org.eclipse.e4.core.di.IObjectDescriptor;
import org.eclipse.e4.core.di.IRequestor;
import org.eclipse.e4.core.di.InjectionException;
import org.eclipse.e4.core.di.extensions.Preferences;
import org.osgi.framework.FrameworkUtil;


		node.addPreferenceChangeListener(new IPreferenceChangeListener() {
			public void preferenceChange(PreferenceChangeEvent event) {
				IInjector requestorInjector = requestor.getInjector();
				if (requestorInjector != null) {
					boolean resolved = requestorInjector.resolveArguments(requestor, requestor
							.getPrimarySupplier());
					if (resolved) {
						try {
							requestor.execute();
						} catch (InvocationTargetException e) {
							logError("Injection failed for the object \""
									+ requestor.getRequestingObject().toString()
									+ "\". Unable to execute \"" + requestor.toString() + "\"");
							return;
						} catch (InstantiationException e) {
							logError("Injection failed for the object \""
									+ requestor.getRequestingObject().toString()
									+ "\". Unable to execute \"" + requestor.toString() + "\"");
							return;
						}
					}
				}
			}
		});
		synchronized (listenerCache) {

		}
	}

	// TBD implement logging
	static protected void logError(String msg) {
		logError(msg, new InjectionException());
	}

	static protected void logError(String msg, Throwable e) {
		if (msg != null)
			System.err.println(msg);
		if (e != null)
			e.printStackTrace();
	}

}




/*******************************************************************************
 * Copyright (c) 2010 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.e4.core.tests.services.internal.annotations;

import java.lang.reflect.InvocationTargetException;

import javax.inject.Inject;
import javax.inject.Named;

import junit.framework.TestCase;

import org.eclipse.e4.core.contexts.ContextInjectionFactory;
import org.eclipse.e4.core.contexts.EclipseContextFactory;
import org.eclipse.e4.core.contexts.IEclipseContext;
import org.eclipse.e4.core.di.IDisposable;
import org.eclipse.e4.core.di.annotations.PreDestroy;

public class ExtraDependenciesTest extends TestCase {

	static public class TestObject {
		
		public String string;
		public Integer integer;
		public String other;
		
		public boolean disposed = false;
		
		@Inject
		public void injectedMethod(@Named("arg1") String strValue, @Named("arg2") Integer intValue, IEclipseContext context) {
			string = strValue;
			integer = intValue;
			if (context == null) {
				other = null;
				return;
			}
			IEclipseContext otherContext = (IEclipseContext) context.get("otherContext");
			if (otherContext == null)
				other = null;
			else
				other = (String) otherContext.get("arg3");
		}
		
		@PreDestroy
		public void finita() {
			disposed = true;
		}
	}
	
	public void testExtraDependencies() throws InvocationTargetException, InstantiationException {
		IEclipseContext context = EclipseContextFactory.create();
		context.set("arg1", "abc");
		context.set("arg2", new Integer (123));
		
		IEclipseContext otherContext = EclipseContextFactory.create();
		otherContext.set("arg3", "other");
		
		context.set("otherContext", otherContext);
		
		TestObject object = (TestObject) ContextInjectionFactory.make(TestObject.class, context);
		
		// check that initial values are properly injected
		assertEquals("abc", object.string);
		assertEquals(new Integer(123), object.integer);
		assertEquals("other", object.other);
		
		// modify argument value to cause update - bug 308650
		context.set("arg2", new Integer (789));
		
		// change the "other" value; should not be propagated
		otherContext.set("arg3", "wrong");
		assertEquals("other", object.other);
		
		// dispose the other context; should not cause disposal of the test object
		((IDisposable)otherContext).dispose();
		assertEquals("other", object.other);
		assertFalse(object.disposed);
		
		// remove "other" context, should not be propagated
		context.remove("otherContext");
		assertEquals("other", object.other);
		
		// check that changes in the method arguments are propagated
		context.set("arg1", "xyz");
		context.set("arg2", new Integer (456));
		assertEquals("xyz", object.string);
		assertEquals(new Integer(456), object.integer);
		assertNull(object.other);
		
		// check that disposal of the injected context causes disposal of the injected object
		((IDisposable)context).dispose();
		assertTrue(object.disposed);
		assertNull(object.string);
		assertNull(object.integer);
		assertNull(object.other);
	}

}

Lines 29-33 Link Here

(-)src/org/eclipse/e4/core/tests/services/internal/annotations/ServicesTestSuiteAnnotations.java (+1 lines)
29	addTestSuite(InjectionOrderTest.class);	29	addTestSuite(InjectionOrderTest.class);
30	addTestSuite(GroupedUpdatesTest.class);	30	addTestSuite(GroupedUpdatesTest.class);
31	addTestSuite(Bug304585Test.class);	31	addTestSuite(Bug304585Test.class);
		32	addTestSuite(ExtraDependenciesTest.class);
32	}	33	}
33	}	34	}

Return to bug 308650

Lines 347-375 Link Here

(-)src/org/eclipse/e4/core/internal/di/InjectorImpl.java (-22 / +3 lines)
347	return true;	347	return true;
348	}	348	}
349		349
350	public boolean update(IRequestor[] requestors, AbstractObjectSupplier objectSupplier) {	350	public boolean resolveArguments(IRequestor requestor, AbstractObjectSupplier objectSupplier) {
351	ArrayList<Requestor> list = new ArrayList<Requestor>(requestors.length);	351	ArrayList<Requestor> list = new ArrayList<Requestor>(1);
352	for (IRequestor requestor : requestors) {	352	list.add((Requestor)requestor);
353	list.add((Requestor) requestor);
354	}
355	resolveRequestorArgs(list, objectSupplier, true);	353	resolveRequestorArgs(list, objectSupplier, true);
356
357	// Call requestors in order
358	for (IRequestor requestor : requestors) {
359	try {
360	((Requestor) requestor).execute();
361	} catch (InvocationTargetException e) {
362	logError("Injection failed for the object \""
363	+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
364	+ requestor.toString() + "\"");
365	return false;
366	} catch (InstantiationException e) {
367	logError("Injection failed for the object \""
368	+ requestor.getRequestingObject().toString() + "\". Unable to execute \""
369	+ requestor.toString() + "\"");
370	return false;
371	}
372	}
373	return true;	354	return true;
374	}	355	}
375		356

Lines 85-91 Link Here

(-)src/org/eclipse/e4/core/internal/contexts/EclipseContext.java (-11 / +19 lines)
85	}	85	}
86	}	86	}
87		87
88	static class TrackableComputationExt extends Computation implements IRunAndTrack {	88	static class TrackableComputationExt extends Computation implements IRunAndTrack, IContextRecorder {
89		89
90	private ContextChangeEvent cachedEvent;	90	private ContextChangeEvent cachedEvent;
91		91
Lines 125-136 Link Here
125	this.runnable = runnable;	125	this.runnable = runnable;
126	}	126	}
127		127
128	public Object getObject() {
129	if (runnable instanceof IRunAndTrackObject)
130	return ((IRunAndTrackObject) runnable).getObject();
131	return null;
132	}
133
134	final protected void doHandleInvalid(ContextChangeEvent event, List<Scheduled> scheduledList) {	128	final protected void doHandleInvalid(ContextChangeEvent event, List<Scheduled> scheduledList) {
135	int eventType = event.getEventType();	129	int eventType = event.getEventType();
136	if (eventType == ContextChangeEvent.INITIAL \|\| eventType == ContextChangeEvent.DISPOSE) {	130	if (eventType == ContextChangeEvent.INITIAL \|\| eventType == ContextChangeEvent.DISPOSE) {
Lines 153-159 Link Here
153	cachedEvent = event;	147	cachedEvent = event;
154	EclipseContext eventsContext = (EclipseContext) event.getContext();	148	EclipseContext eventsContext = (EclipseContext) event.getContext();
155	eventsContext.addWaiting(this);	149	eventsContext.addWaiting(this);
156	// eventsContext.getRoot().waiting.add(this);
157	return true;	150	return true;
158	}	151	}
159	}	152	}
Lines 162-172 Link Here
162	boolean result = true;	155	boolean result = true;
163	try {	156	try {
164	if (cachedEvent != null) {	157	if (cachedEvent != null) {
165	result = runnable.notify(cachedEvent);	158	if (runnable instanceof IRunAndTrackObject)
		159	result = ((IRunAndTrackObject)runnable).notify(event, this);
		160	else
		161	result = runnable.notify(cachedEvent);
166	cachedEvent = null;	162	cachedEvent = null;
167	}	163	}
168	if (eventType != ContextChangeEvent.UPDATE)	164	if (eventType != ContextChangeEvent.UPDATE) {
169	result = runnable.notify(event);	165	if (runnable instanceof IRunAndTrackObject)
		166	result = ((IRunAndTrackObject)runnable).notify(event, this);
		167	else
		168	result = runnable.notify(event);
		169	}
170	} finally {	170	} finally {
171	currentComputation.set(oldComputation);	171	currentComputation.set(oldComputation);
172	}	172	}
Lines 181-186 Link Here
181	public String toString() {	181	public String toString() {
182	return "TrackableComputationExt(" + runnable + ')'; //$NON-NLS-1$	182	return "TrackableComputationExt(" + runnable + ')'; //$NON-NLS-1$
183	}	183	}
		184
		185	public void startAcessRecording() {
		186	currentComputation.set(this);
		187	}
		188
		189	public void stopAccessRecording() {
		190	currentComputation.set(null);
		191	}
184	}	192	}
185		193
186	static class Scheduled {	194	static class Scheduled {

Added Link Here

(-)src/org/eclipse/e4/core/internal/contexts/IContextRecorder.java (+20 lines)
1	/*******************************************************************************
2	* Copyright (c) 2010 IBM Corporation and others.
3	* All rights reserved. This program and the accompanying materials
4	* are made available under the terms of the Eclipse Public License v1.0
5	* which accompanies this distribution, and is available at
6	* http://www.eclipse.org/legal/epl-v10.html
7	*
8	* Contributors:
9	* IBM Corporation - initial API and implementation
10	*******************************************************************************/
11
12	package org.eclipse.e4.core.internal.contexts;
13
14
15	public interface IContextRecorder {
16
17	public void startAcessRecording();
18
19	public void stopAccessRecording();
20	}

Lines 42-53 Link Here

(-)src/org/eclipse/e4/core/di/IInjector.java (-2 / +1 lines)
42		42
43	public boolean injectStatic(Class<?> clazz, AbstractObjectSupplier objectSupplier);	43	public boolean injectStatic(Class<?> clazz, AbstractObjectSupplier objectSupplier);
44		44
45	public boolean update(IRequestor[] requestors, AbstractObjectSupplier objectSupplier);
46
47	public boolean disposed(AbstractObjectSupplier objectSupplier);	45	public boolean disposed(AbstractObjectSupplier objectSupplier);
48		46
49	public IBinding addBinding(Class<?> clazz);	47	public IBinding addBinding(Class<?> clazz);
50		48
51	public IBinding addBinding(IBinding binding);	49	public IBinding addBinding(IBinding binding);
52		50
		51	public boolean resolveArguments(IRequestor requestor, AbstractObjectSupplier objectSupplier);
53	}	52	}

Lines 10-15 Link Here

(-)src/org/eclipse/e4/core/di/internal/extensions/PreferencesObjectSupplier.java (-2 / +32 lines)
10	*******************************************************************************/	10	*******************************************************************************/
11	package org.eclipse.e4.core.di.internal.extensions;	11	package org.eclipse.e4.core.di.internal.extensions;
12		12
		13	import java.lang.reflect.InvocationTargetException;
13	import java.util.ArrayList;	14	import java.util.ArrayList;
14	import java.util.HashMap;	15	import java.util.HashMap;
15	import java.util.List;	16	import java.util.List;
Lines 23-28 Link Here
23	import org.eclipse.e4.core.di.IInjector;	24	import org.eclipse.e4.core.di.IInjector;
24	import org.eclipse.e4.core.di.IObjectDescriptor;	25	import org.eclipse.e4.core.di.IObjectDescriptor;
25	import org.eclipse.e4.core.di.IRequestor;	26	import org.eclipse.e4.core.di.IRequestor;
		27	import org.eclipse.e4.core.di.InjectionException;
26	import org.eclipse.e4.core.di.extensions.Preferences;	28	import org.eclipse.e4.core.di.extensions.Preferences;
27	import org.osgi.framework.FrameworkUtil;	29	import org.osgi.framework.FrameworkUtil;
28		30
Lines 98-106 Link Here
98	node.addPreferenceChangeListener(new IPreferenceChangeListener() {	100	node.addPreferenceChangeListener(new IPreferenceChangeListener() {
99	public void preferenceChange(PreferenceChangeEvent event) {	101	public void preferenceChange(PreferenceChangeEvent event) {
100	IInjector requestorInjector = requestor.getInjector();	102	IInjector requestorInjector = requestor.getInjector();
101	if (requestorInjector != null)	103	if (requestorInjector != null) {
102	requestorInjector.update(new IRequestor[] { requestor }, requestor	104	boolean resolved = requestorInjector.resolveArguments(requestor, requestor
103	.getPrimarySupplier());	105	.getPrimarySupplier());
		106	if (resolved) {
		107	try {
		108	requestor.execute();
		109	} catch (InvocationTargetException e) {
		110	logError("Injection failed for the object \""
		111	+ requestor.getRequestingObject().toString()
		112	+ "\". Unable to execute \"" + requestor.toString() + "\"");
		113	return;
		114	} catch (InstantiationException e) {
		115	logError("Injection failed for the object \""
		116	+ requestor.getRequestingObject().toString()
		117	+ "\". Unable to execute \"" + requestor.toString() + "\"");
		118	return;
		119	}
		120	}
		121	}
104	}	122	}
105	});	123	});
106	synchronized (listenerCache) {	124	synchronized (listenerCache) {
Lines 114-117 Link Here
114	}	132	}
115	}	133	}
116		134
		135	// TBD implement logging
		136	static protected void logError(String msg) {
		137	logError(msg, new InjectionException());
		138	}
		139
		140	static protected void logError(String msg, Throwable e) {
		141	if (msg != null)
		142	System.err.println(msg);
		143	if (e != null)
		144	e.printStackTrace();
		145	}
		146
117	}	147	}