public List<EvaluatedAssignmentTargetImpl> getNonNegativeTargets() { List<EvaluatedAssignmentTargetImpl> rv = new ArrayList<>(); rv.addAll(roles.getZeroSet()); rv.addAll(roles.getPlusSet()); return rv; }
public static void assertTripleNoPlus(DeltaSetTriple<?> triple) { assert triple != null : "triple is null"; assertTripleNoSet("plus set", triple.getPlusSet()); }
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 <V extends PrismValue, D extends ItemDefinition, F extends FocusType> void sqeezeAttributesFromConstructionNonminusToPlus( 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.getPlusSet(), mapping, construction); convertSqueezeSet(vcTriple.getPlusSet(), squeezeTriple.getPlusSet(), mapping, construction); // Ignore minus set } }
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.addAllToPlusSet(itemValueWithOrigin.getPlusSet()); allTriples.addAllToZeroSet(itemValueWithOrigin.getZeroSet());
for (EvaluatedAssignment<?> assignmentAdded : evaluatedAssignmentTriple.getPlusSet()) { addIgnoreNull(instructions, createInstructionFromAssignment(assignmentAdded, PLUS, objectTreeDeltas, requester, ctx, result));
display("evaluatedAssignmentTriple", evaluatedAssignmentTriple); assertEquals("Wrong # of evaluated assignments in plus set", 1, evaluatedAssignmentTriple.getPlusSet().size()); EvaluatedAssignment<?> evaluatedAssignment = evaluatedAssignmentTriple.getPlusSet().iterator().next(); assertNotNull("Target of evaluated assignment is null", evaluatedAssignment.getTarget()); assertEquals("Wrong # of zero-set roles in evaluated assignment", 1, evaluatedAssignment.getRoles().getZeroSet().size());
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); } } }
DeltaSetTriple<? extends EvaluatedAssignment<?>> evaluatedAssignmentTriple = context.getEvaluatedAssignmentTriple(); 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(); assertTrue("Unexpected plus set in evaluatedConstructions", evaluatedConstructions.getPlusSet().isEmpty()); assertTrue("Unexpected minus set in evaluatedConstructions", evaluatedConstructions.getMinusSet().isEmpty()); Collection<EvaluatedConstruction> constructionsZeroSet = evaluatedConstructions.getZeroSet();
assertEquals("Wrong # of added assignments", 1, evaluatedAssignmentTriple.getPlusSet().size()); EvaluatedAssignmentImpl evaluatedAssignment = evaluatedAssignmentTriple.getPlusSet().iterator().next(); assertEquals("Wrong # of focus policy rules", 0, evaluatedAssignment.getFocusPolicyRules().size()); assertEquals("Wrong # of this target policy rules", 2, evaluatedAssignment.getThisTargetPolicyRules().size());
assertEquals("Wrong # of added assignments", 1, evaluatedAssignmentTriple.getPlusSet().size()); EvaluatedAssignmentImpl evaluatedAssignment = evaluatedAssignmentTriple.getPlusSet().iterator().next(); assertEquals("Wrong # of focus policy rules", 0, evaluatedAssignment.getFocusPolicyRules().size()); Collection<EvaluatedPolicyRule> targetPolicyRules = evaluatedAssignment.getAllTargetsPolicyRules();
@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(); }
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); }
display("Evaluated assignment triple", triple.debugDump()); 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());