public void clearSupplier() { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).clear(); } else { supplier = null; key = null; } }
public void setSupplier(Supplier<?> newSupplier, InjectionAttributes attributes) { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).addSupplier(newSupplier, attributes); } else { this.supplier = newSupplier; } }
private Supplier<?> createSupplier(Class<?> referenceType) { if (Map.class.equals(referenceType)) { return new MapMultiplicitySupplier(); } else if (Set.class.equals(referenceType)) { return new SetMultiplicitySupplier(); } else if (List.class.equals(referenceType)) { return new ListMultiplicitySupplier(); } else if (Collection.class.equals(referenceType)) { return new ListMultiplicitySupplier(); } else { return NULL_FACTORY; } } }
MapMultiplicitySupplier mapFactory = new MapMultiplicitySupplier(); mapFactory.startUpdate(); mapFactory.addSupplier(supplier, attributes); factories.put(injectable, mapFactory); } else if (Set.class.equals(type)) { SetMultiplicitySupplier setFactory = new SetMultiplicitySupplier(); setFactory.startUpdate(); setFactory.addSupplier(supplier, attributes); factories.put(injectable, setFactory); } else if (List.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); factories.put(injectable, listFactory); } else if (Collection.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); factories.put(injectable, listFactory); } else if (type.isArray()) { ArrayMultiplicitySupplier arrayFactory = new ArrayMultiplicitySupplier(type.getComponentType()); arrayFactory.startUpdate(); arrayFactory.addSupplier(supplier, attributes); factories.put(injectable, arrayFactory); } else { multiplicitySupplier.addSupplier(supplier, attributes); } else {
public void endUpdate() { reinjectionMappings.keySet().stream().filter(factory -> factory instanceof MultiplicitySupplier).forEach(factory -> ((MultiplicitySupplier) factory) .endUpdate()); }
public void startUpdate() { reinjectionMappings.keySet().stream().filter(factory -> factory instanceof MultiplicitySupplier).forEach(factory -> ((MultiplicitySupplier) factory) .startUpdate()); }
public void endUpdate() { if (temporarySuppliers != null && !temporarySuppliers.isEmpty()) { // The isEmpty() check ensures only updates are applied since startUpdate()/endUpdate() can be called if there are no changes present. // Otherwise, if no updates are made, existing factories will be overwritten by the empty collection. suppliers = sortTemporaryFactories(temporarySuppliers); temporarySuppliers = null; } state = FactoryState.UPDATED; }
@SuppressWarnings("unchecked") public void setSupplier(Injectable injectable, Supplier<?> supplier, InjectionAttributes attributes) { if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { setUpdatableFactory(injectable, supplier, attributes); } else { // the factory corresponds to a property or context, which will override previous values if re-injected Supplier<?> factory = factories.get(injectable); if (factory instanceof UpdatableSupplier) { ((UpdatableSupplier) factory).update(supplier); } else { factories.put(injectable, supplier); } } }
Class<?> type = getMemberType(injectable); if (Map.class.equals(type)) { MapMultiplicitySupplier mapFactory = new MapMultiplicitySupplier(); mapFactory.startUpdate(); mapFactory.addSupplier(supplier, attributes); reinjectionMappings.put(mapFactory, injectable); } else if (Set.class.equals(type)) { SetMultiplicitySupplier setFactory = new SetMultiplicitySupplier(); setFactory.startUpdate(); setFactory.addSupplier(supplier, attributes); reinjectionMappings.put(setFactory, injectable); } else if (List.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); reinjectionMappings.put(listFactory, injectable); } else if (Collection.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); reinjectionMappings.put(listFactory, injectable); } else if (type.isArray()) { ArrayMultiplicitySupplier arrayFactory = new ArrayMultiplicitySupplier(type.getComponentType()); arrayFactory.startUpdate(); arrayFactory.addSupplier(supplier, attributes); reinjectionMappings.put(arrayFactory, injectable); } else { multiplicitySupplier.addSupplier(supplier, attributes);
private Supplier<?> createSupplier(Class<?> referenceType) { if (Map.class.equals(referenceType)) { return new MapMultiplicitySupplier(); } else if (Set.class.equals(referenceType)) { return new SetMultiplicitySupplier(); } else if (List.class.equals(referenceType)) { return new ListMultiplicitySupplier(); } else if (Collection.class.equals(referenceType)) { return new ListMultiplicitySupplier(); } else { return NULL_FACTORY; } } }
public void setSupplier(Supplier<?> newSupplier, InjectionAttributes attributes) { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).addSupplier(newSupplier, attributes); } else { this.supplier = newSupplier; } }
public void endUpdate() { for (Map.Entry<Injectable, Supplier<?>> entry : factories.entrySet()) { // signal to multiplicity factories updates are complete Injectable injectable = entry.getKey(); Supplier<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicitySupplier) { MultiplicitySupplier<?> multiplicitySupplier = (MultiplicitySupplier<?>) factory; multiplicitySupplier.endUpdate(); } } } }
public void startUpdate() { for (Map.Entry<Injectable, Supplier<?>> entry : factories.entrySet()) { // signal to multiplicity factories that previous contents should be overwritten if the factory is updated (e.g. during reinjection) Injectable injectable = entry.getKey(); Supplier<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicitySupplier) { MultiplicitySupplier<?> multiplicitySupplier = (MultiplicitySupplier<?>) factory; multiplicitySupplier.startUpdate(); } } } }
public void clearSupplier() { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).clear(); } else { supplier = null; } }
public void endUpdate() { if (temporarySuppliers != null && !temporarySuppliers.isEmpty()) { // The isEmpty() check ensures only updates are applied since startUpdate()/endUpdate() can be called if there are no changes present. // Otherwise, if no updates are made, existing factories will be overwritten by the empty collection. suppliers = sortTemporaryFactories(temporarySuppliers); temporarySuppliers = null; } state = FactoryState.UPDATED; }
MapMultiplicitySupplier mapFactory = new MapMultiplicitySupplier(); mapFactory.startUpdate(); mapFactory.addSupplier(supplier, attributes); factories.put(injectable, mapFactory); } else if (Set.class.equals(type)) { SetMultiplicitySupplier setFactory = new SetMultiplicitySupplier(); setFactory.startUpdate(); setFactory.addSupplier(supplier, attributes); factories.put(injectable, setFactory); } else if (List.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); factories.put(injectable, listFactory); } else if (Collection.class.equals(type)) { ListMultiplicitySupplier listFactory = new ListMultiplicitySupplier(); listFactory.startUpdate(); listFactory.addSupplier(supplier, attributes); factories.put(injectable, listFactory); } else if (type.isArray()) { ArrayMultiplicitySupplier arrayFactory = new ArrayMultiplicitySupplier(type.getComponentType()); arrayFactory.startUpdate(); arrayFactory.addSupplier(supplier, attributes); factories.put(injectable, arrayFactory); } else { multiplicitySupplier.addSupplier(supplier, attributes); } else {
public void endUpdate() { for (Map.Entry<Injectable, Supplier<?>> entry : factories.entrySet()) { // signal to multiplicity factories updates are complete Injectable injectable = entry.getKey(); Supplier<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicitySupplier) { MultiplicitySupplier<?> multiplicitySupplier = (MultiplicitySupplier<?>) factory; multiplicitySupplier.endUpdate(); } } } }
public void startUpdate() { for (Map.Entry<Injectable, Supplier<?>> entry : factories.entrySet()) { // signal to multiplicity factories that previous contents should be overwritten if the factory is updated (e.g. during reinjection) Injectable injectable = entry.getKey(); Supplier<?> factory = entry.getValue(); if (InjectableType.REFERENCE == injectable.getType() || InjectableType.CALLBACK == injectable.getType()) { if (factory instanceof MultiplicitySupplier) { MultiplicitySupplier<?> multiplicitySupplier = (MultiplicitySupplier<?>) factory; multiplicitySupplier.startUpdate(); } } } }
public void clearSupplier() { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).clear(); } else { supplier = null; } } }
public void clearSupplier() { if (this.supplier instanceof MultiplicitySupplier<?>) { ((MultiplicitySupplier<?>) this.supplier).clear(); } else { supplier = null; } }