Modified: felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceCallbacksBuilderImpl.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceCallbacksBuilderImpl.java?rev=1724333&r1=1724332&r2=1724333&view=diff ============================================================================== --- felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceCallbacksBuilderImpl.java (original) +++ felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceCallbacksBuilderImpl.java Tue Jan 12 22:45:36 2016 @@ -7,35 +7,48 @@ import java.util.Map; import java.util.stream.Stream; import org.apache.felix.dm.Component; -import org.apache.felix.dm.builder.lambda.BundleDependencyBuilder; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder; -import org.apache.felix.dm.builder.lambda.ServiceDependencyBuilder; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.DictServiceDictService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceDictServiceDictService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceMapServiceMapService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceRef; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceRefServiceRefService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceServiceDict; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceServiceMap; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.InstanceServiceRef; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.MapServiceMapService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.Ref; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.RefServiceRefService; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.Service; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.ServiceDict; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.ServiceMap; -import org.apache.felix.dm.builder.lambda.ServiceCallbacksBuilder.ServiceRef; +import org.apache.felix.dm.builder.lambda.CB; +import org.apache.felix.dm.builder.lambda.Functions.CbComponent; +import org.apache.felix.dm.builder.lambda.Functions.CbComponentRef; +import org.apache.felix.dm.builder.lambda.Functions.CbComponentRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbComponentService; +import org.apache.felix.dm.builder.lambda.Functions.CbComponentServiceDict; +import org.apache.felix.dm.builder.lambda.Functions.CbComponentServiceMap; +import org.apache.felix.dm.builder.lambda.Functions.CbDictServiceDictService; +import org.apache.felix.dm.builder.lambda.Functions.CbMapServiceMapService; +import org.apache.felix.dm.builder.lambda.Functions.CbRef; +import org.apache.felix.dm.builder.lambda.Functions.CbRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbRefServiceRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbService; +import org.apache.felix.dm.builder.lambda.Functions.CbServiceDict; +import org.apache.felix.dm.builder.lambda.Functions.CbServiceMap; +import org.apache.felix.dm.builder.lambda.Functions.CbServiceService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponent; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponentRef; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponentRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponentService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponentServiceDict; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeComponentServiceMap; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeDictServiceDictService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeMapServiceMapService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeRef; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeRefServiceRefService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeService; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeServiceDict; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeServiceMap; +import org.apache.felix.dm.builder.lambda.Functions.CbTypeServiceService; import org.osgi.framework.ServiceReference; /** * Dependency Callbacks management. * - * @param <T> the type of the service dependency + * @param <S> the type of the service dependency + * @param <T> the type of the implementation class on which the dependency can be applied (using method references). * @param <B> the type of the sub-classes which may extend this class */ @SuppressWarnings({"unchecked", "unused"}) -public abstract class ServiceCallbacksBuilderImpl<T, B extends ServiceCallbacksBuilderImpl<T, B>> +public abstract class ServiceCallbacksBuilderImpl<S, B extends ServiceCallbacksBuilderImpl<S, B>> { protected boolean m_autoConfig = true; protected boolean m_autoConfigInvoked = false; @@ -45,23 +58,19 @@ public abstract class ServiceCallbacksBu protected String m_changed; protected String m_removed; protected String m_swapped; + protected final Class<S> m_serviceClass; /** * List of service (add/change/remove) callbacks. */ - private final Map<String, List<MethodRef<Object, T>>> m_refs = new HashMap<>(); - + protected final Map<String, List<MethodRef<Object, S>>> m_refs = new HashMap<>(); + /** * List of swap callbacks */ - private final List<SwapMethodRef<?, T>> m_swapRefs = new ArrayList<>(); + protected final List<SwapMethodRef<?, S>> m_swapRefs = new ArrayList<>(); /** - * Tells if there is some component instance method reference callbacks. - */ - private boolean m_hasComponentInstanceRefs; - - /** * This interface (lambda) is called when we want to invoke a method reference. the lambda is called with all necessary service dependency * informations. * @@ -71,8 +80,8 @@ public abstract class ServiceCallbacksBu * @param <T> service dependency type */ @FunctionalInterface - interface MethodRef<I, T> { - public void accept(I instance, Component c, ServiceReference<T> ref, T service); + interface MethodRef<I, S> { + public void accept(I instance, Component c, ServiceReference<S> ref, S service); } /** @@ -83,10 +92,14 @@ public abstract class ServiceCallbacksBu * @param <T> service dependency type */ @FunctionalInterface - interface SwapMethodRef<I, T> { - public void accept(I instance, Component c, ServiceReference<T> oldRef, T oldService, ServiceReference<T> newRef, T newService); + interface SwapMethodRef<I, S> { + public void accept(I instance, Component c, ServiceReference<S> oldRef, S oldService, ServiceReference<S> newRef, S newService); } - + + public ServiceCallbacksBuilderImpl(Class<S> serviceClass) { + m_serviceClass = serviceClass; + } + public B autoConfig() { autoConfig(true); return (B) this; @@ -94,6 +107,7 @@ public abstract class ServiceCallbacksBu public B autoConfig(String field) { m_autoConfigField = field; + m_autoConfigInvoked = true; return (B) this; } @@ -103,338 +117,293 @@ public abstract class ServiceCallbacksBu return (B) this; } - public B callbackInstance(Object instance) { - requiresNoMethodRefs(); - m_callbackInstance = instance; + public B cbInst(Object callbackInstance) { + m_callbackInstance = callbackInstance; return (B) this; } - - public B callbacks(String added, String removed) { - return callbacks(added, null, removed); - } - public B callbacks(String added, String changed, String removed) { - return callbacks(added, changed, removed, null); - } + public B cb(String add) { + return cb(add, null, null, null); + } + + public B cb(String add, String remove) { + return cb(add, null, remove, null); + } + + public B cb(String add, String change, String remove) { + return cb(add, change, remove, null); + } - public B callbacks(String added, String changed, String removed, String swapped) { + public B cb(String added, String changed, String removed, String swapped) { requiresNoMethodRefs(); m_added = added != null ? added : m_added; m_changed = changed != null ? changed : m_changed; m_removed = removed != null ? removed : m_removed; m_swapped = swapped != null ? swapped : m_swapped; - if (! m_autoConfigInvoked) m_autoConfig = false; + if (! m_autoConfigInvoked) m_autoConfig = false; return (B) this; } - public B onAdd(String added) { - callbacks(added, null, null, null); - return (B) this; + public <T> B cb(CB cbType, CbTypeService<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, service)); } - - public B onChange(String changed) { - callbacks(null, changed, null, null); - return (B) this; + + public <T> B cb(CB cbType, CbTypeServiceMap<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, service, new SRefAsMap(ref))); } - public B onRemove(String removed) { - callbacks(null, null, removed, null); - return (B) this; + public <T> B cb(CB cbType, CbTypeServiceDict<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, service, new SRefAsDictionary(ref))); } - - public B onSwap(String swapped) { - callbacks(null, null, null, swapped); - return (B) this; + + public <T> B cb(CB cbType, CbTypeRef<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, ref)); } - public <I> B onAdd(InstanceService<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("add", type, - (instance, component, ref, service) -> callback.call((I) instance, service)); + public <T> B cb(CB cbType, CbTypeRefService<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, ref, service)); } - public B onAdd(Service<T> callback) { - return setCallbackRef("add", (instance, component, sref, service) -> callback.call(service)); - } - - public <I> B onAdd(InstanceServiceMap<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("add", type, - (instance, component, ref, service) -> callback.call((I) instance, service, new SRefAsMap(ref))); + public <T> B cb(CB cbType, CbTypeComponent<T> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component)); } - - public B onAdd(ServiceMap<T> callback) { - return setCallbackRef("add", - (instance, component, ref, service) -> callback.call(service, new SRefAsMap(ref))); - } - - public <I> B onAdd(InstanceServiceDict<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("add", type, - (inst, component, ref, service) -> callback.call((I) inst, service, new SRefAsDictionary(ref))); - } - - public B onAdd(ServiceDict<T> callback) { - return setCallbackRef("add", - (instance, component, ref, service) -> callback.call(service, new SRefAsDictionary(ref))); - } - - public <I> B onAdd(InstanceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("add", type, - (instance, component, ref, service) -> callback.call((I) instance, ref)); - } - - public B onAdd(Ref<T> callback) { - return setCallbackRef("add", - (instance, component, ref, service) -> callback.call(ref)); - } - - public <I> B onAdd(InstanceServiceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("add", type, - (instance, component, ref, service) -> callback.call((I) instance, service, ref)); - } - - public B onAdd(ServiceRef<T> callback) { - return setCallbackRef("add", - (instance, component, ref, service) -> callback.call(service, ref)); - } - public <I> B onChange(InstanceService<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("change", type, - (instance, component, ref, service) -> callback.call((I) instance, service)); + public <T> B cb(CB cbType, CbTypeComponentService<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component, service)); } - public B onChange(Service<T> callback) { - return setCallbackRef("change", - (instance, component, ref, service) -> callback.call(service)); + public <T> B cb(CB cbType, CbTypeComponentServiceMap<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component, service, new SRefAsMap(ref))); } - public <I> B onChange(InstanceServiceMap<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("change", type, - (instance, component, ref, service) -> callback.call((I) instance, service, new SRefAsMap(ref))); + public <T> B cb(CB cbType, CbTypeComponentServiceDict<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component, service, new SRefAsDictionary(ref))); } - public B onChange(ServiceMap<T> callback) { - return setCallbackRef("change", - (instance, component, ref, service) -> callback.call(service, new SRefAsMap(ref))); + public <T> B cb(CB cbType, CbTypeComponentRef<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component, ref)); } - public <I> B onChange(InstanceServiceDict<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("change", type, - (instance, component, ref, service) -> callback.call((I) instance, service, new SRefAsDictionary(ref))); + public <T> B cb(CB cbType, CbTypeComponentRefService<T, S> callback) { + return setComponentCallbackRef(getCallback(cbType), Helpers.getLambdaGenericType(callback, 0), + (instance, component, ref, service) -> callback.accept((T) instance, component, ref, service)); } - - public B onChange(ServiceDict<T> callback) { - return setCallbackRef("change", - (instance, component, ref, service) -> callback.call(service, new SRefAsDictionary(ref))); + + public B cbi(CB cbType, CbService<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(service)); } - public <I> B onChange(InstanceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("change", type, - (instance, component, ref, service) -> callback.call((I) instance, ref)); + public B cbi(CB cbType, CbServiceMap<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(service, new SRefAsMap(ref))); } - public B onChange(Ref<T> callback) { - return setCallbackRef("change", - (instance, component, ref, service) -> callback.call(ref)); + public B cbi(CB cbType, CbServiceDict<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(service, new SRefAsDictionary(ref))); } - public <I> B onChange(InstanceServiceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("change", type, - (instance, component, ref, service) -> callback.call((I) instance, service, ref)); - } - - public B onChange(ServiceRef<T> callback) { - return setCallbackRef("change", - (instance, component, ref, service) -> callback.call(service, ref)); - } - - public <I> B onRemove(InstanceService<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("remove", type, - (instance, component, ref, service) -> callback.call((I) instance, service)); + public B cbi(CB cbType, CbRef<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(ref)); } - public B onRemove(Service<T> callback) { - return setCallbackRef("remove", - (instance, component, ref, service) -> callback.call(service)); + public B cbi(CB cbType, CbRefService<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(ref, service)); } - public <I> B onRemove(InstanceServiceMap<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("remove", type, - (instance, component, ref, service) -> callback.call((I) instance, service, new SRefAsMap(ref))); + public B cbi(CB cbType, CbComponent callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component)); } - public B onRemove(ServiceMap<T> callback) { - return setCallbackRef("remove", - (instance, component, ref, service) -> callback.call(service, new SRefAsMap(ref))); + public B cbi(CB cbType, CbComponentService<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component, service)); } - public <I> B onRemove(InstanceServiceDict<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("remove", type, - (instance, component, ref, service) -> callback.call((I) instance, service, new SRefAsDictionary(ref))); + public B cbi(CB cbType, CbComponentServiceMap<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component, service, new SRefAsMap(ref))); } - public B onRemove(ServiceDict<T> callback) { - return setCallbackRef("remove", - (instance, component, ref, service) -> callback.call(service, new SRefAsDictionary(ref))); + public B cbi(CB cbType, CbComponentServiceDict<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component, service, new SRefAsDictionary(ref))); } - public <I> B onRemove(InstanceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("remove", type, - (instance, component, ref, service) -> callback.call((I) instance, ref)); + public B cbi(CB cbType, CbComponentRef<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component, ref)); } - public B onRemove(Ref<T> callback) { - return setCallbackRef("remove", - (instance, component, ref, service) -> callback.call(ref)); + public B cbi(CB cbType, CbComponentRefService<S> callback) { + return setInstanceCallbackRef(getCallback(cbType), + (instance, component, ref, service) -> callback.accept(component, ref, service)); } - public <I> B onRemove(InstanceServiceRef<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceCallbackRef("remove", type, - (instance, component, ref, service) -> callback.call((I) instance, service, ref)); - } + public <T> B sw(CbTypeServiceService<T, S> swap) { + Class<T> type = Helpers.getLambdaGenericType(swap, 0); + return setComponentSwapCallbackRef(type, (inst, component, oref, oserv, nref, nserv) -> + swap.accept((T) inst, oserv, nserv)); + } - public B onRemove(ServiceRef<T> callback) { - return setCallbackRef("remove", - (instance, component, ref, service) -> callback.call(service, ref)); - } + public <T> B sw(CbTypeRefServiceRefService<T, S> swap) { + Class<T> type = Helpers.getLambdaGenericType(swap, 0); + return setComponentSwapCallbackRef(type, (inst, component, oref, oserv, nref, nserv) -> + swap.accept((T) inst, oref, oserv, nref, nserv)); + } - public <I> B onSwap(InstanceRefServiceRefService<I, T> callback) { - String type = Helpers.getLambdaGenericType(callback); - return setComponentInstanceSwapCallbackRef(type, - (inst, component, oref, oserv, nref, nserv) -> callback.call((I) inst, oref, oserv, nref, nserv)); + public <T> B sw(CbTypeMapServiceMapService<T, S> swap) { + Class<T> type = Helpers.getLambdaGenericType(swap, 0); + return setComponentSwapCallbackRef(type, (inst, component, oref, oserv, nref, nserv) -> + swap.accept((T) inst, new SRefAsMap(oref), oserv, new SRefAsMap(nref), nserv)); } - - public B onSwap(RefServiceRefService<T> callback) { - m_swapRefs.add((inst, component, oref, oserv, nref, nserv) -> callback.call(oref, oserv, nref, nserv)); - return (B) this; + + public <T> B sw(CbTypeDictServiceDictService<T, S> swap) { + Class<T> type = Helpers.getLambdaGenericType(swap, 0); + return setComponentSwapCallbackRef(type, (inst, component, oref, oserv, nref, nserv) -> + swap.accept((T) inst, new SRefAsDictionary(oref), oserv, new SRefAsDictionary(nref), nserv)); + } + + public B swi(CbServiceService<S> swap) { + return setInstanceSwapCallbackRef((inst, component, oref, oserv, nref, nserv) -> swap.accept(oserv, nserv)); } - public <I> B onSwap(InstanceMapServiceMapService<I, T> callback) { - String instanceType = Helpers.getLambdaGenericType(callback); - return setComponentInstanceSwapCallbackRef(instanceType, (inst, component, oref, oserv, nref, nserv) -> - callback.call((I) inst, new SRefAsMap(oref), oserv, new SRefAsMap(nref), nserv)); + public B swi(CbRefServiceRefService<S> swap) { + return setInstanceSwapCallbackRef((inst, component, oref, oserv, nref, nserv) -> swap.accept(oref, oserv, nref, nserv)); } + + public B swi(CbMapServiceMapService<S> swap) { + return setInstanceSwapCallbackRef((inst, component, oref, oserv, nref, nserv) -> + swap.accept(new SRefAsMap(oref), oserv, new SRefAsMap(nref), nserv)); + } + + public B swi(CbDictServiceDictService<S> swap) { + return setInstanceSwapCallbackRef((inst, component, oref, oserv, nref, nserv) -> + swap.accept(new SRefAsDictionary(oref), oserv, new SRefAsDictionary(nref), nserv)); + } + + protected <I> B setComponentCallbackRef(String cb, Class<I> type, MethodRef<I, S> ref) { + requiresNoCallbacks(); + if (! m_autoConfigInvoked) m_autoConfig = false; + List<MethodRef<Object, S>> list = m_refs.computeIfAbsent(cb, l -> new ArrayList<>()); + list.add((instance, component, sref, service) -> { + Stream.of(component.getInstances()).forEach(inst -> { + if (Helpers.getClass(inst).equals(type)) { + ref.accept((I) inst, component, sref, service); + } + }); + }); + return (B) this; + } + + protected <T> B setInstanceCallbackRef(String cb, MethodRef<T, S> ref) { + requiresNoCallbacks(); + if (! m_autoConfigInvoked) m_autoConfig = false; + List<MethodRef<Object, S>> list = m_refs.computeIfAbsent(cb, l -> new ArrayList<>()); + list.add((instance, component, sref, service) -> { + ref.accept((T) component.getInstance(), component, sref, service); + }); + return (B) this; + } - public B onSwap(MapServiceMapService<T> callback) { - m_swapRefs.add((inst, component, oref, oserv, nref, nserv) -> - callback.call(new SRefAsMap(oref), oserv, new SRefAsMap(nref), nserv)); - return (B) this; - } - - public <I> B onSwap(InstanceDictServiceDictService<I, T> callback) { - String instanceType = Helpers.getLambdaGenericType(callback); - return setComponentInstanceSwapCallbackRef(instanceType, (inst, component, oref, oserv, nref, nserv) -> - callback.call((I) inst, new SRefAsDictionary(oref), oserv, new SRefAsDictionary(nref), nserv)); - } - - public B onSwap(DictServiceDictService<T> callback) { - m_swapRefs.add((inst, component, oref, oserv, nref, nserv) -> - callback.call(new SRefAsDictionary(oref), oserv, new SRefAsDictionary(nref), nserv)); - return (B) this; - } - - public <I> B setCallbackRef(String cb, MethodRef<I, T> ref) { - List<MethodRef<Object, T>> list = m_refs.computeIfAbsent(cb, l -> new ArrayList<>()); - list.add((instance, component, sref, service) -> ref.accept(null, component, sref, service)); - return (B) this; - } - - public <I> B setComponentInstanceCallbackRef(String cb, String type, MethodRef<I, T> ref) { - requiresNoCallbacks(); - if (! m_autoConfigInvoked) m_autoConfig = false; - List<MethodRef<Object, T>> list = m_refs.computeIfAbsent(cb, l -> new ArrayList<>()); - list.add((instance, component, sref, service) -> { - Stream.of(component.getInstances()).forEach(inst -> { - if (Helpers.getClassName(inst).equals(type)) { - ref.accept((I) inst, component, sref, service); - } - }); - }); - return (B) this; - } - - public <I> B setComponentInstanceSwapCallbackRef(String type, SwapMethodRef<I, T> ref) { - requiresNoCallbacks(); - if (! m_autoConfigInvoked) m_autoConfig = false; - m_swapRefs.add((instance, component, oref, oservice, nref, nservice) -> { - Stream.of(component.getInstances()).forEach(componentInstance -> { - if (Helpers.getClassName(componentInstance).equals(type)) { // Todo detect dynamic proxy ! - ref.accept((I) componentInstance, component, oref, oservice, nref, nservice); - } - }); - }); - return (B) this; - } - - protected Object createCallbackInstance() { + public <I> B setComponentSwapCallbackRef(Class<I> type, SwapMethodRef<I, S> ref) { + requiresNoCallbacks(); + if (! m_autoConfigInvoked) m_autoConfig = false; + m_swapRefs.add((instance, component, oref, oservice, nref, nservice) -> { + Stream.of(component.getInstances()).forEach(componentInstance -> { + if (Helpers.getClass(componentInstance).equals(type)) { + ref.accept((I) componentInstance, component, oref, oservice, nref, nservice); + } + }); + }); + return (B) this; + } + + public <I> B setInstanceSwapCallbackRef(SwapMethodRef<I, S> ref) { + requiresNoCallbacks(); + if (! m_autoConfigInvoked) m_autoConfig = false; + m_swapRefs.add((instance, component, oref, oservice, nref, nservice) -> { + ref.accept((I) component.getInstance(), component, oref, oservice, nref, nservice); + }); + return (B) this; + } + + protected Object createCallbackInstance() { Object cb = null; - + cb = new Object() { - void add(Component c, ServiceReference<T> ref, Object service) { - invokeMethodRefs("add", c, ref, (T) service); + void add(Component c, ServiceReference<S> ref, Object service) { + invokeMethodRefs("add", c, ref, (S) service); } - void change(Component c, ServiceReference<T> ref, Object service) { - invokeMethodRefs("change", c, ref, (T) service); + void change(Component c, ServiceReference<S> ref, Object service) { + invokeMethodRefs("change", c, ref, (S) service); } - void remove(Component c, ServiceReference<T> ref, Object service) { - invokeMethodRefs("remove", c, ref, (T) service); + void remove(Component c, ServiceReference<S> ref, Object service) { + invokeMethodRefs("remove", c, ref, (S) service); } - void swap(Component c, ServiceReference<T> oldRef, Object oldSrv, ServiceReference<T> newRef, Object newSrv) { - invokeSwapMethodRefs(c, oldRef, (T) oldSrv, newRef, (T) newSrv); + void swap(Component c, ServiceReference<S> oldRef, Object oldSrv, ServiceReference<S> newRef, Object newSrv) { + invokeSwapMethodRefs(c, oldRef, (S) oldSrv, newRef, (S) newSrv); } }; return cb; - } - - private void invokeMethodRefs(String method, Component comp, ServiceReference<T> ref, T service) { + } + + protected boolean hasRefs() { + return m_refs.size() > 0 || m_swapRefs.size() > 0; + } + + protected boolean hasCallbacks() { + return m_callbackInstance != null || m_added != null || m_changed != null || m_removed != null || m_swapped != null; + } + + private void invokeMethodRefs(String method, Component comp, ServiceReference<S> ref, S service) { m_refs.computeIfPresent(method, (k, mrefs) -> { mrefs.forEach(mref -> mref.accept(null, comp, ref, service)); return mrefs; }); - } + } - protected void invokeSwapMethodRefs(Component c, ServiceReference<T> oref, T osrv, ServiceReference<T> nref, T nsrv) { + private void invokeSwapMethodRefs(Component c, ServiceReference<S> oref, S osrv, ServiceReference<S> nref, S nsrv) { m_swapRefs.forEach(ref -> ref.accept(null, c, oref, osrv, nref, nsrv)); - } - - protected boolean hasRefs() { - return m_refs.size() > 0 || m_swapRefs.size() > 0; - } - - protected boolean hasCallbacks() { - return m_callbackInstance != null || m_added != null || m_changed != null || m_removed != null || m_swapped != null; - } + } - protected boolean hasComponentInstanceRefs() { - return m_hasComponentInstanceRefs; - } - - protected void requiresNoCallbacks() { + private void requiresNoCallbacks() { if (hasCallbacks()) { throw new IllegalStateException("can't mix method references and string callbacks."); } - } + } - protected void requiresNoMethodRefs() { + private void requiresNoMethodRefs() { if (hasRefs()) { throw new IllegalStateException("can't mix method references and string callbacks."); } - } + } + + private String getCallback(CB cbType) { + switch (cbType) { + case ADD: return "add"; + case CHG: return "change"; + case REM: return "remove"; + default: + throw new IllegalArgumentException("Invalid CbType: " + cbType); + } + } }
Modified: felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceDependencyBuilderImpl.java URL: http://svn.apache.org/viewvc/felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceDependencyBuilderImpl.java?rev=1724333&r1=1724332&r2=1724333&view=diff ============================================================================== --- felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceDependencyBuilderImpl.java (original) +++ felix/sandbox/pderop/dependencymanager-lambda/org.apache.felix.dependencymanager.lambda/src/org/apache/felix/dm/builder/lambda/impl/ServiceDependencyBuilderImpl.java Tue Jan 12 22:45:36 2016 @@ -6,11 +6,11 @@ import org.apache.felix.dm.ServiceDepend import org.apache.felix.dm.builder.lambda.ServiceDependencyBuilder; import org.osgi.framework.ServiceReference; -public class ServiceDependencyBuilderImpl<T> extends ServiceCallbacksBuilderImpl<T, ServiceDependencyBuilderImpl<T>> implements ServiceDependencyBuilder<T> { - private final Class<T> m_serviceIface; +public class ServiceDependencyBuilderImpl<S> extends ServiceCallbacksBuilderImpl<S, ServiceDependencyBuilderImpl<S>> implements ServiceDependencyBuilder<S> { + private final Class<S> m_serviceIface; private final Component m_component; private String m_filter; - private ServiceReference<T> m_ref; + private ServiceReference<S> m_ref; private boolean m_required = true; private String m_debug; private boolean m_propagate; @@ -18,51 +18,52 @@ public class ServiceDependencyBuilderImp private String m_propagateMethod; private Object m_defaultImpl; - public ServiceDependencyBuilderImpl(Component component, Class<T> service) { + public ServiceDependencyBuilderImpl(Component component, Class<S> service) { + super(service); m_serviceIface = service; m_component = component; } - public ServiceDependencyBuilder<T> filter(String filter) { + public ServiceDependencyBuilder<S> filter(String filter) { m_filter = filter; return this; } - public ServiceDependencyBuilder<T> ref(ServiceReference<T> ref) { + public ServiceDependencyBuilder<S> ref(ServiceReference<S> ref) { m_ref = ref; return this; } - public ServiceDependencyBuilder<T> required() { + public ServiceDependencyBuilder<S> required() { return required(true); } - public ServiceDependencyBuilder<T> required(boolean required) { + public ServiceDependencyBuilder<S> required(boolean required) { m_required = required; return this; } - public ServiceDependencyBuilder<T> debug(String label) { + public ServiceDependencyBuilder<S> debug(String label) { m_debug = label; return this; } - public ServiceDependencyBuilder<T> propagate() { + public ServiceDependencyBuilder<S> propagate() { return propagate(true); } - public ServiceDependencyBuilder<T> propagate(boolean propagate) { + public ServiceDependencyBuilder<S> propagate(boolean propagate) { m_propagate = propagate; return this; } - public ServiceDependencyBuilder<T> propagate(Object instance, String method) { + public ServiceDependencyBuilder<S> propagate(Object instance, String method) { m_propagateInstance = instance; m_propagateMethod = method; return this; } - public ServiceDependencyBuilder<T> defImpl(Object defaultImpl) { + public ServiceDependencyBuilder<S> defImpl(Object defaultImpl) { m_defaultImpl = defaultImpl; return this; } @@ -97,7 +98,7 @@ public class ServiceDependencyBuilderImp sd.setCallbacks(m_callbackInstance, m_added, m_changed, m_removed, m_swapped); } else if (hasRefs()) { Object cb = createCallbackInstance(); - sd.setCallbacks(cb, "add", "change", "remove", "swap"); + sd.setCallbacks(cb, "add", "change", "remove", m_swapRefs.size() > 0 ? "swap" : null); } if (m_autoConfigField != null) {
