public static <T> List<T> copyOf(Iterable<T> source) { Preconditions.checkNotNull(source); if (source instanceof Collection<?>) { return copyOf((Collection<T>) source); } return ImmutableList.<T>builder().addAll(source).build(); }
@Override public Iterator<E> iterator() { final Iterator<E> iterator = Iterators.concat(ImmutableList.of(set1.iterator(), difference.iterator()).iterator()); // Remove operation is not supported by default return new Iterator<E>() { @Override public boolean hasNext() { return iterator.hasNext(); } @Override public E next() { return iterator.next(); } }; }
/** * Creates an immutable list that consists of the given elements. This method should only be used in the varargs form. If there is a need to create an * immutable list of an array of elements, {@link #copyOf(Object[])} should be used instead. * * @param elements the given elements * @return an immutable list */ @SafeVarargs public static <T> List<T> of(T... elements) { Preconditions.checkNotNull(elements); return ofInternal(elements); }
AnnotatedMethodImpl(AnnotatedMethodConfiguratorImpl<X> configurator) { this.delegate = configurator.getAnnotated(); this.annotations = new Annotations(configurator); this.parameters = configurator.getParams().stream().map((c) -> new AnnotatedParameterImpl<X>(c)).collect(ImmutableList.collector()); }
public WeldModules() { modules = load(WeldModule.class, WeldClassLoaderResourceLoader.INSTANCE).stream().map(metadata -> metadata.getValue()) .sorted((m1, m2) -> m1.getName().compareTo(m2.getName())) .collect(ImmutableList.collector()); this.validators = Collections.emptySet(); BootstrapLogger.LOG.debugv("Using Weld modules: {0}", modules.stream().map(m -> m.getName()).collect(Collectors.toList())); }
List<Class<?>> globallyEnabledDecorators = getDecoratorList(null); ImmutableList.Builder<Class<?>> moduleInterceptorsBuilder = ImmutableList.<Class<?>>builder(); moduleInterceptorsBuilder.addAll(globallyEnabledInterceptors); ImmutableList.Builder<Class<?>> moduleDecoratorsBuilder = ImmutableList.<Class<?>>builder(); moduleDecoratorsBuilder.addAll(globallyEnabledDecorators); checkForDuplicates(beansXml.getEnabledAlternativeStereotypes(), ValidatorLogger.ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES); List<Class<?>> interceptorClasses = beansXml.getEnabledInterceptors().stream().map(loader).collect(Collectors.toList()); moduleInterceptorsBuilder.addAll(filter(interceptorClasses, globallyEnabledInterceptors, ValidatorLogger.INTERCEPTOR_ENABLED_FOR_APP_AND_ARCHIVE, deployment)); List<Class<?>> decoratorClasses = beansXml.getEnabledDecorators().stream().map(loader).collect(Collectors.toList()); moduleDecoratorsBuilder.addAll(filter(decoratorClasses, globallyEnabledDecorators, ValidatorLogger.DECORATOR_ENABLED_FOR_APP_AND_ARCHIVE, deployment)); alternativeClasses = beansXml.getEnabledAlternativeClasses().stream().map(loader).collect(ImmutableSet.collector()); alternativeStereotypes = cast(beansXml.getEnabledAlternativeStereotypes().stream().map(loader).collect(ImmutableSet.collector())); } else { alternativeClasses = Collections.emptySet();
List<Class<?>> globallyEnabledDecorators = getDecoratorList(null); ImmutableList.Builder<Class<?>> moduleInterceptorsBuilder = ImmutableList.<Class<?>>builder(); moduleInterceptorsBuilder.addAll(globallyEnabledInterceptors); ImmutableList.Builder<Class<?>> moduleDecoratorsBuilder = ImmutableList.<Class<?>>builder(); moduleDecoratorsBuilder.addAll(globallyEnabledDecorators); interceptorClasses.add(loader.apply(stringMetadata)); moduleInterceptorsBuilder.addAll(filter(interceptorClasses, globallyEnabledInterceptors, ValidatorLogger.INTERCEPTOR_ENABLED_FOR_APP_AND_ARCHIVE, deployment)); deployment)); alternativeClasses = ImmutableSet.copyOf(Iterables.transform(beansXml.getEnabledAlternativeClasses(), loader)); alternativeStereotypes = cast(ImmutableSet.copyOf(Iterables.transform(beansXml.getEnabledAlternativeStereotypes(), loader))); } else { alternativeClasses = Collections.emptySet();
public SimpleInterceptorInvocation(Object instance, InterceptionType interceptionType, List<Method> interceptorMethods, boolean targetClass) { this.instance = instance; this.interceptionType = interceptionType; this.targetClass = targetClass; if (interceptorMethods.size() == 1) { // Very often there will be only one interceptor method interceptorMethodInvocations = ImmutableList.<InterceptorMethodInvocation> of(new SimpleMethodInvocation(interceptorMethods.get(0))); } else { ImmutableList.Builder<InterceptorMethodInvocation> builder = ImmutableList.builder(); for (Method method : interceptorMethods) { builder.add(new SimpleMethodInvocation(method)); } interceptorMethodInvocations = builder.build(); } }
public List<Set<FieldInjectionPoint<?, ?>>> getFieldInjectionPoints(Bean<?> declaringBean, EnhancedAnnotatedType<?> type, BeanManagerImpl manager) { List<Set<FieldInjectionPoint<?, ?>>> injectableFieldsList = new ArrayList<Set<FieldInjectionPoint<?, ?>>>(); if (type.slim() instanceof UnbackedAnnotatedType<?>) { // external AnnotatedTypes require special treatment Collection<EnhancedAnnotatedField<?, ?>> allFields = type.getEnhancedFields(Inject.class); for (Class<?> clazz = type.getJavaClass(); clazz != null && clazz != Object.class; clazz = clazz.getSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> field : allFields) { if (!field.isStatic() && field.getJavaMember().getDeclaringClass().equals(clazz)) { addFieldInjectionPoint(field, fields, declaringBean, type.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } else { for (EnhancedAnnotatedType<?> t = type; t != null && !t.getJavaClass().equals(Object.class); t = t .getEnhancedSuperclass()) { ImmutableSet.Builder<FieldInjectionPoint<?, ?>> fields = ImmutableSet.builder(); for (EnhancedAnnotatedField<?, ?> annotatedField : t.getDeclaredEnhancedFields(Inject.class)) { if (!annotatedField.isStatic()) { addFieldInjectionPoint(annotatedField, fields, declaringBean, t.getJavaClass(), manager); } } injectableFieldsList.add(0, fields.build()); } } return ImmutableList.copyOf(injectableFieldsList); }
@SuppressWarnings({ "rawtypes", "unchecked" }) private <T> AnnotatedType<T> wrapAnnotatedType(AnnotatedType<T> annotatedType, Map<String, Id> routers) { ImmutableSet.Builder<AnnotatedMethod<?>> methodsBuilder = ImmutableSet.builder(); for (AnnotatedMethod<?> method : annotatedType.getMethods()) { Id id = routers.get(method.getJavaMember().toGenericString()); if (id != null) { ImmutableList.Builder<AnnotatedParameter<?>> paramsBuilder = ImmutableList.builder(); for (AnnotatedParameter<?> param : method.getParameters()) { if (param.isAnnotationPresent(Observes.class)) { // Add id qualifier paramsBuilder.add(new WrappedParam(param, ImmutableSet.builder().addAll(param.getAnnotations()).add(id).build())); } else { paramsBuilder.add(param); } } methodsBuilder.add(new WrappedMethod(method, paramsBuilder.build())); } else { // Use the method as it is methodsBuilder.add(method); } } return new WrappedType(annotatedType, methodsBuilder.build()); }
@Override public List<ScanResult> scan() { String javaClassPath = AccessController.doPrivileged(new GetSystemPropertyAction(JAVA_CLASS_PATH_SYSTEM_PROPERTY)); if (javaClassPath == null) { throw CommonLogger.LOG.cannotReadJavaClassPathSystemProperty(); } ImmutableList.Builder<ScanResult> results = ImmutableList.builder(); Set<String> entries = ImmutableSet.of(javaClassPath.split(Pattern.quote(File.pathSeparator))); logger.debugv("Scanning class path entries: {0}", entries); for (String entry : entries) { if (entry == null || entry.isEmpty()) { continue; } File entryFile = new File(entry); if (!entryFile.canRead()) { throw CommonLogger.LOG.cannotReadClassPathEntry(entryFile); } try { if (entryFile.isDirectory()) { scanDirectory(entryFile, results); } else { scanJarFile(entryFile, results); } } catch (IOException e) { throw CommonLogger.LOG.cannotScanClassPathEntry(entryFile, e); } } return results.build(); }
public static <X> List<AnnotatedParameter<X>> forExecutable(Executable executable, BackedAnnotatedCallable<X, ?> declaringCallable, SharedObjectCache cache) { final Parameter[] parameters = executable.getParameters(); if (parameters.length == 0) { return Collections.emptyList(); } ImmutableList.Builder<AnnotatedParameter<X>> builder = ImmutableList.builder(); for (int i = 0; i < parameters.length; i++) { builder.add(BackedAnnotatedParameter.of(parameters[i], i, declaringCallable, cache)); } return builder.build(); }
/** * * @return an immutable list of ids of running containers */ public static List<String> getRunningContainerIds() { return ImmutableList.copyOf(RUNNING_CONTAINER_IDS); }
@SuppressWarnings("unchecked") private static <T> List<T> ofInternal(Object[] elements) { switch (elements.length) { case 0: return Collections.emptyList(); case 1: return new ImmutableTinyList.Singleton<T>((T) elements[0]); default: return new ImmutableArrayList<T>(checkElementsNotNull(elements)); } }
AnnotatedConstructorImpl(AnnotatedConstructorConfiguratorImpl<X> configurator) { this.delegate = configurator.getAnnotated(); this.annotations = new Annotations(configurator); this.parameters = configurator.getParams().stream().map((c) -> new AnnotatedParameterImpl<X>(c)).collect(ImmutableList.collector()); }
public WeldModules() { modules = load(WeldModule.class, WeldClassLoaderResourceLoader.INSTANCE).stream().map(metadata -> metadata.getValue()) .sorted((m1, m2) -> m1.getName().compareTo(m2.getName())) .collect(ImmutableList.collector()); this.validators = Collections.emptySet(); BootstrapLogger.LOG.debugv("Using Weld modules: {0}", modules.stream().map(m -> m.getName()).collect(Collectors.toList())); }
List<Class<?>> globallyEnabledDecorators = getDecoratorList(null); ImmutableList.Builder<Class<?>> moduleInterceptorsBuilder = ImmutableList.<Class<?>>builder(); moduleInterceptorsBuilder.addAll(globallyEnabledInterceptors); ImmutableList.Builder<Class<?>> moduleDecoratorsBuilder = ImmutableList.<Class<?>>builder(); moduleDecoratorsBuilder.addAll(globallyEnabledDecorators); checkForDuplicates(beansXml.getEnabledAlternativeStereotypes(), ValidatorLogger.ALTERNATIVE_STEREOTYPE_SPECIFIED_MULTIPLE_TIMES); List<Class<?>> interceptorClasses = beansXml.getEnabledInterceptors().stream().map(loader).collect(Collectors.toList()); moduleInterceptorsBuilder.addAll(filter(interceptorClasses, globallyEnabledInterceptors, ValidatorLogger.INTERCEPTOR_ENABLED_FOR_APP_AND_ARCHIVE, deployment)); List<Class<?>> decoratorClasses = beansXml.getEnabledDecorators().stream().map(loader).collect(Collectors.toList()); moduleDecoratorsBuilder.addAll(filter(decoratorClasses, globallyEnabledDecorators, ValidatorLogger.DECORATOR_ENABLED_FOR_APP_AND_ARCHIVE, deployment)); alternativeClasses = beansXml.getEnabledAlternativeClasses().stream().map(loader).collect(ImmutableSet.collector()); alternativeStereotypes = cast(beansXml.getEnabledAlternativeStereotypes().stream().map(loader).collect(ImmutableSet.collector())); } else { alternativeClasses = Collections.emptySet();