Defines parameter mappings. One parameter can be mapped to multiple new names, so a list is used instead of a map as the input to this method.
187598
public void setMappings(List<String> mappings) {
        if (mappings.size() > 0) {
            @SuppressWarnings("unchecked") Pair<String, String>[] renames = (Pair<String, String>[])Array.newInstance(Pair.class, mappings.size());
            for (int i = 0; i < _renames.length; ++i) {
                String[] names = mappings.get(i).split("[ ,]+");
                renames[i] = new Pair<String, String>(names[0], names[1]);
            }
            _renames = renames;
        }
    }
959254
def add_mappings(self, defn: Definition, target: Dict) -> None:
        
        self.add_id_prefixes(defn)
        for mapping in defn.mappings:
            if '://' in mapping:
                target['@id'] = mapping
            else:
                if ':' not in mapping or len(mapping.split(':')) != 2:
                    raise ValueError(f"Definition {defn.name} = unrecognized mapping: {mapping}")
                ns = mapping.split(':')[0]
                self.add_prefix(ns)
                target['@id'] = defn.mappings[0]
421131
def set_params(self,**kwargs):
        
        for key,value in list(kwargs.items()):
            setattr(self,key,value)
158359
def _create_mappings(self, spec):
        
        ret = dict(zip(set(spec.fields), set(spec.fields)))
        ret.update(dict([(n, s.alias) for n, s in spec.fields.items() if s.alias]))
        return ret
75036
private static Map<String,String> parameterScanner(String parameters){
	
		String[] parametersArray = parameters.split(";");
		
		Map<String, String> localParametersMap = new HashMap<String, String>();
		
		for(int count=0;count < parametersArray.length; count++){
			String[] parameter  = parametersArray[count].split("=");
			localParametersMap.put(parameter[0], parameter[1]);
		}
		
		return localParametersMap;
	}
534598
def update_from(self, mapping):
        
        for key, value in mapping.items():
            if key in self:
                if isinstance(value, Parameter):
                    value = value.value
                self[key].value = value
692531
def merge_parameter_lists(*parameter_definitions):
    
    merged_parameters = {}
    for parameter_list in parameter_definitions:
        for parameter in parameter_list:
            key = (parameter['name'], parameter['in'])
            merged_parameters[key] = parameter
    return merged_parameters.values()
790826
protected Map<Character, List<Pair<FeaturePattern, FeatureReplacement>>> initMapping() {
		final Map<Character, List<Pair<FeaturePattern, FeatureReplacement>>> map = new TreeMap<>();
		if (!this.ruleReader.initializeConversions(map, this.context) && this.initializer != null) {
			this.initializer.initializeConversions((simpleName, source, target) -> {
				final char c = getKey(simpleName);
				if (c == FeaturePattern.ALL_PATTERN_CHAR) {
					for (int i = 'a'; i <= 'z'; ++i) {
						createMappingEntry(map, (char) i, source, target);
					}
				} else {
					createMappingEntry(map, c, source, target);
				}
			});
		}
		return map;
	}
258525
private void updateMethodParameters(final Set<MethodParameter> parameters, final Set<MethodParameter> additional) {
        additional.forEach(a -> {
            // remove preexisting parameters with identical names
            final Optional<MethodParameter> existingParameter = parameters.stream().filter(p -> p.getName().equals(a.getName())).findAny();
            existingParameter.ifPresent(parameters::remove);
            parameters.add(a);
        });
    }
225338
def define_parameters(**parameters):
    """"""
    params = []
    for key, value in parameters.items():
        param = dict(ParameterKey=key, ParameterValue=value)
        params.append(param)
    return params
525148
private static void setParams(Map<String, ?> map) {
        for (String name : map.keySet()) {
            setParam(name, map.get(name));
        }
    }
844054
static Map<String, List<Integer>> updateParameterNamesToIndexes(Map<String, List<Integer>> parametersNameToIndex,
                                                                    List<ArrayParameter> arrayParametersSortedAsc) {
        for(Map.Entry<String, List<Integer>> parameterNameToIndexes : parametersNameToIndex.entrySet()) {
            List<Integer> newParameterIndex = new ArrayList<>(parameterNameToIndexes.getValue().size());
            for(Integer parameterIndex : parameterNameToIndexes.getValue()) {
                newParameterIndex.add(computeNewIndex(parameterIndex, arrayParametersSortedAsc));
            }
            parameterNameToIndexes.setValue(newParameterIndex);
        }

        return parametersNameToIndex;
    }
844464
def map_parameters(cls, params):
        """"""

        d = {}
        for k, v in six.iteritems(params):
            d[cls.FIELD_MAP.get(k.lower(), k)] = v
        return d
207977
def alias(cls, typemap, base, *names):
        
        cls.parameter_alias[base] = (typemap, base)
        for i in names:
            cls.parameter_alias[i] = (typemap, base)
1283614
public static void addParameter(MethodDeclaration method, Parameter parameter) {
        List<Parameter> parameters = method.getParameters();
        if (parameters == null) {
            parameters = new ArrayList<Parameter>();
            method.setParameters(parameters);
        }
        parameters.add(parameter);
    }
1167790
@SuppressWarnings({ "unchecked", "rawtypes" })
    public Map<String, List<String>> parameters() {
        return (Map<String, List<String>>) (Map) parameters.asMap();
    }
705464
@SuppressWarnings("unchecked")
  public Request addParameter(String name, Object value) {
    Map<String, Object> map = Objects.requireNonNull(parameterMap);
    if (!map.containsKey(name)) {
      map.put(name, value);
    } else {
      Object value0 = map.get(name);
      if (value0 instanceof Collection) {
        if (value instanceof Collection) {
          ((Collection) value0).addAll((Collection) value);
        } else {
          ((Collection) value0).add(value);
        }
      } else {
        List<Object> paramArray = new LinkedList<>();
        if (value instanceof Collection) {
          paramArray.addAll((Collection) value);
        } else {
          paramArray.add(value);
        }
        map.put(name, paramArray);
      }
    }
    return this;
  }