diff options
Diffstat (limited to 'models-base/src')
3 files changed, 119 insertions, 9 deletions
diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java index 65a28cffe..2576aab0a 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfConceptContainer.java @@ -33,6 +33,7 @@ import java.util.TreeMap; import javax.persistence.CascadeType; import javax.persistence.EmbeddedId; import javax.persistence.Entity; +import javax.persistence.FetchType; import javax.persistence.ManyToMany; import javax.persistence.Table; import javax.ws.rs.core.Response; @@ -69,7 +70,7 @@ public class PfConceptContainer<C extends PfConcept, A extends PfNameVersion> ex @EmbeddedId private PfConceptKey key; - @ManyToMany(cascade = CascadeType.ALL) + @ManyToMany(fetch = FetchType.EAGER, cascade = CascadeType.ALL) private Map<PfConceptKey, C> conceptMap; /** diff --git a/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java b/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java index 10ce4ea60..f4e457192 100644 --- a/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java +++ b/models-base/src/main/java/org/onap/policy/models/base/PfObjectFilter.java @@ -24,8 +24,9 @@ package org.onap.policy.models.base; import java.util.ArrayList; import java.util.Collections; import java.util.List; - -import lombok.NonNull; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.regex.Pattern; /** * Interface for filtering a list of concepts. @@ -43,14 +44,74 @@ public interface PfObjectFilter<T extends Comparable<T>> { public List<T> filter(final List<T> originalList); /** - * Check if a value matches a regular expression. + * Check if a value exactly equals some text. * * @param value the incoming value to check - * @param pattern the pattern to check against + * @param text the desired text to check against * @return match or not */ - public default boolean filterString(final String value, final String pattern) { - return value == null || pattern == null || value.equals(pattern); + public default boolean filterString(final String value, final String text) { + return value == null || text == null || value.equals(text); + } + + /** + * Gets a predicate used to filter an item in a list by exactly matching an extracted value + * with some text. + * + * @param text the desired text to check against, or {@code null} if to accept everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a value from a list item + */ + public default Predicate<T> filterStringPred(final String text, Function<T, String> extractor) { + // if null text, then everything matches + if (text == null) { + return item -> true; + } + + return item -> text.equals(extractor.apply(item)); + } + + /** + * Gets a predicate used to filter an item in a list by comparing the start of an + * extracted value with a prefix. + * + * @param prefix the desired prefix to check against, or {@code null} if to accept + * everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a prefix with a value from a list item + */ + public default Predicate<T> filterPrefixPred(final String prefix, Function<T, String> extractor) { + // if null prefix, then everything matches + if (prefix == null) { + return item -> true; + } + + return item -> { + String value = extractor.apply(item); + return (value != null && value.startsWith(prefix)); + }; + } + + /** + * Gets a predicate used to filter an item in a list by matching an extracted value + * with a regular expression. + * + * @param pattern regular expression to match, or {@code null} if to accept everything + * @param extractor function to extract the value, to be matched, from a list item + * @return a predicate to match a value from a list item using a regular expression + */ + public default Predicate<T> filterRegexpPred(final String pattern, Function<T, String> extractor) { + // if null pattern, then everything matches + if (pattern == null) { + return item -> true; + } + + Pattern pat = Pattern.compile(pattern); + + return item -> { + String value = extractor.apply(item); + return (value != null && pat.matcher(value).matches()); + }; } /** diff --git a/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java b/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java index c13140726..291a7d402 100644 --- a/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java +++ b/models-base/src/test/java/org/onap/policy/models/base/PfObjectFilterTest.java @@ -1,6 +1,7 @@ /*- * ============LICENSE_START======================================================= * Copyright (C) 2019 Nordix Foundation. + * Modifications Copyright (C) 2019 AT&T Intellectual Property. All rights reserved. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -20,14 +21,15 @@ package org.onap.policy.models.base; -import static org.assertj.core.api.Assertions.assertThatThrownBy; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; import java.util.ArrayList; import java.util.List; - +import java.util.function.BiFunction; +import java.util.function.Function; +import java.util.function.Predicate; import org.junit.Test; import org.onap.policy.models.base.testconcepts.DummyPfObject; @@ -101,5 +103,51 @@ public class PfObjectFilterTest { latestVersionList.remove(1); List<DummyPfObject> newestVersionList = dof.latestVersionFilter(latestVersionList); assertEquals(latestVersionList, newestVersionList); + + MyFilter filter = new MyFilter(); + + assertEquals(true, filter.filterString(null, "Hello")); + + DummyPfObject doNullVersion = new DummyPfObject(); + do5.setName("bbbbb"); + + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, doNullVersion, "1.0.0")); + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "1")); + assertEquals(false, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "2.0.0")); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterStringPred, DummyPfObject::getVersion, do0, "1.0.0")); + + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, doNullVersion, "1.")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.1")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.1")); + assertEquals(false, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "2")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.0.")); + assertEquals(true, filter(filter::filterPrefixPred, DummyPfObject::getVersion, do0, "1.0.0")); + + assertEquals(false, filter(filter::filterRegexpPred, DummyPfObject::getVersion, doNullVersion, "1[.].*")); + assertEquals(false, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "2[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, doNullVersion, null)); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, null)); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.]0[.].*")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1[.]0[.]0")); + assertEquals(true, filter(filter::filterRegexpPred, DummyPfObject::getVersion, do0, "1....")); + } + + private boolean filter(BiFunction<String, Function<DummyPfObject, String>, Predicate<DummyPfObject>> predMaker, + Function<DummyPfObject, String> extractor, DummyPfObject dpo, String text) { + Predicate<DummyPfObject> pred = predMaker.apply(text, extractor); + return pred.test(dpo); + } + + private static class MyFilter implements PfObjectFilter<DummyPfObject> { + @Override + public List<DummyPfObject> filter(List<DummyPfObject> originalList) { + return null; + } } } |