/** * Convenience constructor to create a descriptor based on name alone. To * include additional parameters use Builder instead. * * @param name name used as unique identifier for this descriptor */ public VariableDescriptor(final String name) { this(new Builder(name)); }
/** * @return a VariableDescriptor as configured * */ public VariableDescriptor build() { return new VariableDescriptor(this); } }
@Override public String getVariableValue(final String name) { if (name == null) { return null; } final VariableDescriptor descriptor = new VariableDescriptor(name); final String value = getVariableMap().get(descriptor); if (value != null) { return value; } return parent.getVariableValue(descriptor); }
/** * Returns the VariableDescriptor for the given key name if it exists. * * @param name the string name of the VariableDescriptor to lookup. * @return the variable descriptor registered for this name if it exists; * null otherwise */ default VariableDescriptor getVariableKey(final String name) { if (name == null) { return null; } final VariableDescriptor spec = new VariableDescriptor(name); for (final Map.Entry<VariableDescriptor, String> entry : getVariableMap().entrySet()) { if (entry.getKey().equals(spec)) { return entry.getKey(); } } return null; }
@Override public String removeVariable(final String name) { Objects.requireNonNull(name); return variableRegistry.removeVariable(new VariableDescriptor.Builder(name).build()); }
@Override public Set<Entry<String, String>> entrySet() { final Map<String, String> newMap = new HashMap<>(); //put variable registry entries first for (final Map.Entry<VariableDescriptor, String> entry : registry.getVariableMap().entrySet()) { newMap.put(entry.getKey().getName(), entry.getValue()); } //put attribute maps in reverse order final List<Map<String,String>> listOfMaps = new ArrayList<>(maps); Collections.reverse(listOfMaps); for(final Map<String,String> map : listOfMaps){ for(final Map.Entry<String, String> entry : map.entrySet()){ newMap.put(entry.getKey(), entry.getValue()); } } return newMap.entrySet(); }
/** * Gets the variable value * * @param name the string name of the VariableDescriptor that is the key of * the value to lookup. * @return the value associated with the given variable name if found; null * otherwise */ default String getVariableValue(final String name) { if (name == null) { return null; } return getVariableMap().get(new VariableDescriptor(name)); }
private ComponentSearchResultDTO search(final String searchStr, final ProcessGroup group) { final List<String> matches = new ArrayList<>(); final ProcessGroup parent = group.getParent(); if (parent == null) { return null; } addIfAppropriate(searchStr, group.getIdentifier(), "Id", matches); addIfAppropriate(searchStr, group.getVersionedComponentId().orElse(null), "Version Control ID", matches); addIfAppropriate(searchStr, group.getName(), "Name", matches); addIfAppropriate(searchStr, group.getComments(), "Comments", matches); final ComponentVariableRegistry varRegistry = group.getVariableRegistry(); if (varRegistry != null) { final Map<VariableDescriptor, String> variableMap = varRegistry.getVariableMap(); for (final Map.Entry<VariableDescriptor, String> entry : variableMap.entrySet()) { addIfAppropriate(searchStr, entry.getKey().getName(), "Variable Name", matches); addIfAppropriate(searchStr, entry.getValue(), "Variable Value", matches); } } if (matches.isEmpty()) { return null; } final ComponentSearchResultDTO result = new ComponentSearchResultDTO(); result.setId(group.getIdentifier()); result.setName(group.getName()); result.setGroupId(parent.getIdentifier()); result.setMatches(matches); return result; }
@Override public VariableDescriptor getVariableKey(final String name) { if (name == null) { return null; } final VariableDescriptor spec = new VariableDescriptor(name); for (final Map.Entry<VariableDescriptor, String> entry : getVariableMap().entrySet()) { if (entry.getKey().equals(spec)) { return entry.getKey(); } } return null; }
/** * Gets the variable value * * @param descriptor the descriptor for which to lookup the variable value. * @return the variable value if the given descriptor is equivalent to one * of the entries in the registry; null otherwise */ default String getVariableValue(final VariableDescriptor descriptor) { if (descriptor == null) { return null; } return getVariableMap().get(descriptor); }
@Override public String getVariableValue(final VariableDescriptor descriptor) { if (descriptor == null) { return null; } final String value = getVariableMap().get(descriptor); if (value != null) { return value; } return parent.getVariableValue(descriptor); } }
private void populateVariableNames(final ProcessGroup group, final Set<String> variableNames) { if (group == null) { return; } group.getVariableRegistry().getVariableMap().keySet().stream() .map(VariableDescriptor::getName) .forEach(variableNames::add); populateVariableNames(group.getParent(), variableNames); }
@Override public void setVariables(final Map<String, String> variables) { writeLock.lock(); try { verifyCanUpdateVariables(variables); if (variables == null) { return; } final Map<VariableDescriptor, String> variableMap = new HashMap<>(); variables.entrySet() // cannot use Collectors.toMap because value may be null .forEach(entry -> variableMap.put(new VariableDescriptor(entry.getKey()), entry.getValue())); variableRegistry.setVariables(variableMap); } finally { writeLock.unlock(); } }
@Override public String get(Object key) { if (key == null) { return null; } for (final Map<String, String> map : maps) { final String val = map.get(key.toString()); if (val != null) { return val; } } return registry.getVariableValue(key.toString()); }
private Set<String> getUpdatedVariables(final ProcessGroup group, final Map<String, String> newVariableValues) { final Set<String> updatedVariableNames = new HashSet<>(); final ComponentVariableRegistry registry = group.getVariableRegistry(); for (final Map.Entry<String, String> entry : newVariableValues.entrySet()) { final String varName = entry.getKey(); final String newValue = entry.getValue(); final String curValue = registry.getVariableValue(varName); if (!Objects.equals(newValue, curValue)) { updatedVariableNames.add(varName); } } return updatedVariableNames; }
private void populateKnownVariableNames(final ProcessGroup group, final Set<String> knownVariables) { group.getVariableRegistry().getVariableMap().keySet().stream() .map(VariableDescriptor::getName) .forEach(knownVariables::add); final ProcessGroup parent = group.getParent(); if (parent != null) { populateKnownVariableNames(parent, knownVariables); } }
@Override public boolean containsKey(Object key) { if (key == null) { return false; } if (maps.stream().anyMatch((map) -> (map.containsKey(key)))) { return true; } return registry.getVariableKey(key.toString()) != null; }
@Override public void setVariable(final String name, final String value) { Objects.requireNonNull(name); Objects.requireNonNull(value); final VariableDescriptor descriptor = new VariableDescriptor.Builder(name).build(); variableRegistry.setVariable(descriptor, value); }
@Override public boolean isEmpty() { for (final Map<String, String> map : maps) { if (!map.isEmpty()) { return false; } } return registry.getVariableMap().isEmpty(); }