<IV extends PrismValue,ID extends ItemDefinition, I extends Item<IV,ID>> I findItem(ItemDefinition itemDefinition, Class<I> type);
@NotNull private static List<PrismValue> getValues(PrismContainerValue<?> pcv, ItemPath path) { Item<PrismValue, ItemDefinition> item = pcv.findItem(path); return item != null ? item.getValues() : Collections.emptyList(); }
public static PrismReferenceValue getReferenceValue(PrismContainerValue<?> parent, QName name) { Validate.notNull(parent, "Prism container value must not be null."); Validate.notNull(name, "QName must not be null."); PrismReference reference = parent.findItem(ItemName.fromQName(name), PrismReference.class); return reference != null ? reference.getValue() : null; }
public <T> Collection<T> getPropertyValues(PrismContainerValue<?> pcv, ItemPathType path) { if (pcv == null) { return emptyList(); } Item<?, ?> item = pcv.findItem(path.getItemPath()); if (item == null) { return new ArrayList<>(0); // TODO or emptyList? } //noinspection unchecked return (Collection<T>) item.getRealValues(); }
public static <T extends Containerable> PrismContainerValue<T> getFieldContainerValue(PrismContainerValue<?> parent, QName fieldName) { Validate.notNull(parent, "Container value must not be null."); Validate.notNull(fieldName, "Field QName must not be null."); PrismContainer<T> container = parent.findItem(ItemName.fromQName(fieldName), PrismContainer.class); return container != null ? container.getValue() : null; }
@SuppressWarnings("unchecked") public static <T> T getExtensionItemRealValue(@Nullable ExtensionType extension, @NotNull QName itemName) { if (extension == null) { return null; } Item item = extension.asPrismContainerValue().findItem(ItemName.fromQName(itemName)); return item != null ? (T) item.getRealValue() : null; }
private Collection findItemValues(Long id, ItemPath path, Collection<PrismContainerValue<V>> cvalues) { if (cvalues == null) { return null; } boolean foundValuesOnPath = false; Collection<PrismValue> subValues = new ArrayList<>(); for (PrismContainerValue<V> cvalue: cvalues) { if (id == null || id.equals(cvalue.getId())) { Item<?,?> item = cvalue.findItem(path); if (item != null) { subValues.addAll(PrismValueCollectionsUtil.cloneCollection(item.getValues())); foundValuesOnPath = true; } } } return foundValuesOnPath ? subValues : null; }
private <T> Item<PrismValue,ItemDefinition> findItem(QName itemName) { return getPrismValue().findItem(ItemName.fromQName(itemName)); }
private void addDescriptiveItems(SceneImpl scene, PrismContainerValue<?> sourceValue, VisualizationContext context, Task task, OperationResult result) { // TODO dynamically typed values if (sourceValue.getContainer() == null || sourceValue.getContainer().getCompileTimeClass() == null) { return; } Class<?> clazz = sourceValue.getContainer().getCompileTimeClass(); List<ItemPath> itemPathsToShow = descriptiveItems.get(clazz); if (itemPathsToShow == null) { return; } List<Item<?,?>> itemsToShow = new ArrayList<>(); for (ItemPath itemPath : itemPathsToShow) { Item<?,?> item = sourceValue.findItem(itemPath); if (item != null) { itemsToShow.add(item); } } visualizeItems(scene, itemsToShow, true, context, task, result); }
@Override public boolean match(PrismContainerValue value, MatchingRuleRegistry matchingRuleRegistry) throws SchemaException { Item itemToFind = value.findItem(fullPath); if (itemToFind == null || itemToFind.getValues().isEmpty()) { return false; } if (!(itemToFind instanceof PrismContainer)) { throw new SchemaException("Couldn't use exists query to search for items other than containers: " + itemToFind); } if (filter == null) { return true; } for (PrismContainerValue<?> pcv : ((PrismContainer<?>) itemToFind).getValues()) { if (filter.match(pcv, matchingRuleRegistry)) { return true; } } return false; }
public static void mergeExtension(PrismContainerValue<?> dstExtensionContainerValue, PrismContainerValue<?> srcExtensionContainerValue) throws SchemaException { for (Item<?,?> srcExtensionItem: emptyIfNull(srcExtensionContainerValue.getItems())) { Item<?,?> magicItem = dstExtensionContainerValue.findItem(srcExtensionItem.getElementName()); if (magicItem == null) { //noinspection unchecked dstExtensionContainerValue.add(srcExtensionItem.clone()); } } }
public static Object getItemRealValue(PrismContainerValue containerValue, String itemName) { Item item = containerValue.findItem(new ItemName(itemName)); if (item == null || item.size() == 0) { return null; } if (item.size() > 1) { throw new IllegalStateException("More than one value in item " + item); } PrismValue value = item.getAnyValue(); if (value == null) { return null; } if (value instanceof PrismPropertyValue) { return ((PrismPropertyValue) value).getValue(); } else if (value instanceof PrismReferenceValue) { ObjectReferenceType ort = new ObjectReferenceType(); ort.setupReferenceValue((PrismReferenceValue) value); return ort; } else if (value instanceof PrismContainerValue) { return ((PrismContainerValue) value).asContainerable(); // questionable } else { throw new IllegalStateException("Unknown PrismValue: " + value); } }
private boolean containsItem(PrismContainerValue prismContainerValue, ItemPath itemPath) { ItemName first = ItemPath.toName(itemPath.first()); Item item = prismContainerValue.findItem(first); if (item == null) { return false; } ItemPath pathTail = stripFirstIds(itemPath); if (item instanceof PrismContainer) { return containsItem((PrismContainer) item, pathTail); } else if (item instanceof PrismReference) { return pathTail.isEmpty(); // we do not want to look inside references } else if (item instanceof PrismProperty) { return pathTail.isEmpty(); // ...neither inside atomic values } else { return false; // should not occur anyway } }
Item i = currentObject.findItem(path); if (i == null) { return null;
public PrismContainerValueAsserter<C,RA> assertItems(QName... expectedItems) { for (QName expectedItem: expectedItems) { Item<PrismValue,ItemDefinition> item = getPrismValue().findItem(ItemName.fromQName(expectedItem)); if (item == null) { fail("Expected item "+expectedItem+" in "+desc()+" but there was none. Items present: "+presentItemNames()); } } for (Item<?, ?> existingItem : getPrismValue().getItems()) { if (!QNameUtil.contains(expectedItems, existingItem.getElementName())) { fail("Unexpected item "+existingItem.getElementName()+" in "+desc()+". Expected items: "+QNameUtil.prettyPrint(expectedItems)); } } return this; }
@Test public void testAssignmentHashcode3() throws SchemaException { LOGGER.info("\n\n===[ testAssignmentHashcode3 ]===\n"); System.out.println("\n\n===[ testAssignmentHashcode3 ]===\n"); PrismContext prismContext = PrismTestUtil.getPrismContext(); AssignmentType a1a = new AssignmentType(prismContext) .beginActivation() .validTo("2018-01-01T00:00:00.000+01:00") .end(); AssignmentType a1b = a1a.clone(); // use unqualified item name for validTo a1b.getActivation().asPrismContainerValue() .findItem(ActivationType.F_VALID_TO) .setElementName(new QName("validTo")); System.out.println("a1a = " + a1a.asPrismContainerValue().debugDump()); System.out.println("a1b = " + a1b.asPrismContainerValue().debugDump()); // WHEN assertEquals("Wrong hashCode", a1a.hashCode(), a1b.hashCode()); }
Item<?,?> item = ownerPCV.findItem(sceneRelativeItemPath); if (item instanceof PrismContainer) { PrismContainer<?> container = (PrismContainer<?>) item;
Item<?,?> item = containerVal.findItem(elementName); if (item != null) { XNodeImpl xsubnode = marshalItemContent(item, getItemDefinition(containerVal, item), ctx);
+ ocDef); if (attributesContainer.getValue().findItem(uidDefinition.getName()) == null) { ResourceAttribute<String> uidRoa = uidDefinition.instantiate(); uidRoa.setRealValue(uid.getUidValue());