public boolean match(T realA, T realB) throws SchemaException { return matchingRule.match(realA, realB); }
private <T> void normalizeValues(Collection<PrismPropertyValue<T>> values, MatchingRule<T> matchingRule) throws SchemaException { for (PrismPropertyValue<T> pval: values) { T normalizedRealValue = matchingRule.normalize(pval.getValue()); pval.setValue(normalizedRealValue); } }
public boolean matches(T realValue, String regex) throws SchemaException{ return matchingRule.matchRegex(realValue, regex); }
} else { if (requireNormalizedIdentfiers) { assertEquals("Unexpected primary identifier in shadow for "+username, nameMatchingRule.normalize(username), idProp.getRealValue()); } else { PrismAsserts.assertEquals("Unexpected primary identifier in shadow for "+username, nameMatchingRule, username, idProp.getRealValue()); String expected = username; if (requireNormalizedIdentfiers && nameMatchingRule != null) { expected = nameMatchingRule.normalize(username); break; } else if (nameMatchingRule.match(username, idProp.getRealValue())) { found = true; break;
@Override public QName getName() { return nameMatchingRule.getName(); }
@Override public boolean isSupported(QName xsdType) { return nameMatchingRule.isSupported(xsdType); }
} else { if (requireNormalizedIdentfiers) { assertEquals("Unexpected primary identifier in shadow for "+username, nameMatchingRule.normalize(username), idProp.getRealValue()); } else { PrismAsserts.assertEquals("Unexpected primary identifier in shadow for "+username, nameMatchingRule, username, idProp.getRealValue()); String expected = username; if (requireNormalizedIdentfiers && nameMatchingRule != null) { expected = nameMatchingRule.normalize(username); break; } else if (nameMatchingRule.match(username, idProp.getRealValue())) { found = true; break;
@Override public QName getName() { return nameMatchingRule.getName(); }
@Override public boolean isSupported(QName xsdType) { return nameMatchingRule.isSupported(xsdType); }
private static <T> boolean equals(MatchingRule<T> matchingRule, T a, T b) throws SchemaException { if (a == null && b == null) { return true; } if (a == null || b == null) { return false; } if (matchingRule == null) { return a.equals(b); } else { return matchingRule.match(a, b); } }
@Override public PolyString normalize(PolyString original) throws SchemaException { return new PolyString(nameMatchingRule.normalize(original.getOrig())); }
@Override public boolean matchRegex(PolyString a, String regex) throws SchemaException { return nameMatchingRule.matchRegex(a.getOrig(), regex); }
<T> void registerMatchingRule(MatchingRule<T> rule) { ((Map)this.matchingRules).put(rule.getName(), rule); }
@Override @NotNull public <T> MatchingRule<T> getMatchingRule(QName ruleName, QName typeQName) throws SchemaException { if (ruleName == null) { return (MatchingRule<T>) defaultMatchingRule; } MatchingRule<T> matchingRule = (MatchingRule<T>) matchingRules.get(ruleName); if (matchingRule == null) { //try match according to the localPart if (QNameUtil.matchAny(ruleName, matchingRules.keySet())){ ruleName = QNameUtil.resolveNs(ruleName, matchingRules.keySet()); matchingRule = (MatchingRule<T>) matchingRules.get(ruleName); } if (matchingRule == null) { throw new SchemaException("Unknown matching rule for name " + ruleName); } } if (typeQName != null && !matchingRule.isSupported(typeQName)) { throw new SchemaException("Matching rule "+ruleName+" does not support type "+typeQName); } return matchingRule; }
public static <T> boolean equals(T a, T b, MatchingRule<T> matchingRule) throws SchemaException { if (a == null && b == null) { return true; } if (a == null || b == null) { return false; } if (matchingRule == null) { if (a instanceof byte[]) { if (b instanceof byte[]) { return Arrays.equals((byte[])a, (byte[])b); } else { return false; } } else { return a.equals(b); } } else { return matchingRule.match(a, b); } }
@Override public PolyString normalize(PolyString original) throws SchemaException { return new PolyString(nameMatchingRule.normalize(original.getOrig())); }
@Override public boolean matchRegex(PolyString a, String regex) throws SchemaException { return nameMatchingRule.matchRegex(a.getOrig(), regex); }
@Override public boolean match(PolyString a, PolyString b) throws SchemaException { return nameMatchingRule.match(a.getOrig(), b.getOrig()); }
private void assertNormalized(MatchingRule<String> rule, String expected, String original) throws SchemaException { assertEquals("Normalized value does not match", expected, rule.normalize(original)); } }
private boolean matchesAssociationPattern(@NotNull List<String> patterns, @NotNull ResourceAttribute<?> identifier, @NotNull MatchingRule<Object> matchingRule) { for (String pattern : patterns) { for (PrismPropertyValue<?> identifierValue : identifier.getValues()) { try { if (identifierValue != null && matchingRule.matchRegex(identifierValue.getRealValue(), pattern)) { return true; } } catch (SchemaException e) { LOGGER.warn("Value '{}' is invalid: {}", identifierValue, e.getMessage(), e); return false; } } } return false; } }