public static <T> void recomputeRealValue(T realValue, PrismContext prismContext) { if (realValue == null) { return; } // TODO: switch to Recomputable interface instead of PolyString if (realValue instanceof PolyString && prismContext != null) { PolyString polyStringVal = (PolyString)realValue; // Always recompute. Recompute is cheap operation and this avoids a lot of bugs polyStringVal.recompute(prismContext.getDefaultPolyStringNormalizer()); } }
private String polyStringNorm(String orig) { return prismContext.getDefaultPolyStringNormalizer().normalize(orig); }
private static void append(List<String> allWords, String text, PrismContext prismContext) { if (StringUtils.isBlank(text)) { return; } String normalized = prismContext.getDefaultPolyStringNormalizer().normalize(text); String[] words = StringUtils.split(normalized); for (String word : words) { if (StringUtils.isNotBlank(word)) { if (!allWords.contains(word)) { allWords.add(word); } } } }
/** * Checks whether the given normalized string ends with the specified value * * @param polyString the string * @param value the value * @return true/false */ public boolean endsWith(PolyString polyString, String value) { if (polyString == null || value == null) { return false; } polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString.getNorm().endsWith(value); }
/** * Checks whether the given normalized string begins with the specified value. * * @param polyString the string * @param value the value * @return true/false */ public boolean startsWith(PolyString polyString, String value) { if (polyString == null || value == null) { return false; } polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString.getNorm().startsWith(value); }
protected PolyString createPolyString(String string) { PolyString polyString = new PolyString(string); polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString; }
private PolyString toPolyString(String orig) { PolyString polyString = new PolyString(orig); polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString; }
public static void assertEqualsPolyStringMulti(String message, Collection<PolyString> actual, String... expectedOrigs) { List<PolyString> expectedPolystrings = new ArrayList<>(expectedOrigs.length); for (String expectedOrig : expectedOrigs) { PolyString expected = new PolyString(expectedOrig); expected.recompute(PrismTestUtil.getPrismContext().getDefaultPolyStringNormalizer()); expectedPolystrings.add(expected); } assertEqualsCollectionUnordered(message, actual, expectedPolystrings); }
public static PolyString createPolyString(String orig) { PolyString polyString = new PolyString(orig); polyString.recompute(getPrismContext().getDefaultPolyStringNormalizer()); return polyString; }
private String polyStringNorm(String orig) { return prismContext.getDefaultPolyStringNormalizer().normalize(orig); }
/** * Normalize a string value. It follows the default normalization algorithm * used for PolyString values. * * @param orig original value to normalize * @return normalized value */ public String norm(String orig) { if (orig == null) { return null; } PolyString polyString = new PolyString(orig); polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString.getNorm(); }
@Override public Condition interpret() throws QueryException { // TODO implement multiple values if (filter.getValues().size() != 1) { throw new QueryException("FullText filter currently supports only a single string"); } String text = filter.getValues().iterator().next(); String normalized = getContext().getPrismContext().getDefaultPolyStringNormalizer().normalize(text); String[] words = StringUtils.split(normalized); List<Condition> conditions = new ArrayList<>(words.length); for (String word : words) { conditions.add(createWordQuery(word)); } if (conditions.isEmpty()) { return createWordQuery(""); // original behavior -> match all records (TODO return something like 'empty condition') } else if (conditions.size() == 1) { return conditions.get(0); } else { return getContext().getHibernateQuery().createAnd(conditions); } }
private Object toCorrectPolyStringClass(Object value, Class<?> beanClass, XNodeImpl node) { PolyString polyString; if (value instanceof String) { polyString = new PolyString((String) value); } else if (value instanceof PolyStringType) { polyString = ((PolyStringType) value).toPolyString(); } else if (value instanceof PolyString) { polyString = (PolyString) value; // TODO clone? } else if (value == null) { polyString = null; } else { throw new IllegalStateException("Couldn't convert " + value + " to a PolyString; while parsing " + node.debugDump()); } if (polyString != null && polyString.getNorm() == null) { // TODO should we always use default normalizer? polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); } if (PolyString.class.equals(beanClass)) { return polyString; } else if (PolyStringType.class.equals(beanClass)) { return new PolyStringType(polyString); } else { throw new IllegalArgumentException("Wrong class for PolyString value: " + beanClass); } }
public static void assertEqualsPolyString(String message, String expectedOrig, PolyString actual) { PolyString expected = new PolyString(expectedOrig); expected.recompute(PrismTestUtil.getPrismContext().getDefaultPolyStringNormalizer()); assertEquals(message, expected, actual); }
String orig = poly.getOrig(); String norm = poly.getNorm(); PolyStringNormalizer polyStringNormalizer = prismContext.getDefaultPolyStringNormalizer(); String expectedNorm = polyStringNormalizer.normalize(orig); if (!norm.equals(expectedNorm)) {
/** * Normalize a PolyString value. * * @param orig original value to normalize * @return normalized value */ public String norm(PolyString orig) { if (orig == null) { return null; } if (orig.getNorm() != null) { return orig.getNorm(); } orig.recompute(prismContext.getDefaultPolyStringNormalizer()); return orig.getNorm(); }
private PolyString toPolyString(String orig) { PolyString polyString = new PolyString(orig); polyString.recompute(prismContext.getDefaultPolyStringNormalizer()); return polyString; }
LOGGER.debug("Trying to query PolyString value but filter contains String '{}'.", filter); String orig = (String) value; value = new PolyString(orig, context.getPrismContext().getDefaultPolyStringNormalizer().normalize(orig));
public static void assertEqualsPolyString(String message, String expectedOrig, PolyStringType actual) { if (expectedOrig == null && actual == null) { return; } assert actual != null : message + ": null value"; assert MiscUtil.equals(expectedOrig, actual.getOrig()) : message+"; expected orig '"+expectedOrig+ "' but was '" + actual.getOrig() + "'"; PolyString expected = new PolyString(expectedOrig); expected.recompute(PrismTestUtil.getPrismContext().getDefaultPolyStringNormalizer()); assert MiscUtil.equals(expected.getNorm(), actual.getNorm()) : message+"; expected norm '"+expected.getNorm()+ "' but was '" + actual.getNorm() + "'"; }
LOGGER.debug("No name for shadow:\n{}", object.debugDump()); } else if (name.getNorm() == null) { name.recompute(objectContext.getPrismContext().getDefaultPolyStringNormalizer());