<p>
A list of parameter values for the parameters of the application.
</p>

@param parameterOverrides
A list of parameter values for the parameters of the application.
766088
public void setParameterOverrides(java.util.Collection<ParameterValue> parameterOverrides) {
        if (parameterOverrides == null) {
            this.parameterOverrides = null;
            return;
        }

        this.parameterOverrides = new java.util.ArrayList<ParameterValue>(parameterOverrides);
    }
813863
public void setParameterGroupNames(java.util.Collection<String> parameterGroupNames) {
        if (parameterGroupNames == null) {
            this.parameterGroupNames = null;
            return;
        }

        this.parameterGroupNames = new java.util.ArrayList<String>(parameterGroupNames);
    }
186896
public void addParameters(Map<String, Object> parameters, boolean suppressNull) {
        
        for (String name : parameters.keySet()) {
            Object value = parameters.get(name);
            
            if (!suppressNull || value != null) {
                addParameter(name, value);
            }
        }
    }
794669
public static <T> T selectValue(T defaultValue, T... overrides) {
        for (T override : overrides) {
            if (override != null) {
                return override;
            }
        }
        return defaultValue;
    }
518243
public void setExtraParams(java.util.Collection<ExtraParam> extraParams) {
        if (extraParams == null) {
            this.extraParams = null;
            return;
        }

        this.extraParams = new com.amazonaws.internal.SdkInternalList<ExtraParam>(extraParams);
    }
1234157
public void setParameters(Parameterization config) {
    TrackParameters track = new TrackParameters(config);
    configureStep(track);

    // update parameter table
    {
      parameterTable.setEnabled(false);

      parameterTable.clear();
      for(TrackedParameter pair : track.getAllParameters()) {
        parameterTable.addParameter(pair.getOwner(), pair.getParameter(), track);
      }
      // parameters.updateFromTrackParameters(track);

      parameterTable.revalidate();
      parameterTable.setEnabled(true);
    }

    // Update status and notify observers
    updateStatus();
    firePanelUpdated();
  }
568688
private void overrideUseMavenPatterns(T overrider, Class overriderClass) {
        if (useMavenPatternsOverrideList.contains(overriderClass.getSimpleName())) {
            try {
                Field useMavenPatternsField = overriderClass.getDeclaredField("useMavenPatterns");
                useMavenPatternsField.setAccessible(true);
                Object useMavenPatterns = useMavenPatternsField.get(overrider);

                if (useMavenPatterns == null) {
                    Field notM2CompatibleField = overriderClass.getDeclaredField("notM2Compatible");
                    notM2CompatibleField.setAccessible(true);
                    Object notM2Compatible = notM2CompatibleField.get(overrider);
                    if (notM2Compatible instanceof Boolean && notM2Compatible != null) {
                        useMavenPatternsField.set(overrider, !(Boolean)notM2Compatible);
                    }
                }
            } catch (NoSuchFieldException | IllegalAccessException e) {
                converterErrors.add(getConversionErrorMessage(overrider, e));
            }
        }
    }
520355
private static void applyOverrides() {
        // Get the appropriate InputStream to read overrides from, if any.
        InputStream stream = getContentTypesPropertiesStream();
        if (stream == null) {
            return;
        }

        try {
            try {
                // Read the properties file...
                Properties overrides = new Properties();
                overrides.load(stream);
                // And translate its mapping to ours...
                for (Map.Entry<Object, Object> entry : overrides.entrySet()) {
                    String extension = (String) entry.getKey();
                    String mimeType = (String) entry.getValue();
                    add(mimeType, extension);
                }
            } finally {
                stream.close();
            }
        } catch (IOException ignored) {
        }
    }
1289642
public void addParameter(ISUPParameter param) throws ParameterException {
        if (param == null) {
            throw new IllegalArgumentException("Argument must not be null");
        }
        int paramCode = param.getCode();
        if (this.mandatoryCodes.contains(paramCode)) {
            int index = this.mandatoryCodeToIndex.get(paramCode);
            this.f_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        if (this.mandatoryVariableCodes.contains(paramCode)) {
            int index = this.mandatoryVariableCodeToIndex.get(paramCode);
            this.v_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }
        if (this.optionalCodes.contains(paramCode)) {
            int index = this.optionalCodeToIndex.get(paramCode);
            this.o_Parameters.put(index, (AbstractISUPParameter) param);
            return;
        }

        throw new ParameterException("Parameter with code: " + paramCode
                + " is not defined in any type: mandatory, mandatory variable or optional");
    }
373071
public String getOverrideForce(String configurationId, String parameterName) {
    Map<String, String> overrideForceScopeMapEntry = overrideForceScopeMap.get(configurationId);
    if (overrideForceScopeMapEntry != null) {
      return overrideForceScopeMapEntry.get(parameterName);
    }
    return null;
  }
743488
private void checkForOverride(Properties properties, String name, String attr, String value) {
		String propertyValue = properties.getProperty(attr);
		if (propertyValue != null && !propertyValue.equals(value)) {
			LOG.warn(name + ":an attempt to override final parameter: " + attr
					+ ";  Ignoring.");
		}
	}
217473
private OverriddenCucumberOptionsParameters overrideParametersWithCucumberOptions() throws MojoExecutionException {

        try {
            final OverriddenCucumberOptionsParameters overriddenParameters =
                new OverriddenCucumberOptionsParameters()
                    .setTags(tags)
                    .setGlue(glue)
                    .setStrict(strict)
                    .setPlugins(parseFormatAndPlugins(format, plugins == null ? new ArrayList<Plugin>() : plugins))
                    .setMonochrome(monochrome);


            if (cucumberOptions != null && cucumberOptions.length() > 0) {
                final RuntimeOptions options = new RuntimeOptions(cucumberOptions);
                overriddenParameters
                    .overrideTags(options.getFilters())
                    .overrideGlue(options.getGlue())
                    .overridePlugins(parsePlugins(options.getPluginNames()))
                    .overrideStrict(options.isStrict())
                    .overrideMonochrome(options.isMonochrome());
            }

            return overriddenParameters;
        } catch (IllegalArgumentException e) {
            throw new MojoExecutionException(this, "Invalid parameter. ", e.getMessage());
        }
    }
119898
public void addOverrideMap(Map<String, String> overrideMap) {
    if (sealed) {
      throw new IllegalStateException("Instance is sealed.");
    }
    for (Map.Entry<String, String> entry : overrideMap.entrySet()) {
      try {
        ParameterOverrideInfo info = new ParameterOverrideInfo(entry.getKey());
        if (info.isOverrideSystemDefault()) {
          putMapIfNotExsits(overrideSystemDefaultMap, info.getParameterName(), entry.getValue());
        }
        else if (StringUtils.isNotEmpty(info.getConfigurationId()))  {
          Map<String, String> overrideForceScopeMapEntry = overrideForceScopeMap.get(info.getConfigurationId());
          if (overrideForceScopeMapEntry == null) {
            overrideForceScopeMapEntry = new HashMap<>();
            overrideForceScopeMap.put(info.getConfigurationId(), overrideForceScopeMapEntry);
          }
          putMapIfNotExsits(overrideForceScopeMapEntry, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            Set<String> lockedParameterNamesScopeMapEntry = lockedParameterNamesScopeMap.get(info.getConfigurationId());
            if (lockedParameterNamesScopeMapEntry == null) {
              lockedParameterNamesScopeMapEntry = new HashSet<>();
              lockedParameterNamesScopeMap.put(info.getConfigurationId(), lockedParameterNamesScopeMapEntry);
            }
            putSetIfNotExsits(lockedParameterNamesScopeMapEntry, info.getParameterName());
          }
        }
        else {
          putMapIfNotExsits(overrideForceMap, info.getParameterName(), entry.getValue());
          if (info.isLocked()) {
            putSetIfNotExsits(lockedParameterNamesSet, info.getParameterName());
          }
        }
      }
      catch (IllegalArgumentException ex) {
        log.warn("Ignoring invalid parameter override definition:\n" + ex.getMessage());
      }
    }
  }
297860
@NotNull
    protected Map<String, Object> toParameterTypes(ParameterElement... parameters) {
        final LinkedHashMap<String, Object> map = new LinkedHashMap<>(parameters.length);
        for (ParameterElement ce : parameters) {
            final ClassElement type = ce.getType();
            if (type == null) {
                continue;
            }
            final Type typeReference = getTypeForElement(type);
            map.put(ce.getName(), typeReference);
        }

        return map;
    }
853206
@Override
    public void configure(String parameters) {
        if (parameters.isEmpty()) {
            return;
        }
        LinkedList<Double> values = new LinkedList<Double>();

        List<String> strValues = Op.split(parameters, " ");
        for (String strValue : strValues) {
            values.add(Op.toDouble(strValue));
        }

        if (values.size() % 2 == 0) {
            setHeight(1.0);
        } else {
            setHeight(values.removeLast());
        }
        setXY(toPairs(values));
    }
75810
public void setParameterGroups(java.util.Collection<ParameterGroup> parameterGroups) {
        if (parameterGroups == null) {
            this.parameterGroups = null;
            return;
        }

        this.parameterGroups = new java.util.ArrayList<ParameterGroup>(parameterGroups);
    }
891152
static List<Map<String, String>> convertOverrideToAttributes(AbstractInterfaceConfig config,
                                                                 String overridePath,
                                                                 List<ChildData> currentData)
        throws UnsupportedEncodingException {
        List<Map<String, String>> attributes = new ArrayList<Map<String, String>>();
        if (CommonUtils.isEmpty(currentData)) {
            return attributes;
        }

        for (ChildData childData : currentData) {
            String url = URLDecoder.decode(childData.getPath().substring(overridePath.length() + 1),
                "UTF-8");
            if (config instanceof ConsumerConfig) {
                //If child data contains system local host, convert config to attribute
                if (StringUtils.isNotEmpty(url) && StringUtils.isNotEmpty(SystemInfo.getLocalHost())
                    && url.contains("://" + SystemInfo.getLocalHost() + "?")) {
                    attributes.add(convertConfigToAttribute(overridePath, childData, false));
                }
            }
        }
        return attributes;
    }