/** * Get the highest ranked available dependency service, or null. */ @Override public Event getService() { Event event = m_component.getDependencyEvent(this); if (event == null) { Object defaultService = getDefaultService(true); if (defaultService != null) { event = new Event(defaultService); } } return event; }
@Override public void removedService(@SuppressWarnings("rawtypes") ServiceReference reference, Object event) { ServiceEventImpl evt = (ServiceEventImpl) event; m_component.handleEvent(this, EventType.REMOVED, evt); }
private boolean allInstanceBoundAvailable() { boolean available = true; for (DependencyContext d : m_dependencies) { if (d.isRequired() && d.isInstanceBound()) { if (!d.isAvailable()) { available = false; break; } } } return available; }
/** * Triggers component activation when the future has completed. * @param result * @param error */ private void completed(F result, Throwable error) { if (error != null) { super.getComponentContext().getLogger().log(LogService.LOG_ERROR, "completable future failed", error); } else { // Will trigger component activation (if other dependencies are satisfied), and our invokeCallback method will then be called. m_component.handleEvent(this, EventType.ADDED, new Event(result)); } }
public void activate(boolean active) { m_component.handleEvent(this, active ? EventType.ADDED : EventType.REMOVED, new Event(active)); }
private void invokeCallbacks(Component component, Object callbackInstance, String callback, String defaultCallback) { boolean logIfNotFound = (callback != null); callback = callback != null ? callback : defaultCallback; ComponentContext ctx = (ComponentContext) component; Object[] instances = callbackInstance != null ? new Object[] { callbackInstance } : ctx.getInstances(); ctx.invokeCallbackMethod(instances, callback, new Class[][] {{ Component.class }, {}}, new Object[][] {{ component }, {}}, logIfNotFound); }
public CompletableFutureDependencyImpl(Component c, CompletableFuture<F> future) { super.setRequired(true); m_future = future; m_comp = c; }
/** * Sets a callback method invoked on the instantiated component. */ public ConfigurationDependencyImpl setCallback(String callback) { super.setCallbacks(callback, null); return this; }
/** * Returns the dependency callback instances * @return the dependency callback instances */ public Object[] getInstances() { if (m_callbackInstance == null) { return m_component.getInstances(); } else { return new Object[] { m_callbackInstance }; } }
/** * Invokes a swap callback, except if the dependency is optional and the component is * not started (optional dependencies are always injected while the component is started). */ private void invokeSwapCallback(DependencyContext dc, Event oldEvent, Event newEvent) { if (! dc.isRequired() && ! m_startCalled) { return; } dc.invokeCallback(EventType.SWAPPED, oldEvent, newEvent); }
/** * Returns this dependency state. */ @Override public int getState() { // Can be called from any threads, but our class attributes are volatile if (m_isStarted) { return (isAvailable() ? 1 : 0) + (isRequired() ? 2 : 0); } else { return isRequired() ? ComponentDependencyDeclaration.STATE_REQUIRED : ComponentDependencyDeclaration.STATE_OPTIONAL; } }
@SuppressWarnings("unchecked") public T setPropagate(boolean propagate, boolean overrideServiceProperties) { ensureNotActive(); m_propagate = propagate; m_propagateOverrides = overrideServiceProperties; return (T) this; }
private boolean someDependenciesNeedInstance() { for (DependencyContext d : m_dependencies) { if (d.needsInstance()) { return true; } } return false; }
private void stopDependencies() { for (DependencyContext d : m_dependencies) { d.stop(); } }
/** * Returns a description of this dependency (like the dependency service class name with associated filters) */ @Override public String getName() { return getSimpleName(); }
@Override public void modifiedService(@SuppressWarnings("rawtypes") ServiceReference reference, Object event) { ServiceEventImpl evt = (ServiceEventImpl) event; m_component.handleEvent(this, EventType.CHANGED, evt); }
private boolean allRequiredAvailable() { boolean available = true; for (DependencyContext d : m_dependencies) { if (d.isRequired() && !d.isInstanceBound()) { if (!d.isAvailable()) { available = false; break; } } } return available; }
@Override public ConfigurationDependencyImpl setRequired(boolean required) { m_optional = ! required; super.setRequired(true); // always required return this; }
/** * Sets the add/change/remove callbacks. * @param add the callback to invoke when a dependency is added * @param change the callback to invoke when a dependency has changed * @param remove the callback to invoke when a dependency is removed * @return this dependency instance */ public T setCallbacks(String add, String change, String remove) { return setCallbacks(null, add, change, remove); }
/** * Sets the add/remove callbacks. * @param add the callback to invoke when a dependency is added * @param remove the callback to invoke when a dependency is removed * @return this dependency instance */ public T setCallbacks(String add, String remove) { return setCallbacks(add, null, remove); }