/** * 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 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; }
public boolean validateRequirementCandidate(final ComponentRequirement requirement) { if (requirement instanceof SimpleComponentRequirement) { final SimpleComponentRequirement simpleComponentRequirement = (SimpleComponentRequirement) requirement; final FilterOutcome outcome = simpleComponentRequirement.getOutcome(); return validateRequirementCandidate(outcome); } return true; }
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); }
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 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 FilterOutcome outcome = ((SimpleComponentRequirement) defaultRequirement).getOutcome(); if (outcome instanceof LazyFilterOutcome) { sourceFilterJobBuilder = ((LazyFilterOutcome) outcome).getFilterJobBuilder();
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); }
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); }
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); }