@Override public Collection<FilterOutcome> getProcessingDependencies() { return getOutcomes(); }
protected boolean isCompoundRequirementLink(final JobGraphLink link) { final ComponentRequirement req = link.getRequirement(); final Object from = link.getFrom(); if (req instanceof CompoundComponentRequirement && from instanceof HasFilterOutcomes) { if (((CompoundComponentRequirement) req).hasMultipleRequirementsFrom((HasFilterOutcomes) from)) { return true; } } return false; }
public ComponentRequirement load(final ComponentRequirement req) { if (req instanceof SimpleComponentRequirement) { final FilterOutcome originalOutcome = ((SimpleComponentRequirement) req).getOutcome(); final FilterOutcome loadedOutcome = load(originalOutcome); if (loadedOutcome != originalOutcome) { return new SimpleComponentRequirement(loadedOutcome); } } else if (req instanceof CompoundComponentRequirement) { boolean changed = false; final CompoundComponentRequirement componentRequirement = (CompoundComponentRequirement) req; final Set<FilterOutcome> originalOutcomes = componentRequirement.getOutcomes(); final List<FilterOutcome> loadedOutcomes = new ArrayList<>(originalOutcomes.size()); for (final FilterOutcome originalOutcome : originalOutcomes) { final FilterOutcome loadedOutcome = load(originalOutcome); if (loadedOutcome != originalOutcome) { changed = true; } loadedOutcomes.add(loadedOutcome); } if (changed) { return new CompoundComponentRequirement(loadedOutcomes); } } return req; }
@Override public <T> Component getEdgeLabelRendererComponent(final JComponent vv, final Object value, final Font font, final boolean isSelected, final T edge) { final String labelText; final String iconPath; if (edge instanceof JobGraphLink) { final JobGraphLink link = (JobGraphLink) edge; if (link.getOutputDataStream() != null) { labelText = link.getLinkLabel(); iconPath = IconUtils.OUTPUT_DATA_STREAM_PATH; } else if (isCompoundRequirementLink(link)) { final HasFilterOutcomes from = (HasFilterOutcomes) link.getFrom(); final CompoundComponentRequirement req = (CompoundComponentRequirement) link.getRequirement(); final Set<FilterOutcome> outcomesFrom = req.getOutcomesFrom(from); labelText = new CompoundComponentRequirement(outcomesFrom).getSimpleName(); iconPath = IconUtils.FILTER_OUTCOME_PATH; } else { labelText = link.getLinkLabel(); iconPath = IconUtils.FILTER_OUTCOME_PATH; } } else { labelText = value + ""; iconPath = IconUtils.FILTER_OUTCOME_PATH; } final Icon icon = imageManager.getImageIcon(iconPath, IconUtils.ICON_SIZE_SMALL); final JLabel label = new JLabel(labelText, icon, JLabel.LEFT); label.setFont(_normalFont); return label; } };
private ComponentRequirement getRequirement(final String ref, final Map<String, FilterOutcome> outcomeMapping) { if (AnyComponentRequirement.KEYWORD.equals(ref)) { return AnyComponentRequirement.get(); } // check for simple component requirements { final FilterOutcome filterOutcome = outcomeMapping.get(ref); if (filterOutcome != null) { return new SimpleComponentRequirement(filterOutcome); } } // check for compound component requirements final List<String> tokens = Lists.newArrayList(Splitter.on(" OR ").omitEmptyStrings().trimResults().split(ref)); if (tokens.size() > 1) { final List<FilterOutcome> list = new ArrayList<>(tokens.size()); for (final String token : tokens) { final FilterOutcome filterOutcome = outcomeMapping.get(token); if (filterOutcome == null) { throw new ComponentConfigurationException( "Could not resolve outcome '" + token + "' in requirement: " + ref); } list.add(filterOutcome); } return new CompoundComponentRequirement(list); } throw new ComponentConfigurationException("Could not resolve requirement: " + ref); }
private ComponentRequirement findImportedRequirement(final ComponentRequirement originalRequirement, final Map<ComponentJob, ComponentBuilder> componentBuilders) { if (originalRequirement == null) { return null; } if (originalRequirement instanceof AnyComponentRequirement) { return AnyComponentRequirement.get(); } if (originalRequirement instanceof SimpleComponentRequirement) { final FilterOutcome originalFilterOutcome = ((SimpleComponentRequirement) originalRequirement).getOutcome(); final FilterOutcome newOutcome = findFilterOutcome(originalFilterOutcome, componentBuilders); return new SimpleComponentRequirement(newOutcome); } if (originalRequirement instanceof CompoundComponentRequirement) { final Set<FilterOutcome> originalOutcomes = ((CompoundComponentRequirement) originalRequirement).getOutcomes(); final Collection<FilterOutcome> newOutcomes = new HashSet<>(); for (final FilterOutcome originalOutcome : originalOutcomes) { final FilterOutcome newOutcome = findFilterOutcome(originalOutcome, componentBuilders); newOutcomes.add(newOutcome); } return new CompoundComponentRequirement(newOutcomes); } throw new UnsupportedOperationException("Unsupported requirement type: " + originalRequirement); }
protected void addOrSetFilterOutcomeAsRequirement(final ComponentBuilder componentBuilder, final FilterOutcome filterOutcome) { final ComponentRequirement existingRequirement = componentBuilder.getComponentRequirement(); if (existingRequirement == null) { // set a new requirement final ComponentRequirement requirement = new SimpleComponentRequirement(filterOutcome); componentBuilder.setComponentRequirement(requirement); return; } final ComponentRequirement defaultRequirement = componentBuilder.getAnalysisJobBuilder().getDefaultRequirement(); if (existingRequirement.equals(defaultRequirement)) { // override the default requirement final ComponentRequirement requirement = new SimpleComponentRequirement(filterOutcome); componentBuilder.setComponentRequirement(requirement); return; } // add outcome to a compound requirement final CompoundComponentRequirement requirement = new CompoundComponentRequirement(existingRequirement, filterOutcome); componentBuilder.setComponentRequirement(requirement); }
if (componentBuilder.getDescriptor().isMultiStreamComponent()) { componentBuilder.setComponentRequirement( new CompoundComponentRequirement(existingRequirement, maxRowFilter.getFilterOutcome(MaxRowsFilter.Category.VALID)));
private String getId(final ComponentRequirement requirement, final Map<FilterOutcome, String> outcomeMappings) { if (requirement instanceof AnyComponentRequirement) { return AnyComponentRequirement.KEYWORD; } if (requirement instanceof SimpleComponentRequirement) { final FilterOutcome outcome = ((SimpleComponentRequirement) requirement).getOutcome(); return getId(outcome, outcomeMappings, true); } if (requirement instanceof CompoundComponentRequirement) { final Set<FilterOutcome> outcomes = ((CompoundComponentRequirement) requirement).getOutcomes(); final StringBuilder sb = new StringBuilder(); for (final FilterOutcome outcome : outcomes) { if (sb.length() != 0) { sb.append(" OR "); } final String id = getId(outcome, outcomeMappings, true); sb.append(id); } return sb.toString(); } throw new UnsupportedOperationException("Unsupported ComponentRequirement type: " + requirement); }