/** * Sets a default requirement for all newly added and existing row * processing component, unless they have another requirement. * * @param defaultRequirement */ public void setDefaultRequirement(final FilterOutcome defaultRequirement) { setDefaultRequirement(new SimpleComponentRequirement(defaultRequirement)); }
public void setRequirement(final FilterOutcome outcome) throws IllegalArgumentException { if (!validateRequirementCandidate(outcome)) { throw new IllegalArgumentException("Cyclic dependency detected when setting requirement: " + outcome); } if (outcome == null) { setComponentRequirement(null); } else if (outcome instanceof FilterOutcome) { setComponentRequirement(new SimpleComponentRequirement((FilterOutcome) outcome)); } else { throw new IllegalArgumentException( "Unsupported outcome type (use ComponentRequirement instead): " + outcome); } }
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); }
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; }
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); }
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); }
final Enum<?> outcome = fjb.getDescriptor().getOutcomeCategoryByName(category); final FilterOutcome filterOutcome = fjb.getFilterOutcome(outcome); final ComponentRequirement newRequirement = new SimpleComponentRequirement(filterOutcome); _componentBuilder.setComponentRequirement(newRequirement); onRequirementChanged();
componentBuilder.setComponentRequirement(new SimpleComponentRequirement( maxRowFilter.getFilterOutcome(MaxRowsFilter.Category.VALID)));
final FilterOutcome filterOutcome = _filterJobBuilder .getFilterOutcome(_filterJobBuilder.getDescriptor().getOutcomeCategoryByName(_categoryName)); final ComponentRequirement requirement = new SimpleComponentRequirement(filterOutcome);
@Override protected void configure(final AnalysisJobBuilder analysisJobBuilder, final ComponentBuilder componentBuilder) { final Component component = componentBuilder.getComponentInstance(); if (component instanceof PrecedingComponentConsumer) { final LifeCycleHelper helper = new LifeCycleHelper(analysisJobBuilder.getConfiguration(), null, true); helper.assignProvidedProperties(componentBuilder.getDescriptor(), component); ((PrecedingComponentConsumer) component) .configureForFilterOutcome(analysisJobBuilder, _filterJobBuilder.getDescriptor(), _categoryName); } final FilterOutcome outcome = _filterJobBuilder.getFilterOutcome(_categoryName); final ComponentRequirement requirement = new SimpleComponentRequirement(outcome); componentBuilder.setComponentRequirement(requirement); }