/** * Check if the given {@code field} should hold a Managed Object. * * @param field * @return */ public boolean isASingleElementProvider( Field field ) { for ( final FieldQualifierExtractor extractor : extractors ) if ( extractor.isASingleElementProvider( field ) ) return true; return false; }
public LazyClassReader( final String serviceClassCanonicalName, final ClassLoader loader ) { this.serviceClassCanonicalName = serviceClassCanonicalName; this.loader = loader; this.resources = readAllServiceResources(); }
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 ) ); }
static void populateWithProvidableFields(InjectableDataExtractor extractor, Class<?> targetClazz, List<ProvidableField> providableFields ) { for ( final Field field : targetClazz.getDeclaredFields() ) { final Collection<Class<? extends Annotation>> qualifiers = extractQualifiersAvoidingNPEWhenCreatingQualifierExtractorFrom( extractor, field ); if ( extractor.isAManyElementsProvider( field ) ) providableFields.add( ManyElementsProvidableField.from( qualifiers, field ) ); else if ( extractor.isASingleElementProvider( field ) ) providableFields.add( SingleElementProvidableField.from( qualifiers, field ) ); } }
/** * Extract Qualifier Annotation from a given {@code field}. * * @param field * @return */ public Collection<Class<? extends Annotation>> extractQualifiersFrom( Field field ){ final Collection<Class<? extends Annotation>> anns = new TinyList<>(); for ( final FieldQualifierExtractor extractor : extractors ) anns.addAll( extractor.extractQualifiersFrom(field) ); return anns; }
static Iterable<ProvidableField> readClassProvidableFields(InjectableDataExtractor extractor, Class<?> targetClazz ) { final List<ProvidableField> providableFields = new TinyList<>(); Class<? extends Object> clazz = targetClazz; while ( !Object.class.equals( clazz ) ) { populateWithProvidableFields( extractor, clazz, providableFields ); if ( clazz.isAnnotationPresent( GeneratedFromStatelessService.class ) ) break; clazz = clazz.getSuperclass(); } return providableFields; }
public static <T> ProvidableClass<T> wrap(InjectableDataExtractor extractor, Class<T> targetClazz ) { return new ProvidableClass<T>( targetClazz, readClassProvidableFields( extractor, targetClazz ), readPostConstructor( targetClazz ) ); }
public static <T> List<T> singleElement( T t ) { return new TinyList<>( t ); } }
public static <T> ProvidableField from( Collection<Class<? extends Annotation>> qualifiers, final Field field ) { field.setAccessible( true ); final Typed Inject = field.getAnnotation( Typed.class ); final Class expectedClass = Inject != null ? Inject.value()[0] : field.getType(); return new SingleElementProvidableField<>( field, (Class<T>)expectedClass, createInjectionCondition( qualifiers, field ), new FieldProviderContext( qualifiers, field ) ); }
public static <T> List<Class<T>> loadImplementationsFor( Class<T> clazz ) { final ClassLoader cl = Thread.currentThread().getContextClassLoader(); final Iterator<Class<T>> reader = new LazyClassReader<T>( clazz, cl ); return readAndConvertToList( reader ); }
static <T> Reference<T> mandatory( String msg, T initialValue ) { return new MandatoryReference<T>( msg ).set( initialValue ); }
@Override public boolean isAManyElementsProvider( Field field ) { return isASingleElementProvider( field ) && fieldRepresentsACollection( field ) && field.isAnnotationPresent( Typed.class ); }
/** * Check if the given {@code field} should hold one or more Managed Objects. * * @param field * @return */ public boolean isAManyElementsProvider( Field field ) { for ( final FieldQualifierExtractor extractor : extractors ) if ( extractor.isAManyElementsProvider( field ) ) return true; return false; } }
@Override public Iterator<T> iterator() { return new TinyListIterator<>(); }
/** * Check if the given Annotation {@code ann} is a Qualifier Annotation. * * @param ann * @return */ public boolean isAnnotatedWithQualifierAnnotation( Class<? extends Annotation> ann ){ for ( final FieldQualifierExtractor extractor : extractors ) if ( extractor.isAnnotatedWithQualifierAnnotation(ann) ) return true; return false; }
@Override public Iterator<T> iterator() { return new SingleObjectIterator( object ); }
@Override public <T> void producerFor( final Class<T> serviceClazz, final ProducerFactory<T> provider ) { producers.memorizeProviderForClazz( provider, serviceClazz ); }
@Override @SuppressWarnings( "unchecked" ) public <T> T attribute( Class<T> key ) { return (T)attribute( key.getCanonicalName() ); }
public static <T> List<Class<T>> loadImplementationsFor( String clazz ) { final ClassLoader cl = Thread.currentThread().getContextClassLoader(); final Iterator<Class<T>> reader = new LazyClassReader<T>( clazz, cl ); return readAndConvertToList( reader ); }