private void invokeRemoveRequiredDependencies() { for (DependencyContext d : m_dependencies) { if (!d.isInstanceBound() && d.isRequired()) { for (Event e : m_dependencyEvents.get(d)) { invokeCallback(d, EventType.REMOVED, e); } } } }
private void invokeAddRequiredDependencies() { for (DependencyContext d : m_dependencies) { if (d.isRequired() && !d.isInstanceBound()) { for (Event e : m_dependencyEvents.get(d)) { invokeCallback(d, EventType.ADDED, e); } } } }
private void invokeAddRequiredInstanceBoundDependencies() { for (DependencyContext d : m_dependencies) { if (d.isRequired() && d.isInstanceBound()) { for (Event e : m_dependencyEvents.get(d)) { invokeCallback(d, EventType.ADDED, e); } } } }
private void invokeRemoveRequiredInstanceBoundDependencies() { for (DependencyContext d : m_dependencies) { if (d.isInstanceBound() && d.isRequired()) { for (Event e : m_dependencyEvents.get(d)) { invokeCallback(d, EventType.REMOVED, e); } } } }
/** * Removes and closes all instance bound dependencies. * This method is called when a component is destroyed. */ private void removeInstanceBoundDependencies() { for (DependencyContext dep : m_dependencies) { if (dep.isInstanceBound()) { m_dependencies.remove(dep); generateNameBasedOnServiceAndProperties(); dep.stop(); } } }
private boolean allRequiredAvailable() { boolean available = true; for (DependencyContext d : m_dependencies) { if (d.isRequired() && !d.isInstanceBound()) { if (!d.isAvailable()) { available = false; break; } } } return available; }
private boolean allInstanceBoundAvailable() { boolean available = true; for (DependencyContext d : m_dependencies) { if (d.isRequired() && d.isInstanceBound()) { if (!d.isAvailable()) { available = false; break; } } } return available; }
private void handleSwapped(DependencyContext dc, Event oldEvent, Event newEvent) { try { if (! m_isStarted) { return; } Set<Event> dependencyEvents = m_dependencyEvents.get(dc); dependencyEvents.remove(oldEvent); dependencyEvents.add(newEvent); // Depending on the state, we possible have to invoke the callbacks and update the component instance. switch (m_state) { case WAITING_FOR_REQUIRED: // No need to swap, we don't have yet injected anything break; case INSTANTIATED_AND_WAITING_FOR_REQUIRED: // Only swap *non* instance-bound dependencies if (!dc.isInstanceBound()) { invokeSwapCallback(dc, oldEvent, newEvent); } break; case TRACKING_OPTIONAL: invokeSwapCallback(dc, oldEvent, newEvent); break; default: } } finally { oldEvent.close(); } }
/** * Then handleEvent calls this method when a dependency service is being changed. */ private void handleChanged(final DependencyContext dc, final Event e) { if (! m_isStarted) { return; } Set<Event> dependencyEvents = m_dependencyEvents.get(dc); dependencyEvents.remove(e); dependencyEvents.add(e); switch (m_state) { case TRACKING_OPTIONAL: invokeCallback(dc, EventType.CHANGED, e); updateInstance(dc, e, true, false); break; case INSTANTIATED_AND_WAITING_FOR_REQUIRED: if (!dc.isInstanceBound()) { invokeCallback(dc, EventType.CHANGED, e); updateInstance(dc, e, true, false); } break; default: // noop } }
private void invokeAutoConfigDependencies() { for (DependencyContext d : m_dependencies) { if (d.isAutoConfig() && !d.isInstanceBound()) { configureImplementation(d.getAutoConfigType(), d, d.getAutoConfigName()); } } }
private void invokeAutoConfigInstanceBoundDependencies() { for (DependencyContext d : m_dependencies) { if (d.isAutoConfig() && d.isInstanceBound()) { configureImplementation(d.getAutoConfigType(), d, d.getAutoConfigName()); } } }
if (!dc.isInstanceBound()) { invokeCallback(dc, EventType.REMOVED, e); updateInstance(dc, e, false, false);
configureAutoConfigState(clone, ComponentImpl.this); getDependencies().stream().filter(dc -> ! dc.isInstanceBound()).map(dc -> dc.createCopy()).forEach(clone::add); clone.setCallbacks(m_callbackInit, m_callbackStart, m_callbackStop, m_callbackDestroy); m_listeners.forEach(clone::add);
if (!dc.isInstanceBound()) { invokeCallback(dc, EventType.ADDED, e); updateInstance(dc, e, false, true);