private boolean isParameter( String parameterCandidate, EList<ParameterExpressionType> parameter) { return parameter != null && parameter .stream() .map(pet -> "${" + pet.getName() + "}") .anyMatch(name -> parameterCandidate.equals(name)); }
private Optional<Node> component(final String id) { final Optional<Node> node = this.flow .getNodes() .stream() .filter(n -> n.getId().equals(id)).findFirst(); return node; }
/** * Returns the parameter of a pattern by name * * @param pattern * @param name * @return the requested parameter of the pattern if exists * @since 2.0 */ public static Optional<Variable> getParameterByName(final Pattern pattern, final String name) { return pattern.getParameters().stream().filter(variable -> name.equals(variable.getName())).findAny(); }
/** * Remove ReferenceTreatments without a declared type from the list */ private void removeInvalidTreatments(EList<ReferenceTreatment> treatments) { ArrayList<ReferenceTreatment> invalidTreatments = Lists.newArrayList(treatments.stream() // .filter(el -> false == el.getReferenceElement() instanceof CollectionReferenceElement) // don't process collection resource links .filter(hasDeclaredType().negate()) // .collect(toList())); if (!invalidTreatments.isEmpty()) { treatments.removeAll(invalidTreatments); } }
@Override public Collection<ElkNode> provideComments() { // Simply return all nodes marked as comments return graph.getChildren().stream() .filter(node -> node.getProperty(CoreOptions.COMMENT_BOX)) .collect(Collectors.toList()); }
@Override public Collection<ElkNode> provideTargets() { // Return all non-comment nodes return graph.getChildren().stream() .filter(node -> !node.getProperty(CoreOptions.COMMENT_BOX)) .collect(Collectors.toList()); }
private String getFormattedPattern(Pattern pattern) { return pattern.getParameters().stream().map(Variable::getName) .collect(Collectors.joining(", ", pattern.getName() + "(", ")")); }
@Override public String casePatternCall(PatternCall object) { return String.format("Pattern call %s(%s)", object.getPatternRef().getName(), object.getParameters().stream().map(this::doSwitch).collect(Collectors.joining(", ")) ); }
@Override public Collection<IDataProvider<ElkNode, ElkNode>> provideSubHierarchies() { return graph.getChildren().stream() .filter(node -> !node.getChildren().isEmpty()) .map(node -> new ElkGraphDataProvider(node)) .collect(Collectors.toList()); }
private static Predicate<ReferenceProperty> isNotDefined(RealizationContainer realization) { return property -> realization.getReferenceTreatments().stream() // .noneMatch(ReferenceTreatmentOperations.treatsReferenceProperty(property)); }
/** * @since 1.3 */ public static Set<Variable> getLocalReferencesOfParameter(final Variable variable) { Preconditions.checkArgument(isParameter(variable), "Variable must represent a pattern parameter."); Pattern pattern = (Pattern) variable.eContainer(); return pattern.getBodies().stream().map(body -> body.getVariables().stream() .filter(ParameterRef.class::isInstance) .map(ParameterRef.class::cast) .filter(input -> input.getReferredParam().equals(variable))) .flatMap(i -> i) .collect(Collectors.toSet()); }
private void setDeclaredParameter(Pattern pattern, final VariableReference reference) { pattern.getParameters().stream().filter(variable -> Objects.equals(variable.getName(), reference.getVar())) .findFirst().ifPresent(reference::setVariable); }
public static boolean hasPureAnnotation(JvmOperation jvmOperation) { return jvmOperation.getAnnotations().stream() .anyMatch(ref -> Objects.equals(ref.getAnnotation().getQualifiedName(), Pure.class.getName())); } }
private Optional<DataOutPort> dataPortOut(final de.dentrassi.flow.Port in) { final Optional<Node> component = component(in.getComponent().getId()); return component.flatMap(c -> { return c.getPorts().stream().filter(p -> p instanceof DataOutPort && p.getName().equals(in.getPortName())) .map(p -> (DataOutPort) p) .findAny(); }); }
private Optional<TriggerOutPort> triggerPortOut(final de.dentrassi.flow.Port in) { final Optional<Node> component = component(in.getComponent().getId()); return component.flatMap(c -> { return c.getPorts().stream() .filter(p -> p instanceof TriggerOutPort && p.getName().equals(in.getPortName())) .map(p -> (TriggerOutPort) p) .findAny(); }); }
private Optional<TriggerInPort> triggerPortIn(final de.dentrassi.flow.Port in) { final Optional<Node> component = component(in.getComponent().getId()); return component.flatMap(c -> { return c.getPorts().stream().filter(p -> p instanceof TriggerInPort && p.getName().equals(in.getPortName())) .map(p -> (TriggerInPort) p) .findAny(); }); }
private Optional<DataInPort> dataPortIn(final de.dentrassi.flow.Port in) { final Optional<Node> component = component(in.getComponent().getId()); return component.flatMap(c -> { return c.getPorts().stream().filter(p -> p instanceof DataInPort && p.getName().equals(in.getPortName())) .map(p -> (DataInPort) p) .findAny(); }); }
@Override public void visit(final OperationCall operationCall) { final Duration duration = operationCall.getDuration(); final Duration durationsOfChildren = operationCall.getChildren().stream().map(c -> c.getDuration()) .reduce(Duration.ZERO, (r, d) -> r.plus(d)); final Duration durationWithoutChildren = duration.minus(durationsOfChildren); this.durationsWithoutChild.put(operationCall, durationWithoutChildren); }
private Enum manageEnum(EEnum obj) { final Enum e = Enum.of(getFullName(obj)); obj.getELiterals().stream().forEach(l -> e.addValue(l.getLiteral())); return e; }
private String getPathExpressionConstraintText(PathExpressionConstraint object, String prefix) { return String.format("%s%s.%s(%s, %s)", prefix, object.getSourceType().getClassname().getName(), object.getEdgeTypes().stream().map(t -> t.getRefname().getName()).collect(Collectors.joining(".")), object.getSrc().getVar(), this.doSwitch(object.getDst()) ); }