public static void assertTripleNoMinus(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("minus set", triple.getMinusSet()); }
public void merge(DeltaSetTriple<T> triple) { zeroSet.addAll(triple.getZeroSet()); plusSet.addAll(triple.getPlusSet()); minusSet.addAll(triple.getMinusSet()); }
public static <T> void diff(Collection<T> valuesOld, Collection<T> valuesNew, DeltaSetTriple<T> triple) { if (valuesOld == null && valuesNew == null) { // No values, no change -> empty triple return; } if (valuesOld == null) { triple.getPlusSet().addAll(valuesNew); return; } if (valuesNew == null) { triple.getMinusSet().addAll(valuesOld); return; } for (T val : valuesOld) { if (valuesNew.contains(val)) { triple.getZeroSet().add(val); } else { triple.getMinusSet().add(val); } } for (T val : valuesNew) { if (!valuesOld.contains(val)) { triple.getPlusSet().add(val); } } }
public Collection<Construction<AH>> getConstructionSet(PlusMinusZero whichSet) { switch (whichSet) { case ZERO: return getConstructionTriple().getZeroSet(); case PLUS: return getConstructionTriple().getPlusSet(); case MINUS: return getConstructionTriple().getMinusSet(); default: throw new IllegalArgumentException("whichSet: " + whichSet); } }
private Collection<V> collectAllValues() throws SchemaException { Collection<V> allValues = new HashSet<>(); collectAllValuesFromSet(allValues, ivwoTriple.getZeroSet()); collectAllValuesFromSet(allValues, ivwoTriple.getPlusSet()); collectAllValuesFromSet(allValues, ivwoTriple.getMinusSet()); return allValues; }
public <F extends FocusType, K, T extends AbstractConstruction> void collectToConstructionMaps(LensContext<F> context, DeltaSetTriple<EvaluatedAssignmentImpl<F>> evaluatedAssignmentTriple, DeltaMapTriple<K, ConstructionPack<T>> constructionMapTriple, Function<EvaluatedAssignmentImpl<F>,DeltaSetTriple<T>> constructionTripleExtractor, FailableLensFunction<T,K> keyGenerator, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getZeroSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.ZERO, task, result); collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getPlusSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.PLUS, task, result); collectToConstructionMapFromEvaluatedAssignments(context, evaluatedAssignmentTriple.getMinusSet(), constructionMapTriple, constructionTripleExtractor, keyGenerator, PlusMinusZero.MINUS, task, result); }
private <AH extends AssignmentHolderType> void evaluateConstructions(LensContext<AH> context, DeltaSetTriple<EvaluatedAssignmentImpl<AH>> evaluatedAssignmentTriple, Task task, OperationResult result) throws SchemaException, ExpressionEvaluationException, ObjectNotFoundException, SecurityViolationException, ConfigurationException, CommunicationException { evaluateConstructions(context, evaluatedAssignmentTriple.getZeroSet(), task, result); evaluateConstructions(context, evaluatedAssignmentTriple.getPlusSet(), task, result); evaluateConstructions(context, evaluatedAssignmentTriple.getMinusSet(), task, result); }
private <F extends FocusType, K, T extends AbstractConstruction> void collectToConstructionMapFromEvaluatedAssignments(LensContext<F> context, Collection<EvaluatedAssignmentImpl<F>> evaluatedAssignments, DeltaMapTriple<K, ConstructionPack<T>> constructionMapTriple, Function<EvaluatedAssignmentImpl<F>,DeltaSetTriple<T>> constructionTripleExtractor, FailableLensFunction<T,K> keyGenerator, PlusMinusZero mode, Task task, OperationResult result) throws ObjectNotFoundException, SchemaException, CommunicationException, ConfigurationException, SecurityViolationException, ExpressionEvaluationException { for (EvaluatedAssignmentImpl<F> evaluatedAssignment: evaluatedAssignments) { if (LOGGER.isTraceEnabled()) { LOGGER.trace("Collecting constructions from evaluated assignment:\n{}", evaluatedAssignment.debugDump(1)); } DeltaSetTriple<T> constructionTriple = constructionTripleExtractor.apply(evaluatedAssignment); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getZeroSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.ZERO, task, result); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getPlusSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.PLUS, task, result); collectToConstructionMapFromEvaluatedConstructions(context, evaluatedAssignment, constructionTriple.getMinusSet(), constructionMapTriple, keyGenerator, mode, PlusMinusZero.MINUS, task, result); } }
allTriples.addAllToMinusSet(itemValueWithOrigin.getMinusSet()); allTriples.addAllToPlusSet(itemValueWithOrigin.getPlusSet()); allTriples.addAllToZeroSet(itemValueWithOrigin.getZeroSet());
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstructionAllToMinus( Map<QName, DeltaSetTriple<ItemValueWithOrigin<V,D>>> squeezedMap, Construction<F> construction, MappingExtractor<V,D,F> extractor, AssignmentPolicyEnforcementType enforcement) { if (enforcement == AssignmentPolicyEnforcementType.NONE) { return; } for (PrismValueDeltaSetTripleProducer<V, D> mapping: extractor.getMappings(construction)) { PrismValueDeltaSetTriple<V> vcTriple = mapping.getOutputTriple(); if (vcTriple == null) { continue; } QName name = mapping.getMappingQName(); DeltaSetTriple<ItemValueWithOrigin<V,D>> squeezeTriple = getSqueezeMapTriple(squeezedMap, name); if (enforcement == AssignmentPolicyEnforcementType.POSITIVE) { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getZeroSet(), mapping, construction); } else { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstructionNonminusToMinus( Map<QName, DeltaSetTriple<ItemValueWithOrigin<V,D>>> squeezedMap, Construction<F> construction, MappingExtractor<V,D,F> extractor, AssignmentPolicyEnforcementType enforcement) { if (enforcement == AssignmentPolicyEnforcementType.NONE) { return; } for (PrismValueDeltaSetTripleProducer<V, D> mapping: extractor.getMappings(construction)) { PrismValueDeltaSetTriple<V> vcTriple = mapping.getOutputTriple(); if (vcTriple == null) { continue; } QName name = mapping.getMappingQName(); DeltaSetTriple<ItemValueWithOrigin<V,D>> squeezeTriple = getSqueezeMapTriple(squeezedMap, name); if (enforcement == AssignmentPolicyEnforcementType.POSITIVE) { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getZeroSet(), mapping, construction); } else { convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getMinusSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
for (PersonaKey key: activePersonaKeyTriple.getMinusSet()) { FocusType existingPersona = findPersona(existingPersonas, key); if (existingPersona != null) {
createInstructionFromAssignment(assignmentAdded, PLUS, objectTreeDeltas, requester, ctx, result)); for (EvaluatedAssignment<?> assignmentRemoved : evaluatedAssignmentTriple.getMinusSet()) { addIgnoreNull(instructions, createInstructionFromAssignment(assignmentRemoved, MINUS, objectTreeDeltas, requester, ctx, result));
for (ItemValueWithOrigin<V,D> ivwo: ivwoTriple.getMinusSet()) { PrismValueDeltaSetTripleProducer<V, D> mapping = ivwo.getMapping(); PrismValueDeltaSetTriple<?> outputTriple = mapping.getOutputTriple();
private <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstruction( Map<QName, DeltaSetTriple<ItemValueWithOrigin<V,D>>> squeezedMap, Construction<F> construction, MappingExtractor<V,D,F> extractor, AssignmentPolicyEnforcementType enforcement) { if (enforcement == AssignmentPolicyEnforcementType.NONE) { return; } for (PrismValueDeltaSetTripleProducer<V, D> mapping: extractor.getMappings(construction)) { PrismValueDeltaSetTriple<V> vcTriple = mapping.getOutputTriple(); if (vcTriple == null) { continue; } QName name = mapping.getMappingQName(); DeltaSetTriple<ItemValueWithOrigin<V,D>> squeezeTriple = getSqueezeMapTriple(squeezedMap, name); convertSqueezeSet(vcTriple.getZeroSet(), squeezeTriple.getZeroSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getPlusSet(), mapping, construction); if (enforcement == AssignmentPolicyEnforcementType.POSITIVE) { convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getZeroSet(), mapping, construction); } else { convertSqueezeSet(vcTriple.getMinusSet(), squeezeTriple.getMinusSet(), mapping, construction); } } }
assertNotNull("null evaluatedAssignmentTriple", evaluatedAssignmentTriple); assertTrue("Unexpected plus set in evaluatedAssignmentTriple", evaluatedAssignmentTriple.getPlusSet().isEmpty()); assertTrue("Unexpected minus set in evaluatedAssignmentTriple", evaluatedAssignmentTriple.getMinusSet().isEmpty()); Collection<? extends EvaluatedAssignment<?>> assignmentZeroSet = evaluatedAssignmentTriple.getZeroSet(); assertNotNull("null zero set in evaluatedAssignmentTriple", assignmentZeroSet); assertTrue("Unexpected minus set in evaluatedConstructions", evaluatedConstructions.getMinusSet().isEmpty()); Collection<EvaluatedConstruction> constructionsZeroSet = evaluatedConstructions.getZeroSet(); assertEquals("Wrong size of zero set in evaluatedConstructions", 1, constructionsZeroSet.size());
@SuppressWarnings("unchecked") private <F extends FocusType> Collection<EvaluatedAssignmentImpl<F>> assertAssignmentTripleSetSize(LensContext<F> context, int zero, int plus, int minus) { assertEquals("Wrong size of assignment triple zero set", zero, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getZeroSet())); assertEquals("Wrong size of assignment triple plus set", plus, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getPlusSet())); assertEquals("Wrong size of assignment triple minus set", minus, CollectionUtils.size(context.getEvaluatedAssignmentTriple().getMinusSet())); return (Collection) context.getEvaluatedAssignmentTriple().getAllValues(); }
assertTrue("Unexpected evaluatedAssignmentTriple minus set", evaluatedAssignmentTriple.getMinusSet().isEmpty()); assertNotNull("No evaluatedAssignmentTriple plus set", evaluatedAssignmentTriple.getPlusSet()); assertEquals("Wrong size of evaluatedAssignmentTriple plus set", 1, evaluatedAssignmentTriple.getPlusSet().size()); assertFalse("Empty personaConstructionTriple", personaConstructionTriple.isEmpty()); assertTrue("Unexpected personaConstructionTriple plus set", personaConstructionTriple.getPlusSet().isEmpty()); assertTrue("Unexpected personaConstructionTriple minus set", personaConstructionTriple.getMinusSet().isEmpty()); assertNotNull("No personaConstructionTriple zero set", personaConstructionTriple.getZeroSet()); assertEquals("Wrong size of personaConstructionTriple zero set", 1, personaConstructionTriple.getZeroSet().size());
private void assertTargets(EvaluatedAssignmentImpl<? extends FocusType> evaluatedAssignment, Boolean evaluateConstructions, List<String> zeroValid, List<String> zeroInvalid, List<String> plusValid, List<String> plusInvalid, List<String> minusValid, List<String> minusInvalid) { assertTargets("zero", evaluatedAssignment.getRoles().getZeroSet(), evaluateConstructions, zeroValid, zeroInvalid); assertTargets("plus", evaluatedAssignment.getRoles().getPlusSet(), evaluateConstructions, plusValid, plusInvalid); assertTargets("minus", evaluatedAssignment.getRoles().getMinusSet(), evaluateConstructions, minusValid, minusInvalid); }
assertEquals("Wrong # of evaluated assignments zero set", 0, triple.getZeroSet().size()); assertEquals("Wrong # of evaluated assignments plus set", 1, triple.getPlusSet().size()); assertEquals("Wrong # of evaluated assignments minus set", 1, triple.getMinusSet().size());