diff -u -N -r ../../HG_FRESH/main/api.debugger/apichanges.xml api.debugger/apichanges.xml --- ../../HG_FRESH/main/api.debugger/apichanges.xml 2008-08-20 02:00:43.000000000 +0200 +++ api.debugger/apichanges.xml 2009-01-25 17:37:11.000000000 +0100 @@ -278,6 +278,41 @@ + + +

Lookup improvements and service annotation registration.

+ + + + + +

+ In order to be able to register debugger services on System FileSystem, + which brings more flexibility and better performance (see also + ), + we add non-recursive content of org.openide.util.Lookups.forPath() + into debugger lookup. + Since debugger needs retrieve context-aware services from the lookup, + ContextAwareService interface is introduced. +

+ Annotations are added for easy registration on module layers. + DebuggerServiceRegistration to register implementations + of interfaces, *Provider.Registration to register + implementations of appropriate providers. +

+ + + + + + + + + + + + diff -u -N -r ../../HG_FRESH/main/api.debugger/manifest.mf api.debugger/manifest.mf --- ../../HG_FRESH/main/api.debugger/manifest.mf 2008-11-18 20:59:37.000000000 +0100 +++ api.debugger/manifest.mf 2009-01-25 16:50:25.000000000 +0100 @@ -1,5 +1,4 @@ Manifest-Version: 1.0 OpenIDE-Module: org.netbeans.api.debugger/1 OpenIDE-Module-Localizing-Bundle: org/netbeans/api/debugger/Bundle.properties -OpenIDE-Module-Specification-Version: 1.15 - +OpenIDE-Module-Specification-Version: 1.16 diff -u -N -r ../../HG_FRESH/main/api.debugger/nbproject/project.properties api.debugger/nbproject/project.properties --- ../../HG_FRESH/main/api.debugger/nbproject/project.properties 2008-08-20 02:00:44.000000000 +0200 +++ api.debugger/nbproject/project.properties 2009-01-23 22:00:37.000000000 +0100 @@ -42,3 +42,4 @@ javac.source=1.5 javadoc.arch=${basedir}/arch.xml javadoc.apichanges=${basedir}/apichanges.xml +cp.extra=${nb_all}/apisupport.harness/external/openjdk-javac-6-b12.jar diff -u -N -r ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/LazyActionsManagerListener.java api.debugger/src/org/netbeans/api/debugger/LazyActionsManagerListener.java --- ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/LazyActionsManagerListener.java 2008-08-20 02:00:44.000000000 +0200 +++ api.debugger/src/org/netbeans/api/debugger/LazyActionsManagerListener.java 2009-01-25 16:56:12.000000000 +0100 @@ -41,15 +41,28 @@ package org.netbeans.api.debugger; +import java.lang.annotation.ElementType; +import java.lang.annotation.Retention; +import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; +import java.util.Map; + +import org.netbeans.debugger.registry.ContextAwareServiceHandler; +import org.netbeans.spi.debugger.ContextAwareSupport; +import org.netbeans.spi.debugger.ContextAwareService; +import org.netbeans.spi.debugger.ContextProvider; + /** * This {@link ActionsManagerListener} modification is designed to be - * registerred in "META-INF/debugger/". + * registerred in "META-INF/debugger/", or preferrably via the + * {@link Registration} annotation. * LazyActionsManagerListener should be registerred for some concrete - * {@link DebuggerEngine} (use - * "META-INF/debugger//LazyActionsManagerListener"), or - * for global {@link ActionsManager} (use - * "META-INF/debugger/LazyActionsManagerListener"). + * {@link DebuggerEngine} - use "" as a path of the + * annotation, or create + * "META-INF/debugger//LazyActionsManagerListener" file. + * For global {@link ActionsManager} (do not use the path parameter, or use + * "META-INF/debugger/LazyActionsManagerListener" file. * New instance of LazyActionsManagerListener implementation is loaded * when the new instance of {@link ActionsManager} is created, and its registerred * automatically to all properties returned by {@link #getProperties}. @@ -70,4 +83,59 @@ * @return list of properties this listener is listening on */ public abstract String[] getProperties (); + + /** + * Declarative registration of a LazyActionsManagerListener implementation. + * By marking the implementation class with this annotation, + * you automatically register that implementation for use by debugger. + * The class must be public and have a public constructor which takes + * no arguments or takes {@link ContextProvider} as an argument. + * @since 1.16 + */ + @Retention(RetentionPolicy.SOURCE) + @Target({ElementType.TYPE}) + public @interface Registration { + /** + * An optional path to register this implementation in. + * Usually the "". + */ + String path() default ""; + + } + + static class ContextAware extends LazyActionsManagerListener implements ContextAwareService { + + private String serviceName; + + private ContextAware(String serviceName) { + this.serviceName = serviceName; + } + + public LazyActionsManagerListener forContext(ContextProvider context) { + return (LazyActionsManagerListener) ContextAwareSupport.createInstance(serviceName, context); + } + + @Override + protected void destroy() { + throw new UnsupportedOperationException("Not supported."); + } + + @Override + public String[] getProperties() { + throw new UnsupportedOperationException("Not supported."); + } + + /** + * Creates instance of ContextAwareService based on layer.xml + * attribute values + * + * @param attrs attributes loaded from layer.xml + * @return new ContextAwareService instance + */ + static ContextAwareService createService(Map attrs) throws ClassNotFoundException { + String serviceName = (String) attrs.get(ContextAwareServiceHandler.SERVICE_NAME); + return new LazyActionsManagerListener.ContextAware(serviceName); + } + + } } diff -u -N -r ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/Lookup.java api.debugger/src/org/netbeans/api/debugger/Lookup.java --- ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/Lookup.java 2009-01-14 13:37:51.000000000 +0100 +++ api.debugger/src/org/netbeans/api/debugger/Lookup.java 2009-01-25 13:21:30.000000000 +0100 @@ -68,13 +68,19 @@ import java.util.logging.Level; import java.util.logging.Logger; +import org.netbeans.spi.debugger.ContextAwareService; +import org.netbeans.spi.debugger.ContextAwareSupport; import org.netbeans.spi.debugger.ContextProvider; import org.openide.modules.ModuleInfo; import org.openide.util.Exceptions; +import org.openide.util.Lookup.Item; import org.openide.util.LookupEvent; +import org.openide.util.LookupListener; import org.openide.util.RequestProcessor; import org.openide.util.WeakListeners; import org.openide.util.WeakSet; +import org.openide.util.lookup.Lookups; +import org.openide.util.Lookup.Result; /** @@ -147,7 +153,7 @@ if (l2 instanceof Compound) ((Compound) l2).setContext (context); if (l2 instanceof MetaInf) ((MetaInf) l2).setContext (context); } - + private class CompoundLookupList extends LookupList implements Customizer, PropertyChangeListener { @@ -227,6 +233,7 @@ MetaInf (String rootFolder) { + if (rootFolder != null && rootFolder.length() == 0) rootFolder = null; this.rootFolder = rootFolder; moduleLookupResult = org.openide.util.Lookup.getDefault().lookupResult(ModuleInfo.class); //System.err.println("\nModules = "+moduleLookupResult.allInstances().size()+"\n"); @@ -251,9 +258,11 @@ private List list(String folder, Class service) { String name = service.getName (); - String resourceName = "META-INF/debugger/" + - ((rootFolder == null) ? "" : rootFolder + "/") + - ((folder == null) ? "" : folder + "/") + + String pathResourceName = "debugger/" + + ((rootFolder == null) ? "" : rootFolder + "/") + + ((folder == null) ? "" : folder + "/"); + String resourceName = "META-INF/" + + pathResourceName + name; synchronized(registrationCache) { List l = registrationCache.get(resourceName); @@ -265,6 +274,17 @@ } } + private org.openide.util.Lookup lookupForPath(String folder) { + String pathResourceName = "Debugger/" + + ((rootFolder == null) ? "" : rootFolder + "/") + + ((folder == null) ? "" : folder + "/"); + return new PathLookup(pathResourceName); + } + + private Result listLookup(String folder, Class service) { + return lookupForPath(folder).lookupResult(service); + } + private static Set getHiddenClassNames(List l) { Set s = null; int i, k = l.size (); @@ -319,97 +339,6 @@ throw new InternalError ("Can not read from Meta-inf!"); } - private Object createInstance (String service) { - try { - ClassLoader cl = org.openide.util.Lookup.getDefault().lookup(ClassLoader.class); - String method = null; - if (service.endsWith("()")) { - int lastdot = service.lastIndexOf('.'); - if (lastdot < 0) { - Exceptions.printStackTrace( - new IllegalStateException("Bad service - dot before method name is missing: " + - "'" + service + "'.")); - return null; - } - method = service.substring(lastdot + 1, service.length() - 2).trim(); - service = service.substring(0, lastdot); - } - Class cls = cl.loadClass (service); - - Object o = null; - if (method != null) { - Method m = null; - if (context != null) { - try { - m = cls.getDeclaredMethod(method, new Class[] { Lookup.class }); - } catch (NoSuchMethodException nsmex) {} - } - if (m == null) { - try { - m = cls.getDeclaredMethod(method, new Class[] { }); - } catch (NoSuchMethodException nsmex) {} - } - if (m != null) { - o = m.invoke(null, (m.getParameterTypes().length == 0) - ? new Object[] {} : new Object[] { context }); - } - } - if (o == null && context != null) { - Constructor[] cs = cls.getConstructors (); - int i, k = cs.length; - for (i = 0; i < k; i++) { - Constructor c = cs [i]; - if (c.getParameterTypes ().length != 1) continue; - try { - o = c.newInstance (new Object[] {context}); - } catch (IllegalAccessException e) { - if (verbose) { - System.out.println("\nservice: " + service); - e.printStackTrace (); - } - } catch (IllegalArgumentException e) { - if (verbose) { - System.out.println("\nservice: " + service); - e.printStackTrace (); - } - } - } - } - if (o == null) - o = cls.newInstance (); - if (verbose) - System.out.println("\nR instance " + o + - " created"); - return o; - } catch (ClassNotFoundException e) { - Exceptions.printStackTrace( - Exceptions.attachMessage( - e, - "The service "+service+" not found.")); - } catch (InstantiationException e) { - Exceptions.printStackTrace( - Exceptions.attachMessage( - e, - "The service "+service+" can not be instantiated.")); - } catch (IllegalAccessException e) { - Exceptions.printStackTrace( - Exceptions.attachMessage( - e, - "The service "+service+" can not be accessed.")); - } catch (InvocationTargetException ex) { - Exceptions.printStackTrace( - Exceptions.attachMessage( - ex, - "The service "+service+" can not be created.")); - } catch (ExceptionInInitializerError ex) { - Exceptions.printStackTrace( - Exceptions.attachMessage( - ex, - "The service "+service+" can not be initialized.")); - } - return null; - } - private void listenOn(ClassLoader cl) { synchronized(moduleChangeListeners) { if (!moduleChangeListeners.containsKey(cl)) { @@ -447,7 +376,7 @@ } pcs.firePropertyChange("PROP_CACHE", null, null); // NOI18N } - + private final class ModuleChangeListener implements PropertyChangeListener, org.openide.util.LookupListener { private ClassLoader cl; @@ -580,40 +509,75 @@ public int notifyUnloadOrder = 0; public MetaInfLookupList(String folder, Class service) { - this(list(folder, service), service); + this(list(folder, service), listLookup(folder, service), service); this.folder = folder; } - private MetaInfLookupList(List l, Class service) { - this(l, getHiddenClassNames(l), service); + private MetaInfLookupList(List l, Result lr, Class service) { + this(l, lr, getHiddenClassNames(l), service); } - private MetaInfLookupList(List l, Set s, Class service) { + private MetaInfLookupList(List l, Result lr, Set s, Class service) { super(s); assert service != null; this.service = service; - fillInstances(l, s); + fillInstances(l, lr, s); listenOnDisabledModules(); } - private void fillInstances(List l, Set s) { + private void fillInstances(List l, Result lr, Set s) { for (String className : l) { if (className.endsWith(HIDDEN)) continue; if (s != null && s.contains (className)) continue; - Object instance = null; - synchronized(instanceCache) { - instance = instanceCache.get (className); - } - if (instance != null) { - try { - add(service.cast(instance), className); - } catch (ClassCastException cce) { - Logger.getLogger(Lookup.class.getName()).log(Level.WARNING, null, cce); - } - listenOn(instance.getClass().getClassLoader()); - } else if (checkClassName(className)) { - add(new LazyInstance(service, className), className); - } + fillClassInstance(className); + } + for (Item li : lr.allItems()) { + // TODO: We likely do not have the Item.getId() defined correctly. + // We have to check the ContextAwareService.serviceID() + String serviceName = getServiceName(li.getId()); + if (s != null && s.contains (serviceName)) continue; + add(new LazyInstance(service, li)); + } + /* + for (Object lri : lr.allInstances()) { + if (lri instanceof ContextAwareService) { + String className = ((ContextAwareService) lri).serviceName(); + if (s != null && s.contains (className)) continue; + fillClassInstance(className); + } + } + */ + } + + private String getServiceName(String itemId) { + int i = itemId.lastIndexOf('/'); + if (i < 0) i = 0; + else i++; // Skip '/' + String serviceName = itemId.substring(i); + serviceName = serviceName.replace('-', '.'); + try { + org.openide.util.Lookup.getDefault().lookup(ClassLoader.class).loadClass(serviceName); + } catch (ClassNotFoundException ex) { + // Not a class, likely a method call + serviceName = serviceName + "()"; + } + return serviceName; + } + + private void fillClassInstance(String className) { + Object instance = null; + synchronized(instanceCache) { + instance = instanceCache.get (className); + } + if (instance != null) { + try { + add(service.cast(instance), className); + } catch (ClassCastException cce) { + Logger.getLogger(Lookup.class.getName()).log(Level.WARNING, null, cce); + } + listenOn(instance.getClass().getClassLoader()); + } else if (checkClassName(className)) { + add(new LazyInstance(service, className), className); } } @@ -645,9 +609,10 @@ // can sync on it clear(); List l = list(folder, service); + Result lr = listLookup(folder, service); Set s = getHiddenClassNames(l); hiddenClassNames = s; - fillInstances(l, s); + fillInstances(l, lr, s); firePropertyChange(); } @@ -704,25 +669,43 @@ } private class LazyInstance extends LookupLazyEntry { + private String className; private Class service; + Item lookupItem; + public LazyInstance(Class service, String className) { this.service = service; this.className = className; } + public LazyInstance(Class service, Item lookupItem) { + this.service = service; + this.lookupItem = lookupItem; + } + private final Object instanceCreationLock = new Object(); protected T getEntry() { Object instance = null; - synchronized (instanceCreationLock) { - synchronized(instanceCache) { - instance = instanceCache.get (className); - } - if (instance == null) { - instance = createInstance (className); - synchronized (instanceCache) { - instanceCache.put (className, instance); + if (lookupItem != null) { + instance = lookupItem.getInstance(); + if (instance instanceof ContextAwareService) { + ContextAwareService cas = (ContextAwareService) instance; + instance = cas.forContext(Lookup.MetaInf.this.context); + lookupItem = null; + } + } + if (instance == null) { + synchronized (instanceCreationLock) { + synchronized(instanceCache) { + instance = instanceCache.get (className); + } + if (instance == null) { + instance = ContextAwareSupport.createInstance (className, Lookup.MetaInf.this.context); + synchronized (instanceCache) { + instanceCache.put (className, instance); + } } } } @@ -841,5 +824,5 @@ } } - + } diff -u -N -r ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/PathLookup.java api.debugger/src/org/netbeans/api/debugger/PathLookup.java --- ../../HG_FRESH/main/api.debugger/src/org/netbeans/api/debugger/PathLookup.java 1970-01-01 01:00:00.000000000 +0100 +++ api.debugger/src/org/netbeans/api/debugger/PathLookup.java 2009-01-25 12:57:08.000000000 +0100 @@ -0,0 +1,277 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2009 Sun Microsystems, Inc. + */ + +package org.netbeans.api.debugger; + +import java.util.Collection; +import java.util.Iterator; +import java.util.NoSuchElementException; +import java.util.Set; + +import org.openide.util.Lookup.Item; +import org.openide.util.Lookup.Result; +import org.openide.util.LookupListener; +import org.openide.util.lookup.Lookups; + +/** + * + * @author Martin Entlicher + */ +class PathLookup extends org.openide.util.Lookup { + + private org.openide.util.Lookup delegate; + private String path; + + PathLookup(String path) { + this.delegate = Lookups.forPath(path); + this.path = path; + } + + @Override + public T lookup(Class clazz) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Result lookup(Template template) { + return resultJustForPath(delegate.lookup(template)); + } + + @Override + public Collection lookupAll(Class clazz) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Item lookupItem(Template template) { + throw new UnsupportedOperationException("Not supported yet."); + } + + @Override + public Result lookupResult(Class clazz) { + return resultJustForPath(delegate.lookupResult(clazz)); + } + + private Result resultJustForPath(Result result) { + int l = path.length() + 1; + int count = 0; + Collection> allItems = result.allItems(); + for (Item it : allItems) { + String filePath = it.getId(); + assert filePath.startsWith(path) : "File path '"+filePath+"' does not start with searched path '"+path+"'"; + if (filePath.indexOf('/', l) > 0) { + // This and further items are from a different folder + // We have to return a restricted result + break; + } + count++; + } + if (count < allItems.size()) { + return new PathLookupResult(result, count); + } + return result; + } + + static class PathLookupResult extends Result { + + private Result orig; + private int n; + + PathLookupResult(Result orig, int n) { + this.orig = orig; + this.n = n; + } + + @Override + public void addLookupListener(LookupListener l) { + orig.addLookupListener(l); + } + + @Override + public void removeLookupListener(LookupListener l) { + orig.removeLookupListener(l); + } + + @Override + public Collection allInstances() { + return new PathLookupCollection(orig.allInstances(), n); + } + + @Override + public Set> allClasses() { + return new PathLookupSet(orig.allClasses(), n); + } + + @Override + public Collection> allItems() { + return new PathLookupCollection(orig.allItems(), n); + } + + private static class PathLookupCollection implements Collection { + + private Collection delegate; + private int n; + + PathLookupCollection(Collection delegate, int n) { + this.delegate = delegate; + this.n = n; + } + + public int size() { + return n; + } + + public boolean isEmpty() { + return n == 0; + } + + public boolean contains(Object o) { + Iterator it = iterator(); + for (int i = 0; i < n; i++) { + Object e = it.next(); + if (o == e || o != null && o.equals(e)) { + return true; + } + } + return false; + } + + public Iterator iterator() { + return new PathLookupIterator(delegate.iterator(), n); + } + + public Object[] toArray() { + Object[] arr = new Object[n]; + Iterator it = iterator(); + for (int i = 0; i < n; i++) { + arr[i] = it.next(); + } + return arr; + } + + public T[] toArray(T[] a) { + if (a.length < n) { + a = (T[]) java.lang.reflect.Array. + newInstance(a.getClass().getComponentType(), n); + } + System.arraycopy(toArray(), 0, a, 0, n); + if (a.length > n) { + a[n] = null; + } + return a; + } + + public boolean add(IT o) { + throw new UnsupportedOperationException("Not supported."); + } + + public boolean remove(Object o) { + throw new UnsupportedOperationException("Not supported."); + } + + public boolean containsAll(Collection c) { + for (Iterator it = c.iterator(); it.hasNext(); ) { + if (!contains(it.next())) { + return false; + } + } + return true; + } + + public boolean addAll(Collection c) { + throw new UnsupportedOperationException("Not supported."); + } + + public boolean removeAll(Collection c) { + throw new UnsupportedOperationException("Not supported."); + } + + public boolean retainAll(Collection c) { + throw new UnsupportedOperationException("Not supported."); + } + + public void clear() { + delegate.clear(); + } + + } + + private static class PathLookupSet extends PathLookupCollection implements Set { + + PathLookupSet(Set delegate, int n) { + super(delegate, n); + } + + } + + + private static class PathLookupIterator implements Iterator { + + private int i; + private Iterator delegate; + private int n; + + PathLookupIterator (Iterator delegate, int n) { + this.delegate = delegate; + this.n = n; + this.i = 0; + } + + public boolean hasNext() { + return i < n; + } + + public IIT next() { + if (i < n) { + i++; + return delegate.next(); + } else { + throw new NoSuchElementException("Index = "+i+", size = "+n); + } + } + + public void remove() { + throw new UnsupportedOperationException("Not supported."); + } + + } + + } + +} diff -u -N -r ../../HG_FRESH/main/api.debugger/src/org/netbeans/debugger/registry/ContextAwareServiceHandler.java api.debugger/src/org/netbeans/debugger/registry/ContextAwareServiceHandler.java --- ../../HG_FRESH/main/api.debugger/src/org/netbeans/debugger/registry/ContextAwareServiceHandler.java 1970-01-01 01:00:00.000000000 +0100 +++ api.debugger/src/org/netbeans/debugger/registry/ContextAwareServiceHandler.java 2009-01-23 21:40:20.000000000 +0100 @@ -0,0 +1,162 @@ +/* + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER. + * + * Copyright 2009 Sun Microsystems, Inc. All rights reserved. + * + * The contents of this file are subject to the terms of either the GNU + * General Public License Version 2 only ("GPL") or the Common + * Development and Distribution License("CDDL") (collectively, the + * "License"). You may not use this file except in compliance with the + * License. You can obtain a copy of the License at + * http://www.netbeans.org/cddl-gplv2.html + * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the + * specific language governing permissions and limitations under the + * License. When distributing the software, include this License Header + * Notice in each file and include the License file at + * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this + * particular file as subject to the "Classpath" exception as provided + * by Sun in the GPL Version 2 section of the License file that + * accompanied this code. If applicable, add the following below the + * License Header, with the fields enclosed by brackets [] replaced by + * your own identifying information: + * "Portions Copyrighted [year] [name of copyright owner]" + * + * If you wish your version of this file to be governed by only the CDDL + * or only the GPL Version 2, indicate your decision by adding + * "[Contributor] elects to include this software in this distribution + * under the [CDDL or GPL Version 2] license." If you do not indicate a + * single choice of license, a recipient has the option to distribute + * your version of this file under either the CDDL, the GPL Version 2 or + * to extend the choice of license to its licensees as provided above. + * However, if you add GPL Version 2 code and therefore, elected the GPL + * Version 2 license, then the option applies only if the new code is + * made subject to such option by the copyright holder. + * + * Contributor(s): + * + * Portions Copyrighted 2009 Sun Microsystems, Inc. + */ + +package org.netbeans.debugger.registry; + +import org.netbeans.spi.debugger.ContextAwareSupport; +import org.netbeans.spi.debugger.ContextAwareService; +import java.lang.ref.WeakReference; +import java.lang.reflect.InvocationHandler; +import java.lang.reflect.Method; +import java.lang.reflect.Proxy; +import java.util.ArrayList; +import java.util.Collections; +import java.util.Map; +import java.util.WeakHashMap; +import org.netbeans.spi.debugger.ContextProvider; +import org.netbeans.spi.debugger.DebuggerServiceRegistration; +import org.openide.util.Lookup; + +/** + * Handler of context aware services that implement one or more interface. + * The services are registered through {@link DebuggerServiceRegistration} annotation. + * + * This handler guarantees that it creates only one service for given context and given set of interfaces. + * Method {@link ContextAwareService#forContext(org.netbeans.spi.debugger.ContextProvider)} + * returns the instance of the actual registered class. However, if necessary, + * this can be changed to return another proxy implementation, that will delegate + * to an instance of the actual registered class. This will allow to mask some + * methods with attributes and also can prevent from too early class loading. + * + * @author Martin Entlicher + */ +public class ContextAwareServiceHandler implements InvocationHandler { + + public static final String SERVICE_NAME = "serviceName"; // NOI18N + public static final String SERVICE_CLASSES = "serviceClasses"; // NOI18N + + private String serviceName; + private Class[] serviceClasses; + private Map methodValues; + //private ContextProvider context; + private Object delegate; + + private Map contextInstances = new WeakHashMap(); + private WeakReference