@NotNull @Override public ItemPath namedSegmentsOnly() { List<Object> newComponents = new ArrayList<>(); for (Object segment : segments) { if (ItemPath.isName(segment)) { newComponents.add(segment); } } return new ItemPathImpl(newComponents); }
@Override public ItemName lastName() { for (int i = segments.size() - 1; i >= 0; i--) { Object segment = segments.get(i); if (ItemPath.isName(segment)) { return ItemPath.toName(segment); } } return null; }
/** * Returns true if the path contains the specified name (requires exact match). */ default boolean containsNameExactly(QName name) { return getSegments().stream().anyMatch(component -> isName(component) && name.equals(toName(component))); }
/** * Returns the last name segment index; or -1 if there's no such segment. */ default int lastNameIndex() { for (int i = size()-1; i >= 0; i--) { if (ItemPath.isName(getSegment(i))) { return i; } } return -1; }
/** * Returns true if the path starts with the standard segment name (i.e. NOT variable nor special symbol). */ default boolean startsWithName() { return !isEmpty() && ItemPath.isName(first()); }
/** * Returns true if the path consists of a single name segment. (Not variable nor special symbol.) */ default boolean isSingleName() { return size() == 1 && ItemPath.isName(first()); }
/** * Returns the first name segment index; or -1 if there's no such segment. */ default int firstNameIndex() { for (int i = 0; i < size(); i++) { if (ItemPath.isName(getSegment(i))) { return i; } } return -1; }
@NotNull public ItemName getElementName() { if (definition != null) { return definition.getName(); // this is more precise, as the name in path can be unqualified } if (fullPath.isEmpty()) { throw new IllegalStateException("Empty full path in filter "+this); } Object last = fullPath.last(); if (ItemPath.isName(last)) { return ItemPath.toName(last); } else { throw new IllegalStateException("Got "+last+" as a last path segment in value filter "+this); } }
private static boolean isMetadata(ItemPathType itemPath) { boolean retMeta = false; for (Object ips : itemPath.getItemPath().getSegments()) { if (ItemPath.isName(ips) && ObjectType.F_METADATA.getLocalPart().equals(ItemPath.toName(ips).getLocalPart())) { return true; } } return retMeta; }
private String formatPath(ItemDelta itemDelta) { if (itemDelta.getDefinition() != null && itemDelta.getDefinition().getDisplayName() != null) { return itemDelta.getDefinition().getDisplayName(); } StringBuilder sb = new StringBuilder(); for (Object segment : itemDelta.getPath().getSegments()) { if (ItemPath.isName(segment)) { if (sb.length() > 0) { sb.append("/"); } sb.append(ItemPath.toName(segment).getLocalPart()); } } return sb.toString(); }
protected ItemDeltaImpl(ItemPath path, D itemDefinition, PrismContext prismContext) { //checkPrismContext(prismContext, itemDefinition); checkNoSpecialSymbols(path); this.prismContext = prismContext; if (path == null) { throw new IllegalArgumentException("Null path specified while creating item delta"); } if (path.isEmpty()) { this.elementName = null; } else { Object last = path.last(); if (!ItemPath.isName(last)) { throw new IllegalArgumentException("Invalid delta path "+path+". Delta path must always point to item, not to value"); } this.elementName = ItemPath.toName(last); this.parentPath = path.allExceptLast(); } this.definition = itemDefinition; }
@Override public Object resolve(ItemPath subpath) { if (subpath == null || subpath.isEmpty()) { return this; } if (subpath.size() > 1) { throw new IllegalArgumentException("Cannot resolve path "+subpath+" on polystring "+this+", the path is too deep"); } Object first = subpath.first(); if (!ItemPath.isName(first)) { throw new IllegalArgumentException("Cannot resolve non-name path "+subpath+" on polystring "+this); } QName itemName = ItemPath.toName(first); if (QNameUtil.match(F_ORIG, itemName)) { return orig; } else if (QNameUtil.match(F_NORM, itemName)) { return norm; } else { throw new IllegalArgumentException("Unknown path segment "+itemName); } }
@Override public <IV extends PrismValue,ID extends ItemDefinition> PartiallyResolvedItem<IV,ID> findPartial(ItemPath path) { if (path == null || path.isEmpty()) { // Incomplete path return null; } Object first = path.first(); if (!ItemPath.isName(first)) { throw new IllegalArgumentException("Attempt to lookup item using a non-name path "+path+" in "+this); } ItemName subName = ItemPath.toName(first); ItemPath rest = path.rest(); Item<?,?> subItem = findItem(subName); if (subItem == null) { return null; } return subItem.findPartial(rest); }
@Override public Object find(ItemPath path) { if (path == null || path.isEmpty()) { return this; } Object first = path.first(); if (!ItemPath.isName(first)) { throw new IllegalArgumentException("Attempt to lookup item using a non-name path "+path+" in "+this); } ItemName subName = ItemPath.toName(first); ItemPath rest = path.rest(); Item<?,?> subItem = findItem(subName); if (subItem == null) { return null; } return subItem.find(rest); }
public static void assertPathEqualsExceptForPrefixes(String message, ItemPath expected, ItemPath actual) { assertEquals(message + ": wrong path size", expected.size(), actual.size()); for (int i = 0; i < expected.size(); i++) { Object expectedSegment = expected.getSegment(i); Object actualSegment = actual.getSegment(i); if (ItemPath.isName(expectedSegment)) { QName qnameExpected = ItemPath.toName(expectedSegment); QName qnameActual = ItemPath.toName(actualSegment); assertEquals(message + ": wrong NS in path segment #" + (i+1), qnameExpected.getNamespaceURI(), qnameActual.getNamespaceURI()); assertEquals(message + ": wrong local part in path segment #" + (i+1), qnameExpected.getLocalPart(), qnameActual.getLocalPart()); } else { if (!ItemPath.segmentsEquivalent(expectedSegment, actualSegment)) { System.out.println("hi"); } assertTrue(message + ": wrong path segment #" + (i+1) + ": exp=" + expectedSegment + ", act=" + actualSegment, ItemPath.segmentsEquivalent(expectedSegment, actualSegment)); } } }
private void preparePassword() { if (valueItemPath == null) { return; } if (!valueItemPath.startsWithName(UserType.F_CREDENTIALS)) { return; } Object secondPathSegment = valueItemPath.getSegment(1); if (!ItemPath.isName(secondPathSegment)) { return; } credentialQName = ItemPath.toName(secondPathSegment); if (!QNameUtil.match(CredentialsType.F_PASSWORD, credentialQName)) { return; } if (securityPolicy == null) { return; } credentialPolicy = SecurityUtil.getEffectivePasswordCredentialsPolicy(securityPolicy); }
@Override public Object find(ItemPath path) { if (path == null || path.isEmpty()) { return this; } Object first = path.first(); if (!ItemPath.isName(first)) { throw new IllegalArgumentException("Attempt to resolve inside the reference value using a non-name path "+path+" in "+this); } ItemName subName = ItemPath.toName(first); if (compareLocalPart(F_OID, subName)) { return this.getOid(); } else if (compareLocalPart(F_TYPE, subName)) { return this.getTargetType(); } else if (compareLocalPart(F_RELATION, subName)) { return this.getRelation(); } else { throw new IllegalArgumentException("Attempt to resolve inside the reference value using a unrecognized path "+path+" in "+this); } }
private void assertNormalizedPath(UniformItemPath normalized, Object... expected) { assertEquals("wrong path length",normalized.size(), expected.length); for(int i=0; i<normalized.size(); i+=2) { ItemPathSegment nameSegment = normalized.getSegment(i); assert ItemPath.isName(nameSegment) : "Expected name segment but it was "+nameSegment.getClass(); QName name = ItemPath.toName(nameSegment); assert name != null : "name is null"; assert name.getNamespaceURI().equals(NS) : "wrong namespace: "+name.getNamespaceURI(); assert name.getLocalPart().equals(expected[i]) : "wrong local name, expected "+expected[i]+", was "+name.getLocalPart(); if (i + 1 < expected.length) { Object idSegment = normalized.getSegment(i+1); assert ItemPath.isId(idSegment) : "Expected is segment but it was "+idSegment.getClass(); Long id = ItemPath.toId(idSegment); assertId(id, (Long)expected[i+1]); } } }
static boolean segmentsEquivalent(Object o1, Object o2) { if (ItemPath.isName(o1)) { return ItemPath.isName(o2) && QNameUtil.match(ItemPath.toName(o1), ItemPath.toName(o2)); } else if (ItemPath.isVariable(o1)) { return ItemPath.isVariable(o2) && QNameUtil.match(ItemPath.toVariableName(o1), ItemPath.toVariableName(o2)); } else if (ItemPath.isSpecial(o1)) { return ItemPath.isSpecial(o2) && QNameUtil.match(ItemPathSegmentUtil.getSpecialSymbol(o1), ItemPathSegmentUtil.getSpecialSymbol(o2)); } else if (ItemPath.isId(o1)) { return ItemPath.isId(o2) && Objects.equals(ItemPath.toId(o1), ItemPath.toId(o2)); } else { return false; } }
private boolean isDynamic(ItemPath path) { for (Object segment : path.getSegments()) { if (ItemPath.isName(segment)) { QName name = ItemPath.toName(segment); if (QNameUtil.match(name, ShadowType.F_ATTRIBUTES) || QNameUtil.match(name, ObjectType.F_EXTENSION)) { return true; } } } return false; }