Returns an object representing the value of OUT parameter parameterName and uses map for the custom mapping of the parameter value.
196150
@Override
    public Object getObject(String parameterName, Map<String,Class<?>> map) throws SQLException
    {
        checkClosed();
        throw SQLError.noSupport();
    }
1265725
def create_parameter_map(self):
        
        names = self.modelInstance.names
        db = self.modelInstance.database['items']
        parameter_map = {}
        
        def get_names_index(my_thing):
            return[i for i, x in enumerate(names) if x == my_thing][0]
        
        for k, this_item in db.items():
            if this_item['type'] == 'process':
                production_id = [x['input'] for x in this_item['exchanges'] if x['type'] == 'production'][0]
                input_ids = [x['input'] for x in this_item['exchanges'] if x['type'] == 'technosphere']
                production_index = get_names_index(db[production_id]['name'])
                input_indexes = [get_names_index(db[x]['name']) for x in input_ids]
                parameter_ids = ['n_p_{}_{}'.format(x, production_index) for x in input_indexes]
                parameter_map_items = {(input_ids[n], k): parameter_ids[n] for n, x in enumerate(input_ids)}
                #check = [self.modelInstance.params[x]['description'] for x in parameter_ids]
                #print(check)
                #print(parameter_map_items)
                parameter_map.update(parameter_map_items)
                
        self.parameter_map = parameter_map
1155679
@Override
    public Object convertParameter(Iterator<Object> parameters) {
        return binding.toColumnValue(parameters.next());
    }
480731
private Map<String, Object> convertParametersToMap(ParametersWithBasePath parametersWithBasePath) {

        Map<String, Object> output = new HashMap<>();
        for (Parameter param : parametersWithBasePath.parameters) {
            switch (param.getType()) {
                case "StringList":
                    // command delimited list back into a set/list and exvalues value to be key=value,key=value
                    String[] items = param.getValue().split(",");
                    for (String item : items) {
                        // now split to key value
                        String[] keyValue = item.split("=");
                        if (keyValue.length > 1) {
                            output.put(keyValue[0], keyValue[1]);
                        } else {
                            addKeyFromPath(output, parametersWithBasePath, param, keyValue[0]);
                        }
                    }
                    break;

                case "SecureString":
                    // if decrypt is set to true on request KMS is supposed to decrypt these for us otherwise we get
                    // back an encoded encrypted string of gobbly gook. It uses the default account key unless
                    // one is specified in the config
                    String[] keyValue = param.getValue().split("=");
                    if (keyValue.length > 1) {
                        output.put(keyValue[0], keyValue[1]);
                    } else {
                        addKeyFromPath(output, parametersWithBasePath, param, keyValue[0]);
                    }

                    break;

                default:
                case "String":
                    String[] keyVal = param.getValue().split("=");
                    if (keyVal.length > 1) {
                        output.put(keyVal[0], keyVal[1]);
                    } else {
                        addKeyFromPath(output, parametersWithBasePath, param, keyVal[0]);
                    }
                    break;
            }
        }
        return output;

    }
521976
def _namify_arguments(mapping):
    
    result = []
    for name, parameter in mapping.iteritems():
        parameter.name = name
        result.append(parameter)
    return result
284034
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.String> getParams() {
    return getParamsMap();
  }
140460
public Map<String, String> getParametersToMap(Map<String, String> map) {
        if (map == null) map = new LinkedHashMap<>();
        final Map<String, String> map0 = map;
        getParameters().forEach((k, v) -> map0.put(k, v));
        return map0;
    }
302034
private Object getParameterValue(ControlBeanContext context, Method method, Object[] args) {
        Object value;
        try {
            value = context.getParameterValue(method, _nameQualifiers[0], args);
        } catch (IllegalArgumentException iae) {
            throw new ControlException("Invalid argument name in SQL statement: " + _nameQualifiers[0], iae);
        }

        for (int i = 1; i < _nameQualifiers.length; i++) {
            // handle maps, properties, and fields...
            value = extractValue(value, _nameQualifiers[i - 1], _nameQualifiers[i]);
        }
        return value;
    }
924395
@Override
	public SqlContext inOutParam(final String parameterName, final Object value, final SQLType sqlType) {
		if (value instanceof Optional) {
			Optional<?> optionalValue = (Optional<?>) value;
			if (optionalValue.isPresent()) {
				param(new InOutParameter(parameterName, optionalValue.get(), sqlType));
			} else {
				param(new InOutParameter(parameterName, null, JDBCType.NULL));
			}
			return this;
		} else {
			return param(new InOutParameter(parameterName, value, sqlType));
		}
	}
484387
def from_mapping(cls, mapping):
        
        group = cls()
        for name, value in mapping.items():
            if name.startswith('_'):
                continue
            group[name] = Parameter(
                name=name,
                value=value,
                constraint=Parameter.constraint_from_type(value),
            )
        return group
128297
protected Map<String, List<Object>> getParameters() {
        List<ActionParameter> actionList = parameterBuilder.build();
        return ImmutableMap.of("actions", actionList.stream()
                .map(ActionParameter::getParameterMap).collect(toList()));
    }
526465
def from_map(map):
        
        skip = map.get_as_nullable_integer("skip")
        take = map.get_as_nullable_integer("take")
        total = map.get_as_nullable_boolean("total")
        return PagingParams(skip, take, total)
239690
@Override
    public MapAttribute<? super X, ?, ?> getMap(String paramName)
    {
        PluralAttribute<? super X, ?, ?> declaredAttrib = getDeclaredPluralAttribute(paramName);

        if (isMapAttribute(declaredAttrib))
        {
            return (MapAttribute<X, ?, ?>) declaredAttrib;
        }

        declaredAttrib = getPluralAttriute(paramName);

        if (isMapAttribute(declaredAttrib))
        {
            return (MapAttribute<X, ?, ?>) declaredAttrib;
        }

        throw new IllegalArgumentException(
                "attribute of the given name and type is not present in the managed type, for name:" + paramName);
    }
348119
public Map/*< String, List< String > >*/ getParameters()
    {
        if(_parameters == null || !_parameters.hasParameters())
            return Collections.EMPTY_MAP;
        else return _parameters.getParameters();
    }
151666
@Override
    public Map<String, List<String>> parameters() {
        Map<String, List<String>> result = new HashMap<>();
        for (String key : request.params().names()) {
            result.put(key, request.params().getAll(key));
        }
        return result;
    }
803160
public static Map<String, Object> getParamMap(final Condition condition) {
    final Map<String, Object> params = new HashMap<String, Object>();
    if (!Strings.contains(condition.getContent(), "?")) {
      final List<String> paramNames = condition.getParamNames();
      /*
       * Abort check param and names for it will updated by params invocation
       * if (paramNames.size() > condition.getParams().size()) { throw new RuntimeException(
       * "condition params not set [" + condition.getContent() + "] with value:" +
       * condition.getParams()); }
       */
      for (int i = 0; i < paramNames.size(); i++) {
        if (i >= condition.getParams().size()) break;
        params.put(paramNames.get(i), condition.getParams().get(i));
      }
    }
    return params;
  }
996841
protected Map<String, Object> allParamValues() {

        List<Method> methods = paramGetMethods();
        Map<String, Object> map = new HashMap<String, Object>(methods.size());
        Iterator<Method> i = methods.iterator();
        while (i.hasNext()) {
            Method m = i.next();
            Object o = null;
            try {
                o = m.invoke(this, new Object[0]);
            } catch (InvocationTargetException ite) {
                // can usually be ignored
                if (LOG.isInfoEnabled()) {
                    LOG.info(ite);
                }
            } catch (IllegalAccessException eae) {
                // can usually be ignored
                if (LOG.isInfoEnabled()) {
                    LOG.info(eae);
                }
            }
            if (o == null) {
                o = "";
            }
            map.put(m.getName().substring(8).toLowerCase(), o);
        }
        return map;
    }