public static <T> T first( Iterable<T> self, Condition condition ) { for ( T object : self ) if ( condition.check(object) ) return object; return null; } }
private static <T> Condition<T> createInjectionCondition( Collection<Class<? extends Annotation>> qualifiers, final Field field ) { final ChainedCondition<T> condition = new ChainedCondition<>(); condition.add( (Condition<T>)new IsAssignableFrom( field.getType() ) ); condition.add( new QualifierCondition<>( qualifiers ) ); return condition; } }
/** * Load all services represented by the argument {@code serviceClazz}. * If no service was found, it will try to instantiate the class, * inject data and return an {@link Iterable} with this instance. * * @param serviceClazz - the service interface(or class) representation * @param condition - a filter condition * @return - all loaded or created services. */ default <T> Iterable<T> loadAll( final Class<T> serviceClazz, final Condition<T> condition ) { return Filter.filter( loadAll( serviceClazz ), condition ); }
/** * Load a service represented by the argument {@code serviceClazz}. * If no service was found, it will try to instantiate the class and * inject data. * * @param serviceClazz - the service interface(or class) representation * @return - the loaded or created service. */ default <T> T load( final Class<T> serviceClazz ) { return load( serviceClazz, AnyObject.instance() ); }
@Override public boolean check( final Element object ) { val parentClass = object.getEnclosingElement(); return object.getKind().equals( ElementKind.METHOD ) && isNotAbstract( parentClass ); }
public static <T> ProvidableField from(Collection<Class<? extends Annotation>> qualifiers, final Field field ) { assertFieldTypeIsIterable( field ); field.setAccessible( true ); final Class collectionType = identifyWhichTypeThisCollectionHas(field); return new ManyElementsProvidableField<>( field, (Class<T>)collectionType, new QualifierCondition<>( qualifiers ), new FieldProviderContext( qualifiers, field ) ); }
public <T> T load( final Class<T> serviceClazz, Condition<T> condition, ProviderContext providerContext ) { final Reference<T> produced = produceFromFactory( serviceClazz, providerContext ); return produced.getOrElse( () -> Filter.first( loadAll( serviceClazz, condition, providerContext ), condition ) ); }
@Override public boolean check( final T object ) { for ( val condition : conditions ) if ( !condition.check( object ) ) return false; return true; }
<T> T load(Class<T> serviceClazz, Condition<T> condition, ProviderContext context);
public <T> Iterable<T> loadAll( final Class<T> serviceClazz, Condition<T> condition, ProviderContext providerContext ) { return Filter.filter( loadAll( serviceClazz, providerContext ), condition ); }
public static <T> Iterable<T> filter( Iterable<T> self, Condition condition ) { val list = new TinyList<T>(); for ( T object : self ) if ( condition.check(object) ) list.add(object); return list; }
private List<ProducerFactory<?>> loadAll( Class<?> clazz, DefaultCDI.DependencyInjector injector ) { final List<ProducerFactory<?>> list = new TinyList<>(); final List<Class<ProducerFactory>> factories = producerImplementationClasses.get( clazz ); if ( factories != null ) for ( final Class<ProducerFactory> factoryClass : factories ) list.add( injector.load( factoryClass, AnyObject.instance(), EmptyProviderContext.INSTANCE ) ); return list; }