Refine search
private String toFileAbsolutePathStrings(File... files) { return Arrays.toString(Arrays.stream(ArrayUtils.nullSafeArray(files, File.class)) .filter(Objects::nonNull) .map(File::getAbsolutePath) .collect(Collectors.toSet()) .toArray()); } }
/** * Returns the {@link Class types} supported and handled by this {@link DataSerializer} during de/serialization. * * @return the {@link Class types} supported and handled by this {@link DataSerializer} during de/serialization. * @see DeltaCapableGemFireSession * @see GemFireSession * @see java.lang.Class */ @Override public Class<?>[] getSupportedClasses() { return asArray(GemFireSession.class, DeltaCapableGemFireSession.class); }
private boolean areAllEmpty(Object[]... arrays) { for (Object[] array : arrays) { if (!ArrayUtils.isEmpty(array)) { return false; } } return true; }
@SuppressWarnings("all") protected Set<String> resolveCacheNames(AnnotatedElement annotatedElement, Class<? extends Annotation>... annotationTypes) { Stream<String> cacheNames = stream(nullSafeArray(annotationTypes, Class.class)) .map(annotationType -> resolveAnnotation(annotatedElement, annotationType)) .flatMap(annotation -> resolveCacheNames((Annotation) annotation).stream()); return cacheNames.collect(Collectors.toSet()); } }
private static Object constructInstance(Class<?> type, Object... constructorArguments) { return org.springframework.data.util.ReflectionUtils.findConstructor(type, constructorArguments) .map(constructor -> BeanUtils.instantiateClass(constructor, constructorArguments)) .orElseThrow(() -> newIllegalArgumentException( "No suitable constructor was found for type [%s] having parameters [%s]", type.getName(), stream(nullSafeArray(constructorArguments, Object.class)) .map(ObjectUtils::nullSafeClassName) .collect(Collectors.toList()))); }
default void createRegions(RegionDefinition... regionDefinitions) { stream(nullSafeArray(regionDefinitions, RegionDefinition.class)).forEach(this::createRegion); }
@SuppressWarnings("unused") private String resolveDiskStoreDirectoryLocation(String... locations) { return stream(nullSafeArray(locations, String.class)) .filter(StringUtils::hasText) .findFirst() .orElse("."); }
@Override public Iterable<String> getBasePackages() { String[] value = this.attributes.getStringArray(VALUE); String[] basePackages = this.attributes.getStringArray(BASE_PACKAGES); Class<?>[] basePackageClasses = this.attributes.getClassArray(BASE_PACKAGE_CLASSES); // Default configuration - return package of annotated class if (areAllEmpty(value, basePackages, basePackageClasses)) { String className = this.metadata.getClassName(); return Collections.singleton(className.substring(0, className.lastIndexOf('.'))); } Set<String> packages = new HashSet<>(); packages.addAll(Arrays.asList(value)); packages.addAll(Arrays.asList(basePackages)); Arrays.stream(nullSafeArray(basePackageClasses, Class.class)) .map(ClassUtils::getPackageName) .forEach(packages::add); return packages; }
private Iterable<TypeFilter> parseFilters(AnnotationAttributes[] componentScanFilterAttributes) { return stream(nullSafeArray(componentScanFilterAttributes, AnnotationAttributes.class)) .flatMap(filterAttributes -> typeFiltersFor(filterAttributes).stream()) .collect(Collectors.toSet()); }
@Override @SuppressWarnings("all") public boolean matches(ConditionContext context, AnnotatedTypeMetadata metadata) { return Arrays.stream(ArrayUtils.nullSafeArray(ClientCacheFactoryBean.class.getMethods(), Method.class)) .map(Method::getName) .anyMatch("setSocketConnectTimeout"::equals); } }
@Override @SuppressWarnings("unchecked") public boolean canSerialize(Class<?> type) { return Arrays.stream(nullSafeArray(getSupportedClasses(), Class.class)) .filter(it -> type != null) .anyMatch(supportedClass -> supportedClass.isAssignableFrom(type)); }
protected Set<String> resolveBasePackages(AnnotationMetadata importingClassMetaData, AnnotationAttributes enableEntityDefinedRegionAttributes) { Set<String> resolvedBasePackages = new HashSet<>(); Collections.addAll(resolvedBasePackages, resolveProperty(entitiesProperty("base-packages"), String[].class, nullSafeArray(defaultIfEmpty( enableEntityDefinedRegionAttributes.getStringArray("basePackages"), enableEntityDefinedRegionAttributes.getStringArray("value")), String.class))); stream(nullSafeArray(enableEntityDefinedRegionAttributes.getClassArray( "basePackageClasses"), Class.class)) .forEach(type -> resolvedBasePackages.add(type.getPackage().getName())); if (resolvedBasePackages.isEmpty()) { resolvedBasePackages.add(ClassUtils.getPackageName(importingClassMetaData.getClassName())); } return resolvedBasePackages; }
private boolean isIncludedJsonRegion(String... regionReferences) { List<String> regionReferencesList = Arrays.asList(nullSafeArray(regionReferences, String.class)); return CollectionUtils.isEmpty(this.includedRegions) || this.includedRegions.stream() .anyMatch(includeRegion -> regionReferencesList.contains(includeRegion)); }
/** * Concatenates an array of {@link Stream Streams} into a single, continuous {@link Stream}. * * @param <T> {@link Class type} of elements in the {@link Stream Streams}. * @param streams array of {@link Stream Streams} to concatenate. * @return the concatenated array of {@link Stream Streams} as a single, continuous {@link Stream}. * @see java.util.stream.Stream */ @SuppressWarnings("unchecked") public static <T> Stream<T> concat(Stream<T>... streams) { Stream<T> concatenatedStream = Stream.empty(); for (Stream<T> stream : nullSafeArray(streams, Stream.class)) { concatenatedStream = Stream.concat(concatenatedStream, stream); } return concatenatedStream; } }
/** * Null-safe operation used to set an array of {@link RegionConfigurer RegionConfigurers} used to apply * additional configuration to this {@link ResolvableRegionFactoryBean} when using Annotation-based configuration. * * @param regionConfigurers array of {@link RegionConfigurer RegionConfigurers} used to apply * additional configuration to this {@link ResolvableRegionFactoryBean}. * @see org.springframework.data.gemfire.config.annotation.RegionConfigurer * @see #setRegionConfigurers(List) */ public void setRegionConfigurers(RegionConfigurer... regionConfigurers) { setRegionConfigurers(Arrays.asList(nullSafeArray(regionConfigurers, RegionConfigurer.class))); }
/** * Parses the array of hosts and ports in the format 'host[port]' to convert into an instance * of ConnectionEndpointList. * * @param defaultPort the default port number to use if port is not specified in a host and port value. * @param hostsPorts the array of hosts and ports to parse. * @return a ConnectionEndpointList representing the hosts and ports in the array. * @see org.springframework.data.gemfire.support.ConnectionEndpoint#parse(String, int) */ public static ConnectionEndpointList parse(int defaultPort, String... hostsPorts) { List<ConnectionEndpoint> connectionEndpoints = new ArrayList<ConnectionEndpoint>( ArrayUtils.length(hostsPorts)); for (String hostPort : ArrayUtils.nullSafeArray(hostsPorts, String.class)) { connectionEndpoints.add(ConnectionEndpoint.parse(hostPort, defaultPort)); } return new ConnectionEndpointList(connectionEndpoints); }
@Override public Object[] resolveFunctionArguments(FunctionContext functionContext) { Object[] args = super.resolveFunctionArguments(functionContext); if (functionContext instanceof RegionFunctionContext) { if (this.regionParameterPosition >= 0) { args = ArrayUtils.insert(args, regionParameterPosition, getRegionForContext( (RegionFunctionContext) functionContext)); } if (this.filterParameterPosition >= 0) { args = ArrayUtils.insert(args, filterParameterPosition, ((RegionFunctionContext) functionContext).getFilter()); } } if (this.functionContextParameterPosition >= 0) { args = ArrayUtils.insert(args, functionContextParameterPosition, functionContext); } if (this.resultSenderParameterPosition >= 0) { args = ArrayUtils.insert(args, resultSenderParameterPosition, functionContext.getResultSender()); } Assert.isTrue(args.length == this.method.getParameterTypes().length, String.format("Wrong number of arguments for method [%s]; Expected [%d], but was [%d]", this.method.getName(), this.method.getParameterTypes().length, args.length)); return args; }
/** * Determines whether the given array is empty or not. * * @param array the array to evaluate for emptiness. * @return a boolean value indicating whether the given array is empty. * @see #length(Object...) */ public static boolean isEmpty(Object[] array) { return length(array) == 0; }
/** * Null-safe method to return the first element in the array or {@literal null} * if the array is {@literal null} or empty. * * @param <T> Class type of the array elements. * @param array the array from which to extract the first element. * @return the first element in the array or {@literal null} if the array is null or empty. * @see #getFirst(Object[], Object) */ public static <T> T getFirst(T[] array) { return getFirst(array, null); }
@Override protected Iterable<?> invokeFunction(Method method, Object[] args) { GemfireOnRegionOperations gemfireOnRegionOperations = (GemfireOnRegionOperations) getGemfireFunctionOperations(); OnRegionMethodMetadata onRegionMethodMetadata = this.methodMetadata.getMethodMetadata(method); int filterArgPosition = onRegionMethodMetadata.getFilterArgPosition(); String functionId = onRegionMethodMetadata.getFunctionId(); Set<?> filter = null; // extract filter from args if necessary if (filterArgPosition >= 0) { filter = (Set<?>) args[filterArgPosition]; args = ArrayUtils.remove(args, filterArgPosition); } return filter != null ? gemfireOnRegionOperations.execute(functionId, filter, args) : gemfireOnRegionOperations.execute(functionId, args); } }