src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<Void> deleteGrantAgreement(long applicationId) { String url = format("%s/%s/%s", REST_URL, "grant-agreement", applicationId); return deleteWithRestResult(url); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); } | @Test public void deleteGrantAgreement() { long applicationId = 78L; setupDeleteWithRestResultExpectations(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId)); service.deleteGrantAgreement(applicationId); setupDeleteWithRestResultVerifications(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId)); } |
EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId) { String url = format("%s/%s/%s", REST_URL, "grant-agreement", applicationId); return getWithRestResult(url, ByteArrayResource.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); } | @Test public void downloadGrantAgreement() { final long applicationId = 912L; ByteArrayResource expected = new ByteArrayResource("1u6536748".getBytes()); setupGetWithRestResultExpectations(format("%s/%s/%s", REST_URL, "grant-agreement", applicationId), ByteArrayResource.class, expected, OK); final ByteArrayResource response = service.downloadGrantAgreement(applicationId).getSuccess(); assertSame(expected, response); } |
EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId) { String url = format("%s/%d", REST_URL, applicationId); return getWithRestResult(url, EuGrantTransferResource.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); } | @Test public void findDetailsByApplicationId() { final long applicationId = 912L; EuGrantTransferResource euGrantTransferResource = newEuGrantTransferResource().build(); setupGetWithRestResultExpectations(format("%s/%s", REST_URL, applicationId), EuGrantTransferResource.class, euGrantTransferResource, OK); RestResult<EuGrantTransferResource> result = service.findDetailsByApplicationId(applicationId); assertSame(euGrantTransferResource, result.getSuccess()); } |
EuGrantTransferRestServiceImpl extends BaseRestService implements EuGrantTransferRestService { @Override public RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId) { String url = format("%s/%d", REST_URL, applicationId); return postWithRestResult(url, euGrantResource, Void.class); } @Override RestResult<Void> uploadGrantAgreement(long applicationId, String contentType, long size, String originalFilename, byte[] multipartFileBytes); @Override RestResult<Void> deleteGrantAgreement(long applicationId); @Override RestResult<ByteArrayResource> downloadGrantAgreement(long applicationId); @Override RestResult<FileEntryResource> findGrantAgreement(long applicationId); @Override RestResult<EuGrantTransferResource> findDetailsByApplicationId(long applicationId); @Override RestResult<Void> updateGrantTransferDetails(EuGrantTransferResource euGrantResource, long applicationId); } | @Test public void updateGrantTransferDetails() { final long applicationId = 912L; EuGrantTransferResource euGrantTransferResource = newEuGrantTransferResource().build(); setupPostWithRestResultExpectations(format("%s/%s", REST_URL, applicationId), euGrantTransferResource, OK); RestResult<Void> result = service.updateGrantTransferDetails(euGrantTransferResource, applicationId); assertTrue(result.isSuccess()); } |
SurveyRestServiceImpl extends BaseRestService implements SurveyRestService { @Override @HystrixCommand(fallbackMethod = "saveFallback") public RestResult<Void> save(SurveyResource surveyResource) { return postWithRestResultAnonymous( "/survey", surveyResource, Void.class); } @Override @Value("${ifs.survey.data.service.baseURL}") void setServiceUrl(String serviceUrl); @Override @HystrixCommand(fallbackMethod = "saveFallback") RestResult<Void> save(SurveyResource surveyResource); RestResult<Void> saveFallback(SurveyResource surveyResource, Throwable e); } | @Test public void save() { String baseUrl = "base"; surveyRestService.setServiceUrl(baseUrl); SurveyResource surveyResource = newSurveyResource().build(); RestResult<Void> expected = mock(RestResult.class); when(rootAnonymousUserRestTemplateAdaptor.postWithRestResult(baseUrl + "/survey", surveyResource, Void.class)).thenReturn(expected); RestResult<Void> result = surveyRestService.save(surveyResource); assertEquals(result, expected); } |
RestResult extends BaseFailingOrSucceedingResult<T, RestFailure> { public static <T> RestResult<List<T>> aggregate(final List<RestResult<T>> input) { return BaseFailingOrSucceedingResult.aggregate( input, (f1, f2) -> new RestFailure(combineLists(f1.getErrors(), f2.getErrors())), restSuccess(emptyList())); } RestResult(RestResult<T> original); RestResult(Either<RestFailure, T> result, HttpStatus successfulStatusCode); @Override RestResult<R> andOnFailure(Runnable failureHandler); @Override RestResult<R> andOnFailure(Consumer<RestFailure> failureHandler); @Override RestResult<R> andOnSuccess(Supplier<? extends FailingOrSucceedingResult<R, RestFailure>> successHandler); @Override RestResult<R> andOnSuccessReturn(Supplier<R> successHandler); @Override RestResult<R> andOnSuccess(ExceptionThrowingFunction<? super T, FailingOrSucceedingResult<R, RestFailure>> successHandler); @Override RestResult<R> andOnSuccessReturn(ExceptionThrowingFunction<? super T, R> successHandler); @Override T findAndThrowException(RestFailure restFailure); HttpStatus getStatusCode(); ServiceResult<T> toServiceResult(); RestResult<Optional<T>> toOptionalIfNotFound(); @Override boolean equals(Object o); @Override int hashCode(); static T1 getLeftOrRight(Either<T1, T1> either); static RestResult<Void> restSuccess(); static RestResult<Void> restSuccess(HttpStatus statusCode); static RestResult<T> restSuccess(T successfulResult); static RestResult<T> restAccepted(T successfulResult); static RestResult<T> restSuccess(T result, HttpStatus statusCode); static RestResult<T> restFailure(RestFailure failure); static RestResult<T> restFailure(HttpStatus statusCode); static RestResult<T> restFailure(ErrorTemplate errorTemplate); static RestResult<T> restFailure(Error error); static RestResult<T> restFailure(List<Error> errors); static RestResult<T> restFailure(List<Error> errors, HttpStatus statusCode); static Either<Void, T> fromJson(String json, Class<T> clazz); static RestResult<T> fromException(HttpStatusCodeException e); static RestResult<T> fromResponse(final ResponseEntity<T> response, HttpStatus expectedSuccessCode, HttpStatus... otherExpectedStatusCodes); static RestResult<T> toGetResponse(T body); static RestResult<T> toPostCreateResponse(T body); static RestResult<T> toPostAcceptResponse(T body); static RestResult<Void> toPostResponse(); static RestResult<T> toPostWithBodyResponse(T body); static RestResult<Void> toPutResponse(); @Deprecated static RestResult<T> toPutWithBodyResponse(T body); static RestResult<Void> toDeleteResponse(); static RestResult<List<T>> aggregate(final List<RestResult<T>> input); } | @Test public void testAggregateSuccess() { final List<RestResult<String>> list = asList("1", "2", "3").stream().map(RestResult::restSuccess).collect(toList()); final RestResult<List<String>> RestResult = aggregate(list); assertTrue(RestResult.isSuccess()); assertFalse(RestResult.getSuccess().isEmpty()); assertEquals(asList("1", "2", "3"), RestResult.getSuccess()); }
@Test public void testEmptyList() { final List<RestResult<String>> empty = new ArrayList(); final RestResult<List<String>> RestResult = aggregate(empty); assertTrue(RestResult.isSuccess()); assertNotNull(RestResult.getSuccess()); assertTrue(RestResult.getSuccess().isEmpty()); } |
ServiceResult extends BaseFailingOrSucceedingResult<T, ServiceFailure> implements Serializable { public static <T> ServiceResult<List<T>> aggregate(final List<ServiceResult<T>> input) { return BaseFailingOrSucceedingResult.aggregate( input, (f1, f2) -> new ServiceFailure(combineLists(f1.getErrors(), f2.getErrors())), serviceSuccess(emptyList())); } private ServiceResult(Either<ServiceFailure, T> result); @Override ServiceResult<R> andOnSuccess(ExceptionThrowingFunction<? super T, FailingOrSucceedingResult<R, ServiceFailure>> successHandler); @Override ServiceResult<R> andOnSuccess(Supplier<? extends FailingOrSucceedingResult<R, ServiceFailure>> successHandler); @Override ServiceResult<R> andOnSuccessReturn(Supplier<R> successHandler); @Override ServiceResult<T> andOnSuccess(Runnable successHandler); @Override ServiceResult<T> andOnSuccessDo(Consumer<T> successHandler); @Override ServiceResult<R> andOnFailure(Supplier<FailingOrSucceedingResult<R, ServiceFailure>> failureHandler); @Override ServiceResult<R> andOnFailure(Consumer<ServiceFailure> failureHandler); @Override ServiceResult<R> andOnFailure(Runnable failureHandler); @Override ServiceResult<Void> andOnSuccessReturnVoid(Runnable successHandler); ServiceResult<Void> andOnSuccessReturnVoid(); ServiceResult<Void> andOnSuccessReturnVoid(Consumer<? super T> successHandler); @Override ServiceResult<R> andOnSuccessReturn(ExceptionThrowingFunction<? super T, R> successHandler); @Override ServiceResult<T> handleSuccessOrFailureNoReturn(ExceptionThrowingConsumer<? super ServiceFailure> failureHandler, ExceptionThrowingConsumer<? super T> successHandler); @Override T findAndThrowException(ServiceFailure serviceFailure); ServiceResult<Optional<T>> toOptionalIfNotFound(); RestResult<T> toGetResponse(); RestResult<T> toPostCreateResponse(); RestResult<Void> toPostResponse(); RestResult<T> toPostWithBodyResponse(); RestResult<Void> toPutResponse(); @Deprecated RestResult<T> toPutWithBodyResponse(); RestResult<Void> toDeleteResponse(); @Override boolean equals(Object o); @Override int hashCode(); static ServiceResult<Void> serviceSuccess(); static ServiceResult<T> serviceSuccess(T successfulResult); static ServiceResult<T> serviceFailure(ServiceFailure failure); static ServiceResult<T> serviceFailure(Error error); static ServiceResult<T> serviceFailure(ErrorTemplate errorTemplate); static ServiceResult<T> serviceFailure(List<Error> errors); static ServiceResult<T> getNonNullValue(T value, Error error); @SafeVarargs static ServiceResult<Void> processAnyFailuresOrSucceed(ServiceResult<T>... results); static ServiceResult<Void> processAnyFailuresOrSucceed(List<ServiceResult<T>> results); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, ServiceResult<T> successResponse); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, ServiceResult<T> failureResponse, ServiceResult<T> successResponse); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, Function<List<ServiceResult<R>>, ServiceResult<T>> failureResponseFn, ServiceResult<T> successResponse); static ServiceResult<T> handlingErrors(Supplier<ServiceResult<T>> serviceCode); static ServiceResult<T> handlingErrors(ErrorTemplate catchAllErrorTemplate, Supplier<ServiceResult<T>> serviceCode); static ServiceResult<T> handlingErrors(Error catchAllError, Supplier<ServiceResult<T>> serviceCode); static ServiceResult<List<T>> aggregate(final List<ServiceResult<T>> input); static ServiceResult<List<T>> aggregate(final ServiceResult<T>... inputs); static ServiceResult<Map<K, List<V>>> aggregateMap(Map<K, List<ServiceResult<V>>> mapWithServiceResultLists); static HttpStatus findStatusCode(List<ServiceResult<T>> failures); } | @Test public void testAggregateSuccess() { final List<ServiceResult<String>> list = asList("1", "2", "3").stream().map(ServiceResult::serviceSuccess).collect(toList()); final ServiceResult<List<String>> serviceResult = aggregate(list); assertTrue(serviceResult.isSuccess()); assertFalse(serviceResult.getSuccess().isEmpty()); assertEquals(asList("1", "2", "3"), serviceResult.getSuccess()); }
@Test public void testEmptyList() { final List<ServiceResult<String>> empty = new ArrayList(); final ServiceResult<List<String>> serviceResult = aggregate(empty); assertTrue(serviceResult.isSuccess()); assertNotNull(serviceResult.getSuccess()); assertTrue(serviceResult.getSuccess().isEmpty()); } |
ServiceResult extends BaseFailingOrSucceedingResult<T, ServiceFailure> implements Serializable { @SafeVarargs public static <T> ServiceResult<Void> processAnyFailuresOrSucceed(ServiceResult<T>... results) { return processAnyFailuresOrSucceed(asList(results)); } private ServiceResult(Either<ServiceFailure, T> result); @Override ServiceResult<R> andOnSuccess(ExceptionThrowingFunction<? super T, FailingOrSucceedingResult<R, ServiceFailure>> successHandler); @Override ServiceResult<R> andOnSuccess(Supplier<? extends FailingOrSucceedingResult<R, ServiceFailure>> successHandler); @Override ServiceResult<R> andOnSuccessReturn(Supplier<R> successHandler); @Override ServiceResult<T> andOnSuccess(Runnable successHandler); @Override ServiceResult<T> andOnSuccessDo(Consumer<T> successHandler); @Override ServiceResult<R> andOnFailure(Supplier<FailingOrSucceedingResult<R, ServiceFailure>> failureHandler); @Override ServiceResult<R> andOnFailure(Consumer<ServiceFailure> failureHandler); @Override ServiceResult<R> andOnFailure(Runnable failureHandler); @Override ServiceResult<Void> andOnSuccessReturnVoid(Runnable successHandler); ServiceResult<Void> andOnSuccessReturnVoid(); ServiceResult<Void> andOnSuccessReturnVoid(Consumer<? super T> successHandler); @Override ServiceResult<R> andOnSuccessReturn(ExceptionThrowingFunction<? super T, R> successHandler); @Override ServiceResult<T> handleSuccessOrFailureNoReturn(ExceptionThrowingConsumer<? super ServiceFailure> failureHandler, ExceptionThrowingConsumer<? super T> successHandler); @Override T findAndThrowException(ServiceFailure serviceFailure); ServiceResult<Optional<T>> toOptionalIfNotFound(); RestResult<T> toGetResponse(); RestResult<T> toPostCreateResponse(); RestResult<Void> toPostResponse(); RestResult<T> toPostWithBodyResponse(); RestResult<Void> toPutResponse(); @Deprecated RestResult<T> toPutWithBodyResponse(); RestResult<Void> toDeleteResponse(); @Override boolean equals(Object o); @Override int hashCode(); static ServiceResult<Void> serviceSuccess(); static ServiceResult<T> serviceSuccess(T successfulResult); static ServiceResult<T> serviceFailure(ServiceFailure failure); static ServiceResult<T> serviceFailure(Error error); static ServiceResult<T> serviceFailure(ErrorTemplate errorTemplate); static ServiceResult<T> serviceFailure(List<Error> errors); static ServiceResult<T> getNonNullValue(T value, Error error); @SafeVarargs static ServiceResult<Void> processAnyFailuresOrSucceed(ServiceResult<T>... results); static ServiceResult<Void> processAnyFailuresOrSucceed(List<ServiceResult<T>> results); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, ServiceResult<T> successResponse); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, ServiceResult<T> failureResponse, ServiceResult<T> successResponse); static ServiceResult<T> processAnyFailuresOrSucceed(List<ServiceResult<R>> results, Function<List<ServiceResult<R>>, ServiceResult<T>> failureResponseFn, ServiceResult<T> successResponse); static ServiceResult<T> handlingErrors(Supplier<ServiceResult<T>> serviceCode); static ServiceResult<T> handlingErrors(ErrorTemplate catchAllErrorTemplate, Supplier<ServiceResult<T>> serviceCode); static ServiceResult<T> handlingErrors(Error catchAllError, Supplier<ServiceResult<T>> serviceCode); static ServiceResult<List<T>> aggregate(final List<ServiceResult<T>> input); static ServiceResult<List<T>> aggregate(final ServiceResult<T>... inputs); static ServiceResult<Map<K, List<V>>> aggregateMap(Map<K, List<ServiceResult<V>>> mapWithServiceResultLists); static HttpStatus findStatusCode(List<ServiceResult<T>> failures); } | @Test public void testProcessAnyFailuresOrSucceed() { List<ServiceResult<Void>> resultsWithErrors = asList(serviceFailure(badRequestError("Error 1")), serviceSuccess(), serviceFailure(asList(internalServerErrorError(), badRequestError("Error 3")))); ServiceResult<String> result = processAnyFailuresOrSucceed(resultsWithErrors, serviceSuccess("Should not see this success")); assertTrue(result.isFailure()); assertTrue(result.getFailure().is(badRequestError("Error 1"), internalServerErrorError(), badRequestError("Error 3"))); } |
DefaultPermissionMethodHandler implements PermissionMethodHandler { @Override public boolean hasPermission(Authentication authentication, Object targetObject, Object permission, Class<?> targetClass) { ListOfOwnerAndMethod securingMethods = lookupAndCacheSecuringMethodsForClassAndPermission(permission, targetClass); for (Pair<Object, Method> methodAndBean : securingMethods) { if (callHasPermissionMethod(methodAndBean, targetObject, authentication)) { return true; } } LOG.warn(detailedAccessDeniedMessage(authentication, targetObject, permission, targetClass)); return false; } DefaultPermissionMethodHandler(PermissionedObjectClassToPermissionsToPermissionsMethods rulesMap); @Override boolean hasPermission(Authentication authentication, Object targetObject, Object permission, Class<?> targetClass); @Override List<String> getPermissions(Authentication authentication, Object targetDomainObject); static boolean isAnonymous(UserResource user); static UserResource getAnonymous(); } | @Test public void testPermissionCheckerRunsThroughAllPermissionMethods() { DefaultPermissionMethodHandler handler = new DefaultPermissionMethodHandler(permissionMethods); when(permissionMethodOwnerMock.readApplicationPermissionMethod1(application, authentication.getDetails())).thenReturn(false); when(permissionMethodOwnerMock.readApplicationPermissionMethod2(application, authentication.getDetails())).thenReturn(false); when(permissionMethodOwnerMock.readApplicationPermissionMethod3(application, authentication.getDetails())).thenReturn(false); assertFalse(handler.hasPermission(authentication, application, "READ", ApplicationResource.class)); verify(permissionMethodOwnerMock).readApplicationPermissionMethod1(application, authentication.getDetails()); verify(permissionMethodOwnerMock).readApplicationPermissionMethod2(application, authentication.getDetails()); verify(permissionMethodOwnerMock).readApplicationPermissionMethod3(application, authentication.getDetails()); }
@Test public void testStopPermissionCheckingAfterFirstMethodThatReturnsTrue() { DefaultPermissionMethodHandler handler = new DefaultPermissionMethodHandler(permissionMethods); when(permissionMethodOwnerMock.readApplicationPermissionMethod1(application, authentication.getDetails())).thenReturn(false); when(permissionMethodOwnerMock.readApplicationPermissionMethod2(application, authentication.getDetails())).thenReturn(true); assertTrue(handler.hasPermission(authentication, application, "READ", ApplicationResource.class)); verify(permissionMethodOwnerMock).readApplicationPermissionMethod1(application, authentication.getDetails()); verify(permissionMethodOwnerMock).readApplicationPermissionMethod2(application, authentication.getDetails()); verify(permissionMethodOwnerMock, never()).readApplicationPermissionMethod3(application, authentication.getDetails()); } |
PrioritySorting { public List<T> unwrap() { return sortedList; } <E extends Comparable<? super E>> PrioritySorting(List<T> list, T priority, Function<T, E> field); List<T> unwrap(); } | @Test public void sortingEmptyListReturnsEmptyList() { List<String> list = new PrioritySorting<>(new ArrayList<String>(), "exceptionElement", Function.identity()).unwrap(); assertTrue(list.isEmpty()); }
@Test public void sortingListWorksAsExpectedWithIdentity() { List<String> list = new PrioritySorting<>(asList("C", "A", "exceptionElement"), "exceptionElement", Function.identity()).unwrap(); assertEquals(3, list.size()); assertEquals(list, asList("exceptionElement", "A", "C")); }
@Test public void sortingListWorksAsExpectedWithFunction() { List<TestResource> orgs = createResources("C", "A", "exceptionElement"); List<TestResource> list = new PrioritySorting<>(orgs, createResource("exceptionElement"), TestResource::getName).unwrap(); assertEquals(3, list.size()); Assert.assertEquals(CollectionFunctions.simpleMap(list, TestResource::getName), CollectionFunctions.simpleMap(createResources("exceptionElement", "A", "C"), TestResource::getName)); }
@Test public void sortingListWithoutPriorityStillSortsElementsByField() { List<TestResource> orgs = createResources("C", "A", "exceptionElement"); List<TestResource> list = new PrioritySorting<>(orgs, null, TestResource::getName).unwrap(); assertEquals(3, list.size()); Assert.assertEquals(CollectionFunctions.simpleMap(list, TestResource::getName), CollectionFunctions.simpleMap(createResources("A", "C", "exceptionElement"), TestResource::getName)); } |
OrganisationPatternMatcher { @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) public boolean organisationTypeIsResearch(Organisation organisation) { try { return OrganisationTypeEnum.isResearch(organisation.getOrganisationType().getId()); } catch(NullPointerException e) { LOG.trace("NPE when checking organisation type is research", e); return false; } } @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeMatches(Organisation organisation, OrganisationResource organisationResource); @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeIsResearch(Organisation organisation); } | @Test public void organisationTypeIsResearch() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.RESEARCH).build(); boolean result = service.organisationTypeIsResearch(organisation); assertTrue(result); }
@Test public void organisationTypeIsResearch_noMatchIfTypeIsNotResearch() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.BUSINESS).build(); boolean result = service.organisationTypeIsResearch(organisation); assertFalse(result); }
@Test public void organisationTypeIsResearch_noMatchIfTypeIsMissing() throws Exception { Organisation organisation = newOrganisation().build(); boolean result = service.organisationTypeIsResearch(organisation); assertFalse(result); } |
StringFunctions { public static int countWords(String content) { return ofNullable(stripToNull(stripHtml(content))).map(contentValue -> contentValue.split("\\s+").length).orElse(0); } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); } | @Test public void countWords() throws Exception { assertEquals(15, StringFunctions.countWords(join(" ", nCopies(15, "content")))); }
@Test public void countWords_valueWithHtml() throws Exception { assertEquals(15, StringFunctions.countWords("<td><p style=\"font-variant: small-caps\">This value is made up of fifteen words even though it is wrapped within HTML.</p></td>")); }
@Test public void countWords_noContent() throws Exception { assertEquals(0, StringFunctions.countWords(null)); }
@Test public void countWords_emptyContent() throws Exception { assertEquals(0, StringFunctions.countWords("")); } |
StringFunctions { public static String stripHtml(String content) { return ofNullable(content).map(contentValue -> { String cleaned = Jsoup.clean(content, "", Whitelist.none(), new Document.OutputSettings().prettyPrint(false)); return cleaned.trim().replaceAll("[ \t]+", " "); } ).orElse(null); } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); } | @Test public void stripHtml() throws Exception { assertEquals("This value is made up of: a table cell a paragraph and a list.", StringFunctions.stripHtml( "<tr>" + " <td>" + " <p style=\"font-variant: small-caps\">This value is made up of:</p>" + " </td>" + " <td>" + " <ul>" + " <li>a table cell</li>" + " <li>a paragraph</li>" + " <li>and a list.</li>" + " </ul>" + " </td>" + "</tr>")); }
@Test public void stripHtml_noHtml() throws Exception { String content = "This value does not contain HTML markup.\n It should remain untouched."; assertEquals(content, StringFunctions.stripHtml(content)); }
@Test public void stripHtml_noContent() throws Exception { assertNull(StringFunctions.stripHtml(null)); }
@Test public void stripHtml_emptyContent() throws Exception { assertEquals("", StringFunctions.stripHtml("")); } |
StringFunctions { public static String plainTextToHtml(String content) { String escaped = StringEscapeUtils.escapeHtml4(content); if (escaped != null) { return escaped.replaceAll("\\R", "<br/>"); } return escaped; } private StringFunctions(); static int countWords(String content); static String stripHtml(String content); static String plainTextToHtml(String content); } | @Test public void plainTextToHtml() throws Exception { assertEquals("This text is split<br/>over several<br/>lines.<br/><br/>It contains characters < > & " which need escaping.", StringFunctions.plainTextToHtml("This text is split\nover several\nlines.\n\nIt contains characters < > & \" which need escaping.")); }
@Test public void plainTextToHtml_newlines() throws Exception { String content = "Line 1\nLine 2\fLine 3\r\nLine 4\rLine 5"; assertEquals("Line 1<br/>Line 2<br/>Line 3<br/>Line 4<br/>Line 5", StringFunctions.plainTextToHtml(content)); }
@Test public void plainTextToHtml_noContent() throws Exception { assertNull(StringFunctions.plainTextToHtml(null)); }
@Test public void plainTextToHtml_emptyContent() throws Exception { assertEquals("", StringFunctions.plainTextToHtml("")); } |
CollectionFunctions { public static <T, R, S> Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn) { Map<S, List<Entry<T, R>>> intermediate = map.entrySet().stream().collect(groupingBy(e -> filterFn.apply(e.getKey()))); return simpleMapKeyAndValue(intermediate, identity(), value -> simpleToMap(value, Entry::getKey, Entry::getValue)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleGroupBy() { Map<String, String> map = new HashMap<>(); map.put("formInput[1].MMYYYY.year", "2001"); map.put("formInput[1].MMYYYY.month", "11"); map.put("formInput[2].MMYYYY.year", "1968"); map.put("formInput[2].MMYYYY.month", "2"); map.put("formInput[3].MMYYYY.year", "2001"); map.put("formInput[3].MMYYYY.month", "11"); Map<String, Map<String, String>> simpleGroupBy = CollectionFunctions.simpleGroupBy(map, key -> key.replace(".MMYYYY.month", "").replace(".MMYYYY.year", "")); assertEquals(3, simpleGroupBy.size()); assertNotNull(simpleGroupBy.get("formInput[1]")); assertEquals("2001", simpleGroupBy.get("formInput[1]").get("formInput[1].MMYYYY.year")); assertEquals("11", simpleGroupBy.get("formInput[1]").get("formInput[1].MMYYYY.month")); assertNotNull(simpleGroupBy.get("formInput[2]")); assertEquals("1968", simpleGroupBy.get("formInput[2]").get("formInput[2].MMYYYY.year")); assertEquals("2", simpleGroupBy.get("formInput[2]").get("formInput[2].MMYYYY.month")); assertNotNull(simpleGroupBy.get("formInput[3]")); assertEquals("2001", simpleGroupBy.get("formInput[3]").get("formInput[3].MMYYYY.year")); assertEquals("11", simpleGroupBy.get("formInput[3]").get("formInput[3].MMYYYY.month")); }
@Test public void simpleGroupByNull() { Map<String, String> map = new HashMap<>(); map.put("formInput[1].MMYYYY.year", null); map.put("formInput[1].MMYYYY.month", null); Map<String, Map<String, String>> simpleGroupBy = CollectionFunctions.simpleGroupBy(map, key -> key.replace(".MMYYYY.month", "").replace(".MMYYYY.year", "")); assertEquals(1, simpleGroupBy.size()); assertNotNull(simpleGroupBy.get("formInput[1]")); assertNull(simpleGroupBy.get("formInput[1]").get("formInput[1].MMYYYY.year")); assertNull(simpleGroupBy.get("formInput[1]").get("formInput[1].MMYYYY.month")); } |
CollectionFunctions { public static <T> List<T> flattenLists(Collection<? extends Collection<T>> toFlatten){ return flattenLists(toFlatten, Function.identity()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void flattenLists() { List<List<Integer>> deepList = asList(asList(1, 2, 3), asList(4, 5), singletonList(6)); List<Integer> expectedFlatList = asList(1, 2, 3, 4, 5, 6); assertEquals(expectedFlatList, CollectionFunctions.flattenLists(deepList)); }
@Test public void flattenLists_nullSafe() { List<List<Integer>> deepList = asList(asList(1, 2, 3), null, singletonList(6)); List<Integer> expectedFlatList = asList(1, 2, 3, 6); assertEquals(expectedFlatList, CollectionFunctions.flattenLists(deepList)); }
@Test public void flattenLists_emptyElements() { List<List<Integer>> deepList = asList(asList(1, 2, 3), emptyList(), singletonList(6)); List<Integer> expectedFlatList = asList(1, 2, 3, 6); assertEquals(expectedFlatList, CollectionFunctions.flattenLists(deepList)); }
@Test public void flattenLists_allEmpty() { List<List<Integer>> deepList = asList(emptyList(), emptyList(), emptyList()); List<Integer> expectedFlatList = emptyList(); assertEquals(expectedFlatList, CollectionFunctions.flattenLists(deepList)); } |
CollectionFunctions { public static <T> Set<T> flattenSets(Set<Set<T>> lists) { return lists.stream() .filter(Objects::nonNull) .flatMap(Collection::stream) .collect(toSet()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void flattenSets() { Set<Set<Integer>> deepList = CollectionFunctions.asLinkedSet( CollectionFunctions.asLinkedSet(1, 2, 3), CollectionFunctions.asLinkedSet(4, 5), singleton(6)); Set<Integer> expectedFlatList = CollectionFunctions.asLinkedSet(1, 2, 3, 4, 5, 6); assertEquals(expectedFlatList, CollectionFunctions.flattenSets(deepList)); } |
CollectionFunctions { @SafeVarargs public static <T> List<T> combineLists(List<T>... lists) { return doCombineLists(lists); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void combineLists() { List<Integer> list1 = asList(1, 2, 3); List<Integer> list2 = asList(4, 5); List<Integer> list3 = singletonList(6); List<Integer> expectedCombinedList = asList(1, 2, 3, 4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(list1, list2, list3)); }
@Test public void combineLists_nullSafe() { List<Integer> list1 = null; List<Integer> list2 = asList(4, 5); List<Integer> list3 = singletonList(6); List<Integer> expectedCombinedList = asList(4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(list1, list2, list3)); }
@Test public void combineLists_emptyElements() { List<Integer> list1 = emptyList(); List<Integer> list2 = asList(4, 5); List<Integer> list3 = singletonList(6); List<Integer> expectedCombinedList = asList(4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(list1, list2, list3)); }
@Test public void combineListsWithListAndVarargs() { List<Integer> list = asList(1, 2, 3); List<Integer> expectedCombinedList = asList(1, 2, 3, 4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(list, 4, 5, 6)); }
@Test public void combineListsWithListAndVarargsNullSafe() { List<Integer> expectedCombinedList = asList(4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(null, 4, 5, 6)); }
@Test public void combineListsWithElementAndVarargs() { List<Integer> expectedCombinedList = asList(1, 2, 3, 4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(1, 2, 3, 4, 5, 6)); }
@Test public void combineListsWithElementAndVarargsEmptyVarargs() { List<Integer> expectedCombinedList = singletonList(1); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(1)); }
@Test public void combineListsWithElementAndVarargsNullElementSafe() { List<Integer> expectedCombinedList = asList(2, 3, 4, 5, 6); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(null, 2, 3, 4, 5, 6)); }
@Test public void combineListsWithElementAndList() { List<Integer> list = asList(1, 2, 3); List<Integer> expectedCombinedList = asList(0, 1, 2, 3); assertEquals(expectedCombinedList, CollectionFunctions.combineLists(0, list)); } |
CollectionFunctions { public static <T> void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer) { forEachConsumer(consumer).accept(list); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void forEachWithIndex() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = asList("string 1", "string 2", "string 3"); CollectionFunctions.forEachWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); valuesSeen.add(value); }); assertEquals(asList(0, 1, 2), indicesSeen); assertEquals(asList("string 1", "string 2", "string 3"), valuesSeen); }
@Test public void forEachWithIndex_nullSafe() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = asList("string 1", null, "string 3"); CollectionFunctions.forEachWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); valuesSeen.add(value); }); assertEquals(asList(0, 1, 2), indicesSeen); assertEquals(asList("string 1", null, "string 3"), valuesSeen); }
@Test public void forEachWithIndex_emptyValues() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = emptyList(); CollectionFunctions.forEachWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); valuesSeen.add(value); }); assertEquals(emptyList(), indicesSeen); assertEquals(emptyList(), valuesSeen); } |
OrganisationPatternMatcher { @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) public boolean organisationTypeMatches(Organisation organisation, OrganisationResource organisationResource) { try { return organisation.getOrganisationType().getId().equals(organisationResource.getOrganisationType()); } catch(NullPointerException e) { LOG.trace("NPE when checking organisation type match", e); return false; } } @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeMatches(Organisation organisation, OrganisationResource organisationResource); @NotSecured(value = "Is a 'static' comparison function", mustBeSecuredByOtherServices = false) boolean organisationTypeIsResearch(Organisation organisation); } | @Test public void organisationTypeMatches() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.BUSINESS).build(); OrganisationResource organisationResource = newOrganisationResource().withOrganisationType(OrganisationTypeEnum.BUSINESS.getId()).build(); boolean result = service.organisationTypeMatches(organisation, organisationResource); assertTrue(result); }
@Test public void organisationTypeMatches_noMatchWhenTypesDiffer() throws Exception { Organisation organisation = newOrganisation().withOrganisationType(OrganisationTypeEnum.RTO).build(); OrganisationResource organisationResource = newOrganisationResource().withOrganisationType(OrganisationTypeEnum.BUSINESS.getId()).build(); boolean result = service.organisationTypeMatches(organisation, organisationResource); assertFalse(result); }
@Test public void organisationTypeMatches_noMatchWhenOrganisationMissesType() throws Exception { Organisation organisation = newOrganisation().build(); OrganisationResource organisationResource = newOrganisationResource().withOrganisationType(OrganisationTypeEnum.BUSINESS.getId()).build(); boolean result = service.organisationTypeMatches(organisation, organisationResource); assertFalse(result); }
@Test public void organisationTypeMatches_noMatchWhenOrganisationResourceIsNull() throws Exception { Organisation organisation = newOrganisation().build(); OrganisationResource organisationResource = null; boolean result = service.organisationTypeMatches(organisation, organisationResource); assertFalse(result); } |
CollectionFunctions { public static <T, R> List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function) { return forEachFunction(function).apply(list); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void mapWithIndex() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = asList("string 1", "string 2", "string 3"); List<String> newStrings = CollectionFunctions.mapWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); return value + " changed"; }); assertEquals(asList(0, 1, 2), indicesSeen); assertEquals(asList("string 1 changed", "string 2 changed", "string 3 changed"), newStrings); }
@Test public void mapWithIndex_nullSafe() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = asList("string 1", null, "string 3"); List<String> newStrings = CollectionFunctions.mapWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); return value != null ? value + " changed" : null; }); assertEquals(asList(0, 1, 2), indicesSeen); assertEquals(asList("string 1 changed", null, "string 3 changed"), newStrings); }
@Test public void mapWithIndex_emptyElements() { final List<Integer> indicesSeen = new ArrayList<>(); final List<String> valuesToIterateOver = emptyList(); List<String> newStrings = CollectionFunctions.mapWithIndex(valuesToIterateOver, (i, value) -> { indicesSeen.add(i); return value + " changed"; }); assertEquals(emptyList(), indicesSeen); assertEquals(emptyList(), newStrings); } |
CollectionFunctions { public static <T> List<T> reverse(List<T> original) { List<T> reversed = original != null ? new ArrayList<>(original) : new ArrayList<>(); Collections.reverse(reversed); return reversed; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void reverse() { List<String> originalList = asList("string 1", "another string 2", "string 3"); List<String> reversed = CollectionFunctions.reverse(originalList); assertEquals(asList("string 3", "another string 2", "string 1"), reversed); }
@Test public void reverse_nullElements() { List<String> originalList = asList(null, null, "string 3"); List<String> reversed = CollectionFunctions.reverse(originalList); assertEquals(asList("string 3", null, null), reversed); }
@Test public void reverse_nullSafe() { assertEquals(new ArrayList<>(), CollectionFunctions.reverse(null)); }
@Test public void reverse_empty() { assertEquals(new ArrayList<>(), CollectionFunctions.reverse(new ArrayList<>())); } |
CollectionFunctions { public static <T> T getOnlyElement(List<T> list) { if (list == null || list.isEmpty()) { throw new IllegalArgumentException("No elements were available in list " + list + ", so cannot return only element"); } if (list.size() > 1) { throw new IllegalArgumentException("More than one element was available in list " + list + ", so cannot return only element"); } return list.get(0); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void getOnlyElement() { assertEquals("hi there", CollectionFunctions.getOnlyElement(singletonList("hi there"))); }
@Test public void nullElement() { List<Object> nullElementList = new ArrayList<>(); nullElementList.add(null); assertNull(CollectionFunctions.getOnlyElement(nullElementList)); }
@Test public void getOnlyElement_tooManyElements() { try { CollectionFunctions.getOnlyElement(asList("hi there", "goodbye!")); fail("Should have thrown an IllegalArgumentException as there were too many elements"); } catch (IllegalArgumentException e) { } }
@Test public void getOnlyElement_notEnoughElements() { try { CollectionFunctions.getOnlyElement(emptyList()); fail("Should have thrown an IllegalArgumentException as there weren't enough elements"); } catch (IllegalArgumentException e) { } }
@Test public void getOnlyElement_notEnoughElements_nullList() { try { CollectionFunctions.getOnlyElement(null); fail("Should have thrown an IllegalArgumentException as there weren't enough elements (null list)"); } catch (IllegalArgumentException e) { } } |
CollectionFunctions { public static <S, T, R> List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn) { return simpleMap(map.entrySet(), entry -> mappingFn.apply(entry.getKey(), entry.getValue())); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMap() { assertEquals(asList("123 string", "456 string"), CollectionFunctions.simpleMap(asList(123, 456), i -> i + " string")); }
@Test public void simpleMap_nullList() { assertEquals(emptyList(), CollectionFunctions.simpleMap((List<?>) null, i -> i + " string")); }
@Test public void simpleMap_nullElements() { assertEquals(asList("123 string", "null string"), CollectionFunctions.simpleMap(asList(123, null), i -> i + " string")); }
@Test public void simpleMap_withArray() { assertEquals(asList("123 string", "456 string"), CollectionFunctions.simpleMap(new Integer[]{123, 456}, i -> i + " string")); }
@Test public void simpleMap_withMap() { Map<Integer, String> map = new HashMap<>(); map.put(1, "a"); map.put(2, "b"); assertEquals(asList("1a", "2b"), CollectionFunctions.simpleMap(map, (key, value) -> key + value)); } |
CollectionFunctions { public static <S, T, R> Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn) { return simpleMapKeyAndValue(map, mappingFn, value -> value); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapKey() { Map<Integer, String> map = new HashMap<>(); map.put(1, "a"); map.put(2, "b"); Map<Integer, String> expected = new HashMap<>(); expected.put(2, "a"); expected.put(4, "b"); assertEquals(expected, CollectionFunctions.simpleMapKey(map, key -> key * 2)); } |
CollectionFunctions { public static <S, T, R> Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn) { return simpleMapKeyAndValue(map, key -> key, mappingFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapValue() { Map<Integer, String> map = new HashMap<>(); map.put(1, "a"); map.put(2, "b"); Map<Integer, String> expected = new HashMap<>(); expected.put(1, "a!"); expected.put(2, "b!"); assertEquals(expected, CollectionFunctions.simpleMapValue(map, value -> value + "!")); } |
CollectionFunctions { public static <S, T, R, U> Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping) { return map.entrySet().stream().collect(toMap(keyMapping, valueMapping)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapEntry() { Map<Integer, String> map = new HashMap<>(); map.put(1, "a"); map.put(2, "b"); Map<String, String> expected = new HashMap<>(); expected.put("2a!", "4a?"); expected.put("4b!", "8b?"); assertEquals(expected, CollectionFunctions.simpleMapEntry(map, entry -> entry.getKey() * 2 + entry.getValue() + "!", entry -> entry.getKey() * 4 + entry.getValue() + "?")); } |
CollectionFunctions { public static <T, R> List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn) { return simpleMapWithIndex(asList(list), mappingFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapWithIndex() { assertEquals(asList("123 string 0", "456 string 1"), CollectionFunctions.simpleMapWithIndex(asList(123, 456), (element, index) -> element + " string " + index)); }
@Test public void simpleMapWithIndex_emptyList() { assertEquals(emptyList(), CollectionFunctions.simpleMapWithIndex(emptyList(), (element, index) -> element + " string " + index)); }
@Test public void simpleMapWithIndex_withArray() { assertEquals(asList("123 string 0", "456 string 1"), CollectionFunctions.simpleMapWithIndex(new Integer[]{123, 456}, (element, index) -> element + " string " + index)); } |
CollectionFunctions { @SuppressWarnings("unchecked") public static <T, R> R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz) { if (array == null || array.length == 0){ return (R[]) Array.newInstance(clazz, 0); } else { R[] result = (R[]) Array.newInstance(clazz, array.length); for (int index = 0; index < array.length; index++){ result[index] = mappingFn.apply(array[index]); } return result; } } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapArray() { assertEquals(new String[]{"123 string", "456 string"}, CollectionFunctions.simpleMapArray(new Integer[]{123, 456}, element -> element + " string", String.class)); }
@Test public void simpleMapArray_nullArray() { assertEquals(new String[]{}, CollectionFunctions.simpleMapArray(null, element -> element + " string ", String.class)); }
@Test public void simpleMapArray_emptyArray() { assertEquals(new String[]{}, CollectionFunctions.simpleMapArray(new String[]{}, element -> element + " string ", String.class)); } |
CollectionFunctions { public static <T, R> Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn) { if (null == list || list.isEmpty()) { return emptySet(); } return list.stream().map(mappingFn).collect(toSet()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleMapSet() { assertEquals(CollectionFunctions.asLinkedSet("123 string", "456 string"), CollectionFunctions.simpleMapSet(CollectionFunctions.asLinkedSet(123, 456), i -> i + " string")); }
@Test public void simpleMapSet_null() { assertEquals(emptySet(), CollectionFunctions.simpleMapSet((Set<?>) null, i -> i + " string")); }
@Test public void simpleMapSet_withEmptyList() { assertEquals(emptySet(), CollectionFunctions.simpleMapSet(emptyList(), i -> i + " string")); }
@Test public void simpleMapSet_withEmptyArray() { assertEquals(emptySet(), CollectionFunctions.simpleMapSet(new Integer[]{}, i -> i + " string")); }
@Test public void simpleMapSet_fromArray() { String[] strings = {"a", "b", "c", "c"}; Set<String> expected = newHashSet(asList("A", "B", "C")); Set<String> actual = CollectionFunctions.simpleMapSet(strings, String::toUpperCase); assertEquals(expected, actual); } |
CollectionFunctions { public static <T, R> LinkedHashSet<R> simpleToLinkedHashSet(T[] array, Function<T, R> mappingFn) { if (array == null) { return new LinkedHashSet<>(); } return simpleToLinkedHashSet(asList(array), mappingFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleToLinkedHashSetWithCollection() { assertEquals(new LinkedHashSet<>(asList("123 string", "456 string")), CollectionFunctions.simpleToLinkedHashSet(asList(123, 456), i -> i + " string")); }
@Test public void simpleToLinkedHashSetWithCollection_nullList() { assertEquals(new LinkedHashSet<String>(), CollectionFunctions.simpleToLinkedHashSet((List<?>) null, i -> i + " string")); }
@Test public void arrayToLinkedHashSetWithCollection_nullElements() { assertEquals(new LinkedHashSet<>(asList("123 string", "null string")), CollectionFunctions.simpleToLinkedHashSet(asList(123, null), i -> i + " string")); }
@Test public void toLinkedHashSetWithArray() { assertEquals(new LinkedHashSet<>(asList("123 string", "456 string")), CollectionFunctions.simpleToLinkedHashSet(new Integer[]{123, 456}, i -> i + " string")); }
@Test public void arrayToLinkedHashSetWithArray_nullArray() { String[] stringArray = null; assertEquals(new LinkedHashSet<String>(), CollectionFunctions.simpleToLinkedHashSet(stringArray, i -> i + " string")); }
@Test public void simpleToLinkedHashSetWithArray_nullElements() { assertEquals(new LinkedHashSet<>(asList("123 string", "null string")), CollectionFunctions.simpleToLinkedHashSet(new Integer[]{123, null}, i -> i + " string")); } |
CollectionFunctions { public static <T, R> Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn) { return simpleFilter(map, (k, v) -> filterFn.test(k)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleFilter() { assertEquals(singletonList(789), CollectionFunctions.simpleFilter(asList(123, 456, 789), i -> i > 456)); }
@Test public void simpleFilter_nullList() { assertEquals(emptyList(), CollectionFunctions.simpleFilter((Collection<?>) null, i -> false)); }
@Test public void simpleFilter_nullElements() { assertEquals(singletonList(789), CollectionFunctions.simpleFilter(asList(123, null, 456, 789), i -> i != null && i > 456)); }
@Test public void simpleFilter_withArray() { assertEquals(singletonList(789), CollectionFunctions.simpleFilter(new Integer[]{123, 456, 789}, i -> i > 456)); }
@Test public void simpleFilter_withEmptyArray() { assertEquals(emptyList(), CollectionFunctions.simpleFilter((Integer[]) null, i -> i > 456)); }
@Test public void simpleFilter_withMap() { Map<Integer, String> map = new LinkedHashMap<>(); map.put(1, "1"); map.put(2, "2"); map.put(3, "3"); map.put(4, "4"); Map<Integer, String> filtered = CollectionFunctions.simpleFilter(map, key -> key < 3); Map<Integer, String> expectedFilteredMap = new LinkedHashMap<>(); expectedFilteredMap.put(1, "1"); expectedFilteredMap.put(2, "2"); assertEquals(expectedFilteredMap, filtered); }
@Test public void simpleFilter_withMap_biPredicate() { Map<Integer, String> map = new LinkedHashMap<>(); map.put(1, "1"); map.put(2, "2"); map.put(3, "3"); map.put(4, "4"); Map<Integer, String> filtered = CollectionFunctions.simpleFilter(map, (key, value) -> key < 3); Map<Integer, String> expectedFilteredMap = new LinkedHashMap<>(); expectedFilteredMap.put(1, "1"); expectedFilteredMap.put(2, "2"); assertEquals(expectedFilteredMap, filtered); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") public boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user) { return isSystemRegistrationUser(user) && !organisationLinkedToAnApplication(organisation); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void systemRegistrationUserCanViewAnOrganisationThatIsNotYetLinkedToAnApplication() { when(processRoleRepository.existsByOrganisationId(anyLong())).thenReturn(false); allGlobalRoleUsers.forEach(user -> { if (user.equals(systemRegistrationUser())) { assertTrue(rules.systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(newOrganisationResource().build(), user)); } else { assertFalse(rules.systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { public static <T, R> Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn) { return simpleFilter(map, filterFn.negate()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleFilterNot() { assertEquals(asList(123, 456), CollectionFunctions.simpleFilterNot(asList(123, 456, 789), i -> i > 456)); }
@Test public void simpleFilterNot_nullList() { assertEquals(emptyList(), CollectionFunctions.simpleFilterNot((List<?>) null, i -> false)); }
@Test public void simpleFilterNot_nullElements() { assertEquals(asList(123, null, 456), CollectionFunctions.simpleFilterNot(asList(123, null, 456, 789), i -> i != null && i > 456)); }
@Test public void simpleFilterNot_withMap() { Map<Integer, String> map = new LinkedHashMap<>(); map.put(1, "1"); map.put(2, "2"); map.put(3, "3"); map.put(4, "4"); Map<Integer, String> filtered = CollectionFunctions.simpleFilterNot(map, key -> key < 3); Map<Integer, String> expectedFilteredMap = new LinkedHashMap<>(); expectedFilteredMap.put(3, "3"); expectedFilteredMap.put(4, "4"); assertEquals(expectedFilteredMap, filtered); } |
CollectionFunctions { public static <T> Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn) { if (list == null || list.isEmpty()) { return empty(); } return list.stream().filter(filterFn).findAny(); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleFindAnyWithNullList() { assertEquals(empty(), CollectionFunctions.simpleFindAny(null, i -> true)); }
@Test public void simpleFindAnyWithNullElements() { assertEquals(Optional.of(789), CollectionFunctions.simpleFindAny(asList(123, null, 455, 789), i -> i != null && i > 456)); }
@Test public void simpleFindAny() { assertEquals(Optional.of(789), CollectionFunctions.simpleFindAny(asList(123, 789, 455, 112), i -> i != null && i > 456)); } |
CollectionFunctions { public static <T, K, U> Collector<T, ?, Map<K, U>> toLinkedMap( Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) { return toMap(keyMapper, valueMapper, (u, v) -> { throw new IllegalStateException(String.format("Duplicate key %s", u)); }, LinkedHashMap::new); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testToLinkedMap() { List<String> orderedList = asList("1", "2", "3", "4", "5"); Map<String, String> orderedMap = orderedList.stream().collect(CollectionFunctions.toLinkedMap(item -> item, item -> item + item)); int index = 0; for (Entry<String, String> entry : orderedMap.entrySet()) { assertEquals(orderedList.get(index), entry.getKey()); assertEquals(orderedList.get(index) + orderedList.get(index), entry.getValue()); index++; } assertEquals(orderedList.size(), index); }
@Test(expected = IllegalStateException.class) public void testToLinkedMapDuplicateEntry() { List<String> orderedList = asList("1", "2", "3", "4", "5", "4"); orderedList.stream().collect(CollectionFunctions.toLinkedMap(item -> item, item -> item + item)); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") public boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user) { return isInternal(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void internalUsersCanViewAnyOrganisation() { allGlobalRoleUsers.forEach(user -> { if (allInternalUsers.contains(user)) { assertTrue(rules.internalUsersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } else { assertFalse(rules.internalUsersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { public static <T> String simpleJoiner(Collection<T> list, String joinString) { if (list == null || list.isEmpty()) { return ""; } return list.stream().map(element -> element != null ? element.toString() : "").collect(joining(joinString)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleJoiner() { assertEquals("123, 456, 789", CollectionFunctions.simpleJoiner(asList(123, 456, 789), ", ")); }
@Test public void simpleJoiner_nullList() { assertEquals("", CollectionFunctions.simpleJoiner(null, ", ")); }
@Test public void simpleJoiner_nullElements() { assertEquals("123, , 789", CollectionFunctions.simpleJoiner(asList(123, null, 789), ", ")); }
@Test public void simpleJoiner_withTransformer() { assertEquals("123!, 456!, 789!", CollectionFunctions.simpleJoiner(asList(123, 456, 789), i -> i + "!", ", ")); }
@Test public void simpleJoiner_withTransformer_nullList() { assertEquals("", CollectionFunctions.simpleJoiner(null, i -> i + "!", ", ")); } |
CollectionFunctions { public static <T, K, U> Map<K, U> simpleToMap( Collection<T> list, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) { if (list == null || list.isEmpty()) { return Collections.emptyMap(); } Map<K,U> map = new HashMap<K,U>(); list.forEach(item -> map.put(keyMapper.apply(item), valueMapper.apply(item))); return map; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testSimpleToMapWithKeyAndValueMappers() { Map<Integer, String> toMap = CollectionFunctions.simpleToMap(asList(1, 2, 3), element -> element + 10, element -> element + " value"); assertEquals(3, toMap.size()); assertTrue(toMap.keySet().contains(11)); assertTrue(toMap.keySet().contains(12)); assertTrue(toMap.keySet().contains(13)); assertEquals("1 value", toMap.get(11)); assertEquals("2 value", toMap.get(12)); assertEquals("3 value", toMap.get(13)); }
@Test public void testSimpleToMapWithKeyAndValueMappersNullSafe() { Map<Integer, Integer> toMap = CollectionFunctions.simpleToMap(null, identity(), identity()); assertTrue(toMap.isEmpty()); }
@Test public void testSimpleToMapWithKeyMapper() { Map<Integer, Integer> toMap = CollectionFunctions.simpleToMap(asList(1, 2, 3), element -> element + 10); assertEquals(3, toMap.size()); assertTrue(toMap.keySet().contains(11)); assertTrue(toMap.keySet().contains(12)); assertTrue(toMap.keySet().contains(13)); assertEquals(Integer.valueOf(1), toMap.get(11)); assertEquals(Integer.valueOf(2), toMap.get(12)); assertEquals(Integer.valueOf(3), toMap.get(13)); }
@Test public void testSimpleToMapWithKeyMapperNullSafe() { Map<Integer, Integer> toMap = CollectionFunctions.simpleToMap(null, identity()); assertTrue(toMap.isEmpty()); } |
CollectionFunctions { public static <T, K, U> Map<K, U> simpleToLinkedMap( List<T> list, Function<? super T, ? extends K> keyMapper, Function<? super T, ? extends U> valueMapper) { if (list == null || list.isEmpty()) { return Collections.emptyMap(); } return list.stream().collect(toMap(keyMapper, valueMapper, throwingMerger(), LinkedHashMap::new)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleToLinkedMapWhenInputListIsNull() { Map<Integer, Integer> toLinkedMap = CollectionFunctions.simpleToLinkedMap(null, identity(), identity()); assertTrue(toLinkedMap.isEmpty()); }
@Test public void simpleToLinkedMapWhenInputListIsEmpty() { Map<Integer, Integer> toLinkedMap = CollectionFunctions.simpleToLinkedMap(emptyList(), identity(), identity()); assertTrue(toLinkedMap.isEmpty()); }
@Test public void simpleToLinkedMap() { List<Integer> inputList = asList(1, 2, 3, 4, 5, 6); Map<Integer, String> toLinkedMap = CollectionFunctions.simpleToLinkedMap(inputList, element -> element + 10, element -> element + " value"); int index = 0; for (Entry<Integer, String> entry : toLinkedMap.entrySet()) { Integer expectedKey = inputList.get(index) + 10; String expectedValue = inputList.get(index) + " value"; assertEquals(expectedKey, entry.getKey()); assertEquals(expectedValue, entry.getValue()); index++; } } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") public boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user) { return isStakeholder(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void stakeholdersCanSeeAllOrganisations() { allGlobalRoleUsers.forEach(user -> { if (user.hasRole(STAKEHOLDER)) { assertTrue(rules.stakeholdersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } else { assertFalse(rules.stakeholdersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { public static <S, T, R, U> Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn) { List<Pair<R, U>> list = simpleMap(map.entrySet(), entry -> Pair.of(keyMappingFn.apply(entry.getKey()), valueMappingFn.apply(entry.getValue()))); return simpleToLinkedMap(list, Pair::getKey, Pair::getValue); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleLinkedMapKeyAndValue() { Map<Integer, String> inputMap = new LinkedHashMap<>(); inputMap.put(1, "Test1"); inputMap.put(2, "Test2"); inputMap.put(3, "Test3"); Map<Integer, String> toLinkedMap = CollectionFunctions.simpleLinkedMapKeyAndValue(inputMap, element -> element + 10, element -> element + " value"); int inputKey = 1; for (Entry<Integer, String> entry : toLinkedMap.entrySet()) { Integer expectedKey = inputKey + 10; String expectedValue = inputMap.get(inputKey) + " value"; assertEquals(expectedKey, entry.getKey()); assertEquals(expectedValue, entry.getValue()); inputKey++; } } |
CollectionFunctions { public static <S, T, R> Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn) { return simpleLinkedMapKeyAndValue(map, mappingFn, value -> value); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleLinkedMapKey() { Map<Integer, String> inputMap = new LinkedHashMap<>(); inputMap.put(1, "Test1"); inputMap.put(2, "Test2"); inputMap.put(3, "Test3"); Map<Integer, String> toLinkedMap = CollectionFunctions.simpleLinkedMapKey(inputMap, element -> element + 10); int inputKey = 1; for (Entry<Integer, String> entry : toLinkedMap.entrySet()) { Integer expectedKey = inputKey + 10; String expectedValue = inputMap.get(inputKey); assertEquals(expectedKey, entry.getKey()); assertEquals(expectedValue, entry.getValue()); inputKey++; } } |
CollectionFunctions { public static <S, T, R> Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn) { return simpleLinkedMapKeyAndValue(map, key -> key, mappingFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleLinkedMapValue() { Map<Integer, String> inputMap = new LinkedHashMap<>(); inputMap.put(1, "Test1"); inputMap.put(2, "Test2"); inputMap.put(3, "Test3"); Map<Integer, String> toLinkedMap = CollectionFunctions.simpleLinkedMapValue(inputMap, element -> element + " value"); int inputKey = 1; for (Entry<Integer, String> entry : toLinkedMap.entrySet()) { Integer expectedKey = inputKey; String expectedValue = inputMap.get(inputKey) + " value"; assertEquals(expectedKey, entry.getKey()); assertEquals(expectedValue, entry.getValue()); inputKey++; } } |
CollectionFunctions { public static <T> List<List<T>> findPermutations(List<T> excludedWords) { List<List<List<T>>> allPermutations = mapWithIndex(excludedWords, (i, currentWord) -> findPermutations(emptyList(), currentWord, removeElement(excludedWords, i))); return flattenLists(allPermutations); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testFindPermutations() { List<List<String>> permutations = CollectionFunctions.findPermutations(asList("a", "b", "c")); assertEquals(3 * 2, permutations.size()); List<List<String>> expectedPermutations = asList( asList("a", "b", "c"), asList("b", "a", "c"), asList("c", "a", "b"), asList("a", "c", "b"), asList("b", "c", "a"), asList("c", "b", "a")); expectedPermutations.forEach(expected -> assertTrue(permutations.contains(expected))); } |
CollectionFunctions { public static <T> List<T> removeElement(List<T> list, int index) { List<T> copy = new ArrayList<>(list); copy.remove(index); return copy; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void removeElement() { List<String> tokens = asList("a", "b", "c"); assertEquals(asList("a", "c"), CollectionFunctions.removeElement(tokens, 1)); assertEquals(asList("a", "b", "c"), tokens); } |
CollectionFunctions { public static <T> List<T> removeDuplicates(Collection<T> list) { if (list == null) { return emptyList(); } return list.stream().distinct().collect(toList()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void removeDuplicates() { List<String> tokens = asList("a", "b", "c", "b", "e", "c"); assertEquals(asList("a", "b", "c", "e"), CollectionFunctions.removeDuplicates(tokens)); assertEquals(asList("a", "b", "c", "b", "e", "c"), tokens); } |
CollectionFunctions { public static <T extends Comparable> List<T> sort(Collection<T> list) { if (list == null || list.isEmpty()) { return emptyList(); } return list.stream().sorted().collect(toList()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void sort() { assertEquals(asList("a", "b", "c"), CollectionFunctions.sort(asList("b", "c", "a"))); }
@Test public void sort_nullSafe() { assertEquals(emptyList(), CollectionFunctions.sort(null)); }
@Test public void sortWithComparator() { assertEquals(asList("c", "b", "a"), CollectionFunctions.sort(asList("b", "c", "a"), Comparator.reverseOrder())); }
@Test public void sortWithComparator_nullSafe() { assertEquals(emptyList(), CollectionFunctions.sort((List<String>) null, Comparator.reverseOrder())); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") public boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user) { return isExternalFinanceUser(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void competitionFinanceUsersCanSeeAllOrganisations() { allGlobalRoleUsers.forEach(user -> { if (user.hasRole(EXTERNAL_FINANCE)) { assertTrue(rules.competitionFinanceUsersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } else { assertFalse(rules.competitionFinanceUsersCanSeeAllOrganisations(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { public static <T> Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test) { if (list == null || list.isEmpty()) { return Pair.of(emptyList(), emptyList()); } Map<Boolean, List<T>> partitioned = list.stream().collect(partitioningBy(test)); return Pair.of(partitioned.get(true), partitioned.get(false)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testSimplePartition() { Pair<List<String>, List<String>> partitioned = CollectionFunctions.simplePartition(asList("a1", "b1", "a2", "c1"), string -> string.startsWith("a")); assertEquals(asList("a1", "a2"), partitioned.getLeft()); assertEquals(asList("b1", "c1"), partitioned.getRight()); }
@Test public void testSimplePartition_NullSafe() { Pair<List<String>, List<String>> partitioned = CollectionFunctions.simplePartition(null, string -> string.startsWith("a")); assertEquals(emptyList(), partitioned.getLeft()); assertEquals(emptyList(), partitioned.getRight()); } |
CollectionFunctions { public static <T, R> boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction){ if (containing == null && contained != null) { return false; } else if (contained == null) { return true; } boolean notContained = contained.stream().anyMatch(containedItem -> containing.stream().noneMatch(containingItem -> equalsFunction.apply(containingItem, containedItem)) ); return !notContained; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testContainsAllEqualsFunction() { List<Pair<Integer, String>> containingList = asList(of(1, "two"), of(2, "pair")); List<String> containedList = asList("two", "pair"); List<String> anotherSmallerContainedList = singletonList("two"); List<String> isNotContainedList = singletonList("not present"); assertTrue(containsAll(containingList, containedList, (s, t) -> Objects.equals(s.getRight(), t))); assertTrue(containsAll(containedList, containingList, (s, t) -> Objects.equals(s, t.getRight()))); assertTrue(containsAll(containingList, anotherSmallerContainedList, (s, t) -> Objects.equals(s.getRight(), t))); assertFalse(containsAll(anotherSmallerContainedList, containingList, (s, t) -> Objects.equals(s, t.getRight()))); assertFalse(containsAll(containingList, isNotContainedList, (s, t) -> Objects.equals(s.getRight(), t))); }
@Test public void testContainsAllEqualsFunction_withNullLists() { assertTrue(containsAll(null, null, (i1, i2) -> i1 == i2)); assertFalse(containsAll(null, asList(1, 2), (i1, i2) -> i1 == i2)); }
@Test public void testContainsAll() { List<Pair<Integer, String>> containingList = asList(of(1, "two"), of(2, "pair")); List<Pair<String, Integer>> containedList = asList(of("two", 8), of("pair", 57)); List<Pair<String, Integer>> isNotContainedList = singletonList(of("not present", 8)); assertTrue(containsAll(containingList, Pair::getRight, containedList, Pair::getLeft)); assertFalse(containsAll(containingList, Pair::getRight, isNotContainedList, Pair::getLeft)); }
@Test public void testContainsAllNull() { List<String> nullList = null; List<String> notNullList = asList("two", "pair"); assertFalse(containsAll(nullList, identity(), notNullList, identity())); assertTrue(containsAll(notNullList, identity(), nullList, identity())); assertTrue(containsAll(nullList, identity(), nullList, identity())); assertTrue(containsAll(notNullList, identity(), notNullList, identity())); }
@Test public void testContainsAllNullEntry() { List<String> listContainingNull = asList(null, "pair"); List<String> listWithJustNull = new ArrayList<>(); listWithJustNull.add(null); assertTrue(containsAll(listContainingNull, identity(), listWithJustNull, identity())); assertTrue(containsAll(listWithJustNull, identity(), listWithJustNull, identity())); } |
CollectionFunctions { public static <R, S, T> SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform) { SortedMap<T, List<R>> orderedMap = new TreeMap<>(); if (orderedList != null) { orderedList.forEach(s -> { if (s != null) { T key = keyTransform.apply(s); R value = valueTransform.apply(s); if (!orderedMap.containsKey(key)) { orderedMap.put(key, new ArrayList<>()); } orderedMap.get(key).add(value); } }); } return orderedMap; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testToSorted() { String firstLabel = "getLabel 1"; String secondLabel = "getLabel 2"; String firstEntry = "1st entry"; String secondEntry = "2nd entry"; String thirdEntry = "3rd entry"; String fourthEntry = "4th entry"; List<Pair<String, String>> sortedList = asList(of(firstLabel, firstEntry), of(firstLabel, secondEntry), of(secondLabel, thirdEntry), of(firstLabel, fourthEntry)); SortedMap<String, List<String>> sortedMap = toSortedMapWithList(sortedList, Pair::getLeft, Pair::getRight); assertEquals(2, sortedMap.size()); assertEquals(firstLabel, sortedMap.firstKey()); assertEquals(sortedMap.get(firstLabel), asList(firstEntry, secondEntry, fourthEntry)); assertEquals(secondLabel, sortedMap.lastKey()); assertEquals(sortedMap.get(secondLabel), singletonList(thirdEntry)); }
@Test public void testToSortedNull() { List<String> nullList = null; SortedMap<String, List<String>> sortedMap = toSortedMapWithList(nullList, identity(), identity()); assertEquals(new TreeMap<String, List<String>>(), sortedMap); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") public boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user) { List<MonitoringOfficer> projectMonitoringOfficers = projectMonitoringOfficerRepository.findByUserId(user.getId()); return getMonitoringOfficersOrganisationIds(projectMonitoringOfficers).contains(organisation.getId()); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void monitoringOfficersCanSeeAllOrganisations() { long organisationId = 1L; Organisation organisation = newOrganisation() .withId(organisationId) .build(); List<PartnerOrganisation> partnerOrganisations = newPartnerOrganisation() .withOrganisation(organisation) .build(1); Project project = newProject() .withPartnerOrganisations(partnerOrganisations) .build(); List<MonitoringOfficer> projectMonitoringOfficers = newMonitoringOfficer() .withProject(project) .build(1); when(projectMonitoringOfficerRepository.findByUserId(monitoringOfficerUser().getId())).thenReturn(projectMonitoringOfficers); allGlobalRoleUsers.forEach(user -> { if (user.hasRole(MONITORING_OFFICER)) { assertTrue(rules.monitoringOfficersCanSeeAllOrganisations(newOrganisationResource().withId(organisationId).build(), monitoringOfficerUser())); } else { assertFalse(rules.monitoringOfficersCanSeeAllOrganisations(newOrganisationResource().withId(organisationId).build(), user)); } }); } |
CollectionFunctions { public static <S, T> T unique(Collection<S> collectionToSearch, Function<S, T> property) { List<T> distinct = collectionToSearch.stream().map(property).distinct().collect(toList()); if (distinct.size() != 1) { throw new IllegalArgumentException("Collection to search:" + collectionToSearch + " does not have a unique property:" + property); } else { return distinct.get(0); } } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void testUnique() { List<String> uniqueList = asList("one", "one", "one"); assertEquals("one", unique(uniqueList, identity())); List<String> notUniqueList = asList("one", "two", "three"); try { unique(notUniqueList, identity()); fail("Should have thrown and IllegalArgumentException"); } catch (IllegalArgumentException e) { } } |
CollectionFunctions { public static <T, S> void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer) { forEachWithIndex(list1, (i, item1) -> consumer.accept(item1, list2.get(i))); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void zip() { List<String> list1 = asList("a", "b", "c"); List<Integer> list2 = asList(1, 2, 3); List<String> results = new ArrayList<>(); CollectionFunctions.zip(list1, list2, (string, integer) -> results.add(string + integer)); assertEquals(asList("a1", "b2", "c3"), results); }
@Test public void zipTriple() { List<Integer> list1 = asList(1, 2, 3); List<String> list2 = asList("4", "5", "6"); List<Boolean> list3 = asList(true, false, true); List<String> results = new ArrayList<>(); CollectionFunctions.zip(list1, list2, list3, (o1, o2, o3) -> results.add(o1 + o2 + o3)); assertEquals(asList("14true", "25false", "36true"), results); } |
CollectionFunctions { public static <T, S> void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer) { forEachWithIndex(list1, (i, item1) -> consumer.accept(item1, list2.get(i), i)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void zipWithIndex() { List<String> list1 = asList("a", "b", "c"); List<Integer> list2 = asList(1, 2, 3); List<String> results = new ArrayList<>(); CollectionFunctions.zipWithIndex(list1, list2, (string, integer, index) -> results.add(string + integer + "" + index)); assertEquals(asList("a10", "b21", "c32"), results); } |
CollectionFunctions { public static <T, R, S> List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction) { return zipAndMapWithIndex(list1, list2, (o1, o2, i) -> biFunction.apply(o1, o2)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void zipAndMap() { List<String> list1 = asList("a", "b", "c"); List<Integer> list2 = asList(1, 2, 3); List<String> results = CollectionFunctions.zipAndMap(list1, list2, (string, integer) -> string + integer); assertEquals(asList("a1", "b2", "c3"), results); } |
CollectionFunctions { public static <T, R, S> List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction) { List<R> resultList = new ArrayList<>(); zipWithIndex(list1, list2, (o1, o2, index) -> resultList.add(triFunction.apply(o1, o2, index))); return resultList; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void zipAndMapWithIndex() { List<String> list1 = asList("a", "b", "c"); List<Integer> list2 = asList(1, 2, 3); List<String> results = CollectionFunctions.zipAndMapWithIndex(list1, list2, (string, integer, index) -> string + integer + "" + index); assertEquals(asList("a10", "b21", "c32"), results); } |
OrganisationPermissionRules { @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") public boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user) { return isProjectFinanceUser(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void projectFinanceUserCanUpdateAllOrganisations() { allGlobalRoleUsers.forEach(user -> { if (user.equals(projectFinanceUser())) { assertTrue(rules.projectFinanceUserCanUpdateAnyOrganisation(newOrganisationResource().build(), user)); } else { assertFalse(rules.projectFinanceUserCanUpdateAnyOrganisation(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { @SafeVarargs public static <T> Predicate<T> and(Predicate<? super T>... predicates){ return t -> { for (Predicate<? super T> predicate : predicates){ if (!predicate.test(t)){ return false; } } return true; }; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void and() { List<Integer> list = asList(1, 2, 3, 4, 5, 6, 7, 8); Predicate<Integer> compoundPredicate = CollectionFunctions.and( i -> i > 3, i -> (i % 2) == 0); List<Integer> filtered = CollectionFunctions.simpleFilter(list, compoundPredicate); assertEquals(asList(4, 6, 8), filtered); } |
CollectionFunctions { public static <T> Optional<T> getOnlyElementOrEmpty(List<T> list) { if (list == null || list.isEmpty()) { return empty(); } if (list.size() > 1) { throw new IllegalArgumentException("More than one element was available in list " + list + ", so cannot return only element"); } return Optional.of(list.get(0)); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void getOnlyElementOrEmpty() { assertEquals(Optional.of(1), CollectionFunctions.getOnlyElementOrEmpty(singletonList(1))); }
@Test(expected = IllegalArgumentException.class) public void getOnlyElementOrEmpty_MoreThanOneElement() { CollectionFunctions.getOnlyElementOrEmpty(asList(1, 2)); }
@Test public void getOnlyElementOrEmpty_emptyList() { assertEquals(Optional.empty(), CollectionFunctions.getOnlyElementOrEmpty(emptyList())); }
@Test public void getOnlyElementOrEmpty_nullList() { assertEquals(Optional.empty(), CollectionFunctions.getOnlyElementOrEmpty(null)); } |
CollectionFunctions { public static <R, T> Map<R, T> pairsToMap(List<Pair<R, T>> pairs) { return simpleToMap(pairs, Pair::getKey, Pair::getValue); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void pairsToMap() { Map<Integer, String> expected = new LinkedHashMap<>(); expected.put(1, "a"); expected.put(2, "b"); assertEquals(expected, CollectionFunctions.pairsToMap(asList(Pair.of(1, "a"), Pair.of(2, "b")))); } |
CollectionFunctions { public static <T> Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn) { if (list == null || list.isEmpty()) { return empty(); } return list.stream().filter(filterFn).findFirst(); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleFindFirst() { assertEquals(Optional.of(3), CollectionFunctions.simpleFindFirst(asList(1, 2, 3), i -> i > 2)); }
@Test public void simpleFindFirst_notFound() { assertEquals(Optional.empty(), CollectionFunctions.simpleFindFirst(asList(1, 2, 3), i -> i > 3)); }
@Test public void simpleFindFirst_nullList() { assertEquals(Optional.empty(), CollectionFunctions.simpleFindFirst((List<Integer>) null, i -> i > 2)); }
@Test public void simpleFindFirst_withArray() { assertEquals(Optional.of(3), CollectionFunctions.simpleFindFirst(new Integer[]{1, 2, 3}, i -> i > 2)); }
@Test public void simpleFindFirst_withNullArray() { assertEquals(Optional.empty(), CollectionFunctions.simpleFindFirst((Integer[]) null, i -> i > 2)); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") public boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user) { return isSystemRegistrationUser(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void systemRegistrationUsersCanViewAnyOrganisation() { allGlobalRoleUsers.forEach(user -> { if (user.equals(systemRegistrationUser())) { assertTrue(rules.systemRegistrationUserCanSeeAllOrganisations(newOrganisationResource().build(), user)); } else { assertFalse(rules.systemRegistrationUserCanSeeAllOrganisations(newOrganisationResource().build(), user)); } }); } |
CollectionFunctions { public static <T> T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn) { if (list == null || list.isEmpty()) { throw new IllegalArgumentException("Cannot find a mandatory matching value in an empty list"); } return simpleFindFirst(list, filterFn).orElseThrow(() -> new IllegalArgumentException("Was unable to find a matching mandatory result in list")); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleFindFirstMandatory() { assertEquals(Integer.valueOf(3), CollectionFunctions.simpleFindFirstMandatory(asList(1, 2, 3), i -> i > 2)); }
@Test(expected = IllegalArgumentException.class) public void simpleFindFirstMandatory_withNullList() { CollectionFunctions.simpleFindFirstMandatory((List<Integer>) null, i -> i > 2); }
@Test(expected = IllegalArgumentException.class) public void simpleFindFirstMandatory_withNoMatchingElement() { CollectionFunctions.simpleFindFirstMandatory(asList(1, 2), i -> i > 2); } |
CollectionFunctions { public static <T> boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn) { if (list == null || list.isEmpty()) { return false; } return list.stream().anyMatch(filterFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleAnyMatch() { assertTrue(CollectionFunctions.simpleAnyMatch(asList(1, 2, 3), i -> i > 2)); }
@Test public void simpleAnyMatch_noMatch() { assertFalse(CollectionFunctions.simpleAnyMatch(asList(1, 2), i -> i > 2)); }
@Test public void simpleAnyMatch_nullList() { assertFalse(CollectionFunctions.simpleAnyMatch((List<Integer>) null, i -> i > 2)); }
@Test public void simpleAnyMatch_withArray() { assertTrue(CollectionFunctions.simpleAnyMatch(new Integer[]{1, 2, 3}, i -> i > 2)); }
@Test public void simpleAnyMatch_withArray_noMatch() { assertFalse(CollectionFunctions.simpleAnyMatch(new Integer[]{1, 2}, i -> i > 2)); }
@Test public void simpleAnyMatch_withArray_nullArray() { assertFalse(CollectionFunctions.simpleAnyMatch((Integer[]) null, i -> i > 2)); } |
OrganisationPermissionRules { @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") public boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user) { return isMemberOfOrganisation(organisation, user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void memberOfOrganisationCanViewOwnOrganisation() { UserResource user = newUserResource().build(); UserResource anotherUser = newUserResource().build(); OrganisationResource organisation = newOrganisationResource().build(); when(processRoleRepository.existsByUserIdAndOrganisationId(user.getId(), organisation.getId())).thenReturn(true); assertTrue(rules.memberOfOrganisationCanViewOwnOrganisation(organisation, user)); }
@Test public void memberOfOrganisationCanViewOwnOrganisationButUserIsNotAMemberOfTheOrganisation() { UserResource user = newUserResource().build(); UserResource anotherUser = newUserResource().build(); UserResource unrelatedUser = newUserResource().build(); OrganisationResource organisation = newOrganisationResource().build(); when(processRoleRepository.existsByUserIdAndOrganisationId(user.getId(), organisation.getId())).thenReturn(false); assertFalse(rules.memberOfOrganisationCanViewOwnOrganisation(organisation, unrelatedUser)); } |
CollectionFunctions { public static <T> boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn) { if (list == null || list.isEmpty()) { return true; } return list.stream().allMatch(filterFn); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void simpleAllMatch() { assertTrue(CollectionFunctions.simpleAllMatch(asList(1, 2, 3), i -> i > 0)); }
@Test public void simpleAllMatch_noMatch() { assertFalse(CollectionFunctions.simpleAllMatch(asList(1, 2, 3), i -> i > 1)); }
@Test public void simpleAllMatch_nullList() { assertTrue(CollectionFunctions.simpleAllMatch((List<Integer>) null, i -> i > 2)); }
@Test public void simpleAllMatch_emptyList() { assertTrue(CollectionFunctions.simpleAllMatch(emptyList(), i -> i != null)); }
@Test public void simpleAllMatch_withArray() { assertTrue(CollectionFunctions.simpleAllMatch(new Integer[]{1, 2, 3}, i -> i > 0)); }
@Test public void simpleAllMatch_withArray_noMatch() { assertFalse(CollectionFunctions.simpleAllMatch(new Integer[]{1, 2}, i -> i > 1)); }
@Test public void simpleAllMatch_withArray_nullArray() { assertTrue(CollectionFunctions.simpleAllMatch((Integer[]) null, i -> i > 2)); } |
CollectionFunctions { public static <T> BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe) { return (t1, t2) -> { if (t1 != null && t2 != null) { return notNullSafe.apply(t1, t2); } else if (t1 != null) { return t1; } else return t2; }; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void nullSafe() { BinaryOperator<Integer> nullSafeAdder = CollectionFunctions.nullSafe((Integer o1, Integer o2) -> o1 + o2); Integer reduction = Stream.of(null, null, null, 4, null, 6, 7).reduce(nullSafeAdder).get(); assertEquals(17, reduction.intValue()); } |
CollectionFunctions { @SuppressWarnings("unchecked") public static <T, R> List<Pair<T, R>> asListOfPairs(Object... entries) { if (entries.length % 2 != 0) { throw new IllegalArgumentException("Should have an even number of names and values in list"); } List<Pair<T, R>> list = new ArrayList<>(); for (int i = 0; i < entries.length; i += 2) { T key = (T) entries[i]; R value = (R) entries[i + 1]; list.add(Pair.of(key, value)); } return list; } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void asListOfPairs() { List<Pair<String, Integer>> expected = asList(Pair.of("a", 1), Pair.of("b", 2), Pair.of("c", 3)); assertEquals(expected, CollectionFunctions.asListOfPairs("a", 1, "b", 2, "c", 3)); }
@Test(expected = IllegalArgumentException.class) public void asListOfPairs_unevenEntries() { CollectionFunctions.asListOfPairs("a", 1, "b", 2, "c"); } |
CollectionFunctions { public static <T> List<T> nOf(int n, T t) { return range(0, n).mapToObj(x -> t).collect(toList()); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void nOf() { assertEquals(asList("a", "a", "a", "a", "a"), CollectionFunctions.nOf(5, "a")); } |
CollectionFunctions { public static <T> List<T> flattenOptional(Collection<Optional<T>> toFlatten){ return simpleMap(simpleFilter(toFlatten, Optional::isPresent), Optional::get); } private CollectionFunctions(); static List<T> flattenLists(Collection<? extends Collection<T>> toFlatten); static List<T> flattenLists(Collection<S> toFlatten, Function<S, ? extends Collection<T>> mapper); static Set<T> flattenSets(Set<Set<T>> lists); @SafeVarargs static List<T> combineLists(List<T>... lists); @SafeVarargs static Predicate<T> and(Predicate<? super T>... predicates); @SafeVarargs static List<T> combineLists(List<T> list, T... otherElements); @SafeVarargs static List<T> combineLists(T firstElement, T... otherElements); static List<T> combineLists(T firstElement, Collection<T> otherElements); static Consumer<List<T>> forEachConsumer(BiConsumer<Integer, T> consumer); static void forEachWithIndex(List<T> list, BiConsumer<Integer, T> consumer); static void zip(List<T> list1, List<S> list2, BiConsumer<T, S> consumer); static void zip(List<R> list1, List<S> list2, List<T> list3, TriConsumer<R, S, T> consumer); static void zipWithIndex(List<T> list1, List<S> list2, TriConsumer<T, S, Integer> consumer); static List<R> zipAndMap(List<T> list1, List<S> list2, BiFunction<T, S, R> biFunction); static List<R> zipAndMapWithIndex(List<T> list1, List<S> list2, TriFunction<T, S, Integer, R> triFunction); static Function<List<T>, List<R>> forEachFunction(BiFunction<Integer, T, R> function); static List<R> mapWithIndex(List<T> list, BiFunction<Integer, T, R> function); static List<T> reverse(List<T> original); static T getOnlyElement(List<T> list); static Optional<T> getOnlyElementOrEmpty(List<T> list); @SuppressWarnings("unchecked") static R[] simpleMapArray(T[] array, Function<T, R> mappingFn, Class<R> clazz); static List<R> simpleMap(Map<S, T> map, BiFunction<S, T, R> mappingFn); static List<R> simpleMap(T[] list, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(T[] list, BiFunction<T, Integer, R> mappingFn); static Map<T, R> simpleFilter(Map<T, R> map, Predicate<T> filterFn); static Map<T, R> simpleFilterNot(Map<T, R> map, Predicate<T> filterFn); static Map<S, Map<T,R>> simpleGroupBy(Map<T, R> map, Function<T, S> filterFn); static Map<T, R> simpleFilter(Map<T, R> map, BiPredicate<T, R> filterFn); static Map<R, U> simpleMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleLinkedMapKeyAndValue(Map<S, T> map, Function<S, R> keyMappingFn, Function<T, U> valueMappingFn); static Map<R, U> simpleMapEntry(Map<S, T> map, Function<Entry<S, T>, R> keyMapping, Function<Entry<S,T>, U> valueMapping); static Map<R, T> simpleMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<R, T> simpleLinkedMapKey(Map<S, T> map, Function<S, R> mappingFn); static Map<S, R> simpleMapValue(Map<S, T> map, Function<T, R> mappingFn); static Map<S, R> simpleLinkedMapValue(Map<S, T> map, Function<T, R> mappingFn); static Set<R> simpleMapSet(Set<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(List<T> list, Function<T, R> mappingFn); static Set<R> simpleMapSet(T[] array, Function<T, R> mappingFn); static List<R> simpleMap(Collection<T> collection, Function<T, R> mappingFn); static List<R> simpleMapWithIndex(Collection<T> collection, BiFunction<T, Integer, R> mappingFn); static List<T> sort(Collection<T> list); static List<T> sort(Collection<T> list, Comparator<T> comparator); static Collector<T, ?, Map<K, U>> toLinkedMap(
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToMap(
Collection<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static Map<K, U> simpleToLinkedMap(
List<T> list,
Function<? super T, ? extends K> keyMapper,
Function<? super T, ? extends U> valueMapper); static LinkedHashSet<R> simpleToLinkedHashSet(T[] array,
Function<T, R> mappingFn); static LinkedHashSet<R> simpleToLinkedHashSet(Collection<T> collection,
Function<T, R> mappingFn); static Map<K, T> simpleToMap(
List<T> list,
Function<? super T, ? extends K> keyMapper); static Map<R, T> pairsToMap(List<Pair<R, T>> pairs); static List<T> simpleFilter(Collection<? extends T> list, Predicate<T> filterFn); static List<T> simpleFilter(T[] array, Predicate<T> filterFn); static List<T> simpleFilterNot(Collection<? extends T> list, Predicate<T> filterFn); static Optional<T> simpleFindAny(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(Collection<T> list, Predicate<T> filterFn); static Optional<T> simpleFindFirst(T[] array, Predicate<T> filterFn); static T simpleFindFirstMandatory(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAnyMatch(T[] array, Predicate<T> filterFn); static boolean simpleAllMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleAllMatch(T[] array, Predicate<T> filterFn); static boolean simpleNoneMatch(Collection<T> list, Predicate<T> filterFn); static boolean simpleNoneMatch(T[] array, Predicate<T> filterFn); static String simpleJoiner(Collection<T> list, String joinString); static String simpleJoiner(List<T> list, Function<T, String> transformer, String joinString); @SafeVarargs static Set<T> asLinkedSet(T... items); static List<T> removeElement(List<T> list, int index); static List<T> removeDuplicates(Collection<T> list); static Pair<List<T>, List<T>> simplePartition(List<T> list, Predicate<T> test); static BinaryOperator<T> nullSafe(final BinaryOperator<T> notNullSafe); static List<List<T>> findPermutations(List<T> excludedWords); @SuppressWarnings("unchecked") static List<Pair<T, R>> asListOfPairs(Object... entries); static boolean containsAll(Collection<T> containing, Collection<R> contained, BiFunction<T, R, Boolean> equalsFunction); static boolean containsAll(Collection<T> containing, Function<T, S> transformer1, Collection<R> contained, Function<R, S> transformer2); static SortedMap<T, List<R>> toSortedMapWithList(List<S> orderedList, Function<S, T> keyTransform, Function<S, R> valueTransform); static T unique(Collection<S> collectionToSearch, Function<S, T> property); static List<T> nOf(int n, T t); static List<T> flattenOptional(Collection<Optional<T>> toFlatten); static Predicate<T> negate(Predicate<T> predicate); } | @Test public void flattenOptional() { List<Optional<Integer>> listOfOptionals = asList( Optional.of(1), Optional.empty(), Optional.of(3), Optional.of(4), Optional.empty()); assertEquals(asList(1, 3, 4), CollectionFunctions.flattenOptional(listOfOptionals)); } |
MathFunctions { public static BigDecimal percentage(long numerator, long denominator) { int scale = 2; if (denominator != 0) { return valueOf(numerator).multiply(valueOf(100)).divide(valueOf(denominator), scale, HALF_UP); } else { return ZERO.setScale(scale); } } private MathFunctions(); static BigDecimal percentage(long numerator, long denominator); } | @Test public void testPercentage() { assertEquals(percentage(0, 10), new BigDecimal("0.00")); assertEquals(percentage(10, 10), new BigDecimal("100.00")); assertEquals(percentage(1, 3), new BigDecimal("33.33")); assertEquals(percentage(2, 3), new BigDecimal("66.67")); assertEquals(percentage(2, 1), new BigDecimal("200.00")); assertEquals(percentage(-1, 10), new BigDecimal("-10.00")); assertNotEquals(percentage(0, 10), new BigDecimal("0")); assertEquals(percentage(0, 0), new BigDecimal("0.00")); } |
MapFunctions { public static <T, R> Map<T, R> asMap(Object... nameValuePairs) { if (nameValuePairs.length % 2 != 0) { throw new IllegalArgumentException("Should have an even number of names and values in list"); } Map<T, R> map = new HashMap<>(); for (int i = 0; i < nameValuePairs.length; i += 2) { T key = (T) nameValuePairs[i]; R value = (R) nameValuePairs[i + 1]; map.put(key, value); } return map; } private MapFunctions(); static Map<T, R> asMap(Object... nameValuePairs); static LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn); static List<Pair<T, R>> toListOfPairs(Map<T, R> map); static Map<T, R> toMap(List<Pair<T, R>> list); static Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2); static Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test); } | @Test public void testAsMap() { Map<Long, String> map = asMap(1L, "String 1", 2L, "String 2"); assertEquals(2, map.size()); assertTrue(map.containsKey(1L)); assertTrue(map.containsKey(2L)); assertEquals("String 1", map.get(1L)); assertEquals("String 2", map.get(2L)); }
@Test(expected = IllegalArgumentException.class) public void testAsMapWithUnevenNamesAndValues() { asMap(1L, "String 1", 2L); }
@Test public void testAsMapEmptyNameValuePairs() { Map<Long, String> map = asMap(); assertTrue(map.isEmpty()); } |
MapFunctions { public static <T, R> LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn) { if (list == null || list.isEmpty()) { return new LinkedHashMap<>(0); } Map<R, List<T>> grouped = list.stream().collect(groupingBy(groupFn)); Map<R, Integer> numberOfOccurrancesByGrouping = simpleToMap(new ArrayList<>(grouped.entrySet()), Entry::getKey, entry -> entry.getValue().size()); List<Entry<R, Integer>> entries = new ArrayList<>(numberOfOccurrancesByGrouping.entrySet()); entries.sort((entry1, entry2) -> entry2.getValue().compareTo(entry1.getValue())); LinkedHashMap<R, Integer> sortedMap = new LinkedHashMap<>(); entries.forEach(entry -> sortedMap.put(entry.getKey(), entry.getValue())); return sortedMap; } private MapFunctions(); static Map<T, R> asMap(Object... nameValuePairs); static LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn); static List<Pair<T, R>> toListOfPairs(Map<T, R> map); static Map<T, R> toMap(List<Pair<T, R>> list); static Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2); static Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test); } | @Test public void testGetSortedGroupingCounts() { List<SortGroupTest> groupable = simpleMap(asList("string 1", "string 1", "string 2", "string 2", "string 2", "string 2", "string 3"), SortGroupTest::new); Map<String, Integer> groupedCountedAndSorted = MapFunctions.getSortedGroupingCounts(groupable, SortGroupTest::getValue); assertEquals(3, groupedCountedAndSorted.size()); assertEquals(Integer.valueOf(4), groupedCountedAndSorted.get("string 2")); assertEquals(Integer.valueOf(2), groupedCountedAndSorted.get("string 1")); assertEquals(Integer.valueOf(1), groupedCountedAndSorted.get("string 3")); }
@Test public void testGetSortedGroupingCountsNullSafe() { Map<String, Integer> groupedCountedAndSorted = MapFunctions.getSortedGroupingCounts(null, SortGroupTest::getValue); assertEquals(0, groupedCountedAndSorted.size()); } |
MapFunctions { public static <T, R> Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2) { if (map1 == null && map2 == null) { return new HashMap<>(0); } if (map1 == null) { return new HashMap<>(map2); } if (map2 == null) { return new HashMap<>(map1); } Map<T, R> combined = new HashMap<>(map1); map2.forEach((key, value) -> combined.put(key, value)); return combined; } private MapFunctions(); static Map<T, R> asMap(Object... nameValuePairs); static LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn); static List<Pair<T, R>> toListOfPairs(Map<T, R> map); static Map<T, R> toMap(List<Pair<T, R>> list); static Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2); static Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test); } | @Test public void testCombineMaps() { Map<Long, String> map1 = asMap(1L, "1", 2L, "2"); Map<Long, String> map2 = asMap(3L, "3"); assertEquals(asMap(1L, "1", 2L, "2", 3L, "3"), combineMaps(map1, map2)); } |
OrganisationPermissionRules { @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") public boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user) { return isMemberOfOrganisation(organisation, user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void memberOfOrganisationCanUpdateOwnOrganisation() { UserResource user = newUserResource().build(); OrganisationResource organisation = newOrganisationResource().build(); when(processRoleRepository.existsByUserIdAndOrganisationId(user.getId(), organisation.getId())).thenReturn(true); assertTrue(rules.memberOfOrganisationCanUpdateOwnOrganisation(organisation, user)); }
@Test public void memberOfOrganisationCanUpdateOwnOrganisationButUserIsNotAMemberOfTheOrganisation() { UserResource user = newUserResource().build(); UserResource unrelatedUser = newUserResource().build(); OrganisationResource organisation = newOrganisationResource().build(); when(processRoleRepository.existsByUserIdAndOrganisationId(user.getId(), organisation.getId())).thenReturn(false); assertFalse(rules.memberOfOrganisationCanUpdateOwnOrganisation(organisation, unrelatedUser)); } |
MapFunctions { public static <T, S> Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test) { if (map == null || map.isEmpty()) { return Pair.of(emptyMap(), emptyMap()); } Map<Boolean, List<Entry<T, S>>> partitioned = map.entrySet().stream().collect(partitioningBy(test)); Map<T, S> left = partitioned.get(true).stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue)); Map<T, S> right = partitioned.get(false).stream().collect(Collectors.toMap(Entry::getKey, Entry::getValue)); return Pair.of(left, right); } private MapFunctions(); static Map<T, R> asMap(Object... nameValuePairs); static LinkedHashMap<R, Integer> getSortedGroupingCounts(List<T> list, Function<T, R> groupFn); static List<Pair<T, R>> toListOfPairs(Map<T, R> map); static Map<T, R> toMap(List<Pair<T, R>> list); static Map<T, R> combineMaps(Map<T, R> map1, Map<T, R> map2); static Pair<Map<T, S>, Map<T, S>> simplePartition(Map<T, S> map, Predicate<Entry<T, S>> test); } | @Test public void testSimplePartition() { Map<Long, String> map1 = asMap(1L, "1", 2L, "2", 3L, "3"); Pair<Map<Long, String>, Map<Long, String>> result = simplePartition(map1, longStringEntry -> longStringEntry.getKey().equals(2L)); assertEquals(asMap(2L, "2"), result.getLeft()); assertEquals(asMap(1L, "1", 3L, "3"), result.getRight()); Pair<Map<Long, String>, Map<Long, String>> result2 = simplePartition(map1, longStringEntry -> longStringEntry.getValue().equals("3")); assertEquals(asMap(3L, "3"), result2.getLeft()); assertEquals(asMap(1L, "1", 2L, "2"), result2.getRight()); Pair<Map<Long, String>, Map<Long, String>> result3 = simplePartition(map1, longStringEntry -> longStringEntry.getValue().equals("4")); assertEquals(emptyMap(), result3.getLeft()); assertEquals(asMap(1L, "1", 2L, "2", 3L, "3"), result3.getRight()); } |
FieldComparisonValidator implements ConstraintValidator<FieldComparison, Object> { @Override public boolean isValid(Object value, ConstraintValidatorContext context) { boolean valid = isValid(value); if (!valid) { addConstraintViolationMessageToField(context, message, firstFieldName); } return valid; } @Override void initialize(final FieldComparison constraintAnnotation); @Override boolean isValid(Object value, ConstraintValidatorContext context); } | @Test public void isValid() throws Exception { mockMvc.perform(post("/") .contentType(APPLICATION_FORM_URLENCODED) .param("hasCats", "true") .param("catQuantity", "10") .param("hasDogs", "true") .param("dogQuantity", "10")) .andExpect(status().isOk()) .andExpect(model().hasNoErrors()) .andExpect(view().name("success")); } |
PhoneNumberValidator { public boolean validate(final String phonenumber) { matcher = pattern.matcher(phonenumber); return matcher.matches(); } PhoneNumberValidator(); boolean validate(final String phonenumber); static final String VALID_PHONE_NUMBER; } | @Test public void validPhoneNumberWithEightDigits() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertTrue("Eight digit phonenumber", tester.validate(eightDigitPhoneNumber)); }
@Test public void invalidPhoneNumberWithSevenDigits() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertFalse("Seven digit phonenumber", tester.validate(sevenDigitPhoneNumber)); }
@Test public void validPhoneNumberWithTwentyDigits() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertTrue("Twenty digit phonenumber", tester.validate(twentyDigitPhoneNumber)); }
@Test public void invalidPhoneNumberWithTwentyOneDigits() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertFalse("Twenty one digit phonenumber", tester.validate(twentyOneDigitPhoneNumber)); }
@Test public void validPhoneNumberWithBrackets() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertTrue("Valid phone number - Brackets are not included in the count.", tester.validate(validPhoneNumberWithBracket)); }
@Test public void invalidPhoneNumberWithBrackets() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertFalse("Invalid phone number - Brackets are not included in the count.", tester.validate(invalidPhoneNumberWithBracket)); }
@Test public void validPhoneNumberLengthWithInvalidCharacters() { PhoneNumberValidator tester = new PhoneNumberValidator(); assertFalse("Valid phone number length, invalid characters included", tester.validate(validPhoneNumberLengthWithInvalidCharacters)); } |
ApplicationAssessorResource { public boolean isAssigned() { return complementOf(of(REJECTED, WITHDRAWN)).contains(mostRecentAssessmentState); } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isAssigned() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(CREATED, PENDING, ACCEPTED, OPEN, DECIDE_IF_READY_TO_SUBMIT, READY_TO_SUBMIT, SUBMITTED), ApplicationAssessorResource::isAssigned); } |
ApplicationAssessorResource { public boolean isAccepted() { return of(ACCEPTED, OPEN, DECIDE_IF_READY_TO_SUBMIT, READY_TO_SUBMIT, SUBMITTED).contains(mostRecentAssessmentState); } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isAccepted() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(ACCEPTED, OPEN, DECIDE_IF_READY_TO_SUBMIT, READY_TO_SUBMIT, SUBMITTED), ApplicationAssessorResource::isAccepted); } |
ApplicationAssessorResource { public boolean isNotified() { return complementOf(of(CREATED)).contains(mostRecentAssessmentState); } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isNotified() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(PENDING, REJECTED, ACCEPTED, OPEN, DECIDE_IF_READY_TO_SUBMIT, READY_TO_SUBMIT, SUBMITTED, WITHDRAWN), ApplicationAssessorResource::isNotified); } |
ApplicationAssessorResource { public boolean isStarted() { return complementOf(of(CREATED, PENDING, ACCEPTED, REJECTED, WITHDRAWN)).contains(mostRecentAssessmentState); } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isStarted() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(OPEN, DECIDE_IF_READY_TO_SUBMIT, READY_TO_SUBMIT, SUBMITTED), ApplicationAssessorResource::isStarted); } |
ApplicationAssessorResource { public boolean isSubmitted() { return SUBMITTED == mostRecentAssessmentState; } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isSubmitted() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(SUBMITTED), ApplicationAssessorResource::isSubmitted); } |
ApplicationAssessorResource { public boolean isRejected() { return REJECTED == mostRecentAssessmentState; } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isRejected() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(AssessmentState.REJECTED), ApplicationAssessorResource::isRejected); } |
ApplicationAssessorResource { public boolean isWithdrawn() { return WITHDRAWN == mostRecentAssessmentState; } ApplicationAssessorResource(); ApplicationAssessorResource(Long userId,
String firstName,
String lastName,
BusinessType businessType,
Set<InnovationAreaResource> innovationAreas,
String skillAreas,
AssessmentRejectOutcomeValue rejectReason,
String rejectComment,
boolean available,
Long mostRecentAssessmentId,
AssessmentState mostRecentAssessmentState,
long totalApplicationsCount,
long assignedCount,
long submittedCount); Long getUserId(); void setUserId(Long userId); String getFirstName(); void setFirstName(String firstName); String getLastName(); void setLastName(String lastName); BusinessType getBusinessType(); void setBusinessType(BusinessType businessType); Set<InnovationAreaResource> getInnovationAreas(); void setInnovationAreas(Set<InnovationAreaResource> innovationAreas); String getSkillAreas(); void setSkillAreas(String skillAreas); AssessmentRejectOutcomeValue getRejectReason(); void setRejectReason(AssessmentRejectOutcomeValue rejectReason); String getRejectComment(); void setRejectComment(String rejectComment); boolean isAvailable(); void setAvailable(boolean available); Long getMostRecentAssessmentId(); void setMostRecentAssessmentId(Long mostRecentAssessmentId); AssessmentState getMostRecentAssessmentState(); void setMostRecentAssessmentState(AssessmentState mostRecentAssessmentState); long getTotalApplicationsCount(); void setTotalApplicationsCount(long totalApplicationsCount); long getAssignedCount(); void setAssignedCount(long assignedCount); long getSubmittedCount(); void setSubmittedCount(long submittedCount); boolean isAssigned(); boolean isAccepted(); boolean isNotified(); boolean isStarted(); boolean isSubmitted(); boolean isRejected(); boolean isWithdrawn(); @Override boolean equals(Object o); @Override int hashCode(); @Override String toString(); } | @Test public void isWithdrawn() throws Exception { assertTrueOnlyForMostRecentAssessmentStates(of(AssessmentState.WITHDRAWN), ApplicationAssessorResource::isWithdrawn); } |
AssessmentTotalScoreResource { @JsonIgnore public Integer getTotalScorePercentage() { if (totalScoreGiven == null || totalScoreGiven == 0) { return 0; } return totalScorePossible == 0 ? 0 : Math.round(totalScoreGiven * 100.0f / totalScorePossible); } AssessmentTotalScoreResource(); AssessmentTotalScoreResource(Integer totalScoreGiven, Integer totalScorePossible); Integer getTotalScoreGiven(); void setTotalScoreGiven(int totalScoreGiven); Integer getTotalScorePossible(); void setTotalScorePossible(int totalScorePossible); @JsonIgnore Integer getTotalScorePercentage(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void getTotalScorePercentage() throws Exception { assertEquals("Expected 50% since a score of 100 was given out of a possible 200", 50, getTotalScorePercentage(100, 200)); }
@Test public void getTotalScorePercentage_roundDown() throws Exception { assertEquals("Expected 50.4% to be rounded down to 50%", 50, getTotalScorePercentage(126, 250)); }
@Test public void getTotalScorePercentage_halfWayRoundUp() throws Exception { assertEquals("Expected 50.5% to be rounded up to 51%", 51, getTotalScorePercentage(101, 200)); }
@Test public void getTotalScorePercentage_roundUp() throws Exception { assertEquals("Expected 50.6% to be rounded up to 51%", 51, getTotalScorePercentage(253, 500)); }
@Test public void getTotalScorePercentage_noScore() throws Exception { assertEquals("Expected 0% since no score was given", 0, getTotalScorePercentage(0, 100)); }
@Test public void getTotalScorePercentage_noScorePossible() throws Exception { assertEquals("Expected 0% since no score is possible", 0, getTotalScorePercentage(50, 0)); }
@Test public void getTotalScorePercentage_maxScorePossible() throws Exception { assertEquals("Expected 100% since the score given equals the maximum score possible", 100, getTotalScorePercentage(50, 50)); }
@Test public void getTotalScorePercentage_zeroIfNoScoreGiven() { assertEquals(0, getTotalScorePercentage(0,0)); } |
OrganisationPermissionRules { @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") public boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user) { return isSystemRegistrationUser(user); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void systemRegistrationUserCanCreateOrganisations() { allGlobalRoleUsers.forEach(user -> { if (user.equals(systemRegistrationUser())) { assertTrue(rules.systemRegistrationUserCanCreateOrganisations(newOrganisationResource().build(), user)); } else { assertFalse(rules.systemRegistrationUserCanCreateOrganisations(newOrganisationResource().build(), user)); } }); } |
CompetitionFundedKeyApplicationStatisticsResource { @JsonIgnore public boolean isCanManageFundingNotifications() { return applicationsFunded > 0 || applicationsNotFunded > 0 || applicationsOnHold > 0; } int getApplicationsSubmitted(); void setApplicationsSubmitted(int applicationsSubmitted); int getApplicationsFunded(); void setApplicationsFunded(int applicationsFunded); int getApplicationsNotFunded(); void setApplicationsNotFunded(int applicationsNotFunded); int getApplicationsOnHold(); void setApplicationsOnHold(int applicationsOnHold); int getApplicationsNotifiedOfDecision(); void setApplicationsNotifiedOfDecision(int applicationsNotifiedOfDecision); int getApplicationsAwaitingDecision(); void setApplicationsAwaitingDecision(int applicationsAwaitingDecision); @JsonIgnore boolean isCanManageFundingNotifications(); @JsonIgnore boolean isCanReleaseFeedback(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void isCanManageFundingNotifications() { List<CompetitionFundedKeyApplicationStatisticsResource> resources = newCompetitionFundedKeyApplicationStatisticsResource() .withApplicationsFunded(0, 1, 0, 0, 1, 0, 1, 1) .withApplicationsNotFunded(0, 0, 1, 0, 1, 1, 0, 1) .withApplicationsOnHold(0, 0, 0, 1, 0, 1, 0, 1) .build(8); boolean[] expectedCanManageFunding = {false, true, true, true, true, true, true, true}; for (int i = 0; i < 8; i++) { assertEquals(expectedCanManageFunding[i], resources.get(i).isCanManageFundingNotifications()); } } |
CompetitionFundedKeyApplicationStatisticsResource { @JsonIgnore public boolean isCanReleaseFeedback() { return applicationsAwaitingDecision == 0 && applicationsSubmitted == applicationsNotifiedOfDecision; } int getApplicationsSubmitted(); void setApplicationsSubmitted(int applicationsSubmitted); int getApplicationsFunded(); void setApplicationsFunded(int applicationsFunded); int getApplicationsNotFunded(); void setApplicationsNotFunded(int applicationsNotFunded); int getApplicationsOnHold(); void setApplicationsOnHold(int applicationsOnHold); int getApplicationsNotifiedOfDecision(); void setApplicationsNotifiedOfDecision(int applicationsNotifiedOfDecision); int getApplicationsAwaitingDecision(); void setApplicationsAwaitingDecision(int applicationsAwaitingDecision); @JsonIgnore boolean isCanManageFundingNotifications(); @JsonIgnore boolean isCanReleaseFeedback(); @Override boolean equals(Object o); @Override int hashCode(); } | @Test public void isCanReleaseFeedback() { List<CompetitionFundedKeyApplicationStatisticsResource> resources = newCompetitionFundedKeyApplicationStatisticsResource() .withApplicationsAwaitingDecision(1,1,0,0) .withApplicationsSubmitted(1,1,1,1) .withApplicationsNotifiedOfDecision(0,1,0,1) .build(4); boolean[] expectedCanReleaseFeedback = {false, false, false, true}; for (int i = 0; i < 4; i++) { assertEquals(expectedCanReleaseFeedback[i], resources.get(i).isCanReleaseFeedback()); } } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getAssociateSalary() { return associateSalary; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getAssociateSalary() { assertEquals(associateSalary, additionalCompanyCostCategory.getAssociateSalary()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getManagementSupervision() { return managementSupervision; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getManagementSupervision() { assertEquals(managementSupervision, additionalCompanyCostCategory.getManagementSupervision()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getOtherStaff() { return otherStaff; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getOtherStaff() { assertEquals(otherStaff, additionalCompanyCostCategory.getOtherStaff()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getCapitalEquipment() { return capitalEquipment; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getCapitalEquipment() { assertEquals(capitalEquipment, additionalCompanyCostCategory.getCapitalEquipment()); } |
OrganisationPermissionRules { @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") public boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user) { return isSystemRegistrationUser(user) && !organisationLinkedToAnApplication(organisation); } @PermissionRule(value = "READ", description = "Internal Users can see all Organisations") boolean internalUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Stakeholders can see all Organisations") boolean stakeholdersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Competition finance users can see all Organisations") boolean competitionFinanceUsersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Monitoring officers can see Organisations on their projects") boolean monitoringOfficersCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "System Registration User can see all Organisations, in order to view particular Organisations during registration and invite") boolean systemRegistrationUserCanSeeAllOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can see Organisations on behalf of non-logged in users " + "whilst the Organisation is not yet linked to an Application") boolean systemRegistrationUserCanSeeOrganisationsNotYetConnectedToApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "A member of an Organisation can view their own Organisation") boolean memberOfOrganisationCanViewOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Users linked to Applications can view the basic details of the other Organisations on their own Applications") boolean usersCanViewOrganisationsOnTheirOwnApplications(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "User is invited to join the organisation") boolean usersCanViewOrganisationsTheyAreInvitedTo(OrganisationResource organisation, UserResource user); @PermissionRule(value = "CREATE", description = "The System Registration User can create Organisations on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanCreateOrganisations(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "The System Registration User can update Organisations that are not yet linked to Applications on behalf of non-logged in Users " + "during the regsitration process") boolean systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(OrganisationResource organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A member of an Organisation can update their own Organisation") boolean memberOfOrganisationCanUpdateOwnOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "The System Registration User can search for Organisations on behalf of non-logged in " + "users during the registration process") boolean systemRegistrationUserCanSeeOrganisationSearchResults(OrganisationSearchResult organisation, UserResource user); @PermissionRule(value = "UPDATE", description = "A project finance user can update any Organisation") boolean projectFinanceUserCanUpdateAnyOrganisation(OrganisationResource organisation, UserResource user); @PermissionRule(value = "READ", description = "Project Partners can see the Partner Organisations within their Projects") boolean projectPartnerUserCanSeePartnerOrganisationsWithinTheirProjects(OrganisationResource organisation, UserResource user); } | @Test public void systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers() { when(processRoleRepository.existsByOrganisationId(anyLong())).thenReturn(false); allGlobalRoleUsers.forEach(user -> { if (user.equals(systemRegistrationUser())) { assertTrue(rules.systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(newOrganisationResource().build(), user)); } else { assertFalse(rules.systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(newOrganisationResource().build(), user)); } }); }
@Test public void systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsersButOrganisationAttachedToUsers() { when(processRoleRepository.existsByOrganisationId(anyLong())).thenReturn(true); OrganisationResource organisation = newOrganisationResource().build(); allGlobalRoleUsers.forEach(user -> assertFalse(rules.systemRegistrationUserCanUpdateOrganisationsNotYetConnectedToApplicationsOrUsers(organisation, user))); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getConsumables() { return consumables; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getConsumables() { assertEquals(consumables, additionalCompanyCostCategory.getConsumables()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { public AdditionalCompanyCost getOtherCosts() { return otherCosts; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getOtherCosts() { assertEquals(otherCosts, additionalCompanyCostCategory.getOtherCosts()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { @Override @JsonIgnore public List<FinanceRowItem> getCosts() { return newArrayList(associateSalary, managementSupervision, otherStaff, capitalEquipment, consumables, otherCosts); } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getCosts() { assertEquals(costs, additionalCompanyCostCategory.getCosts()); } |
AdditionalCompanyCostCategory implements FinanceRowCostCategory { @Override public BigDecimal getTotal() { return total; } AdditionalCompanyCost getAssociateSalary(); void setAssociateSalary(AdditionalCompanyCost associateSalary); AdditionalCompanyCost getManagementSupervision(); void setManagementSupervision(AdditionalCompanyCost managementSupervision); AdditionalCompanyCost getOtherStaff(); void setOtherStaff(AdditionalCompanyCost otherStaff); AdditionalCompanyCost getCapitalEquipment(); void setCapitalEquipment(AdditionalCompanyCost capitalEquipment); AdditionalCompanyCost getConsumables(); void setConsumables(AdditionalCompanyCost consumables); AdditionalCompanyCost getOtherCosts(); void setOtherCosts(AdditionalCompanyCost otherCosts); void setTotal(BigDecimal total); @Override @JsonIgnore List<FinanceRowItem> getCosts(); @Override BigDecimal getTotal(); @Override void calculateTotal(); @Override void addCost(FinanceRowItem costItem); @Override boolean excludeFromTotalCost(); } | @Test public void getTotal() { BigDecimal result = associateSalary.getTotal() .add(managementSupervision.getTotal()) .add(otherStaff.getTotal()) .add(capitalEquipment.getTotal()) .add(consumables.getTotal()) .add(otherCosts.getTotal()); additionalCompanyCostCategory.calculateTotal(); assertEquals(result, additionalCompanyCostCategory.getTotal()); } |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.