/*
(non-Javadoc)

@see
javax.persistence.criteria.CriteriaBuilder#parameter(java.lang.Class,
java.lang.String)
432064
@Override
    public <T> ParameterExpression<T> parameter(Class<T> arg0, String arg1)
    {
        // TODO Auto-generated method stub
        return null;
    }
151706
@Override
    public void setDate(int parameterIndex, Date x) throws SQLException {
        internalStmt.setDate(parameterIndex, x);
    }
1136152
public int setParameter(final PreparedStatement preparedStatement, final int index,
			final BindParameterMapperManager parameterMapperManager) throws SQLException {
		return setInParameter(preparedStatement, index, parameterMapperManager);
	}
508821
public <I> RequestHandler4<T, R, U, I> param(final Class<I> paramClass) {
    return new RequestHandler4<>(method, path, resolverParam1, resolverParam2, resolverParam3,
      ParameterResolver.path(3, paramClass),
      errorHandler);
  }
411461
@Override
	public void initParam(Object session) {
		super.initParam(session);
		
		this.session = (Session) session;
		for (AbstractParamPanel panel : super.getPanels()) {
			if (panel instanceof AbstractContextPropertiesPanel) {
				initContextPanel((AbstractContextPropertiesPanel) panel);
			}
		}
	}
18091
@Override
    public void setNString(int parameterIndex, String value) throws SQLException
    {
        checkParameterBounds(parameterIndex);
        throw SQLError.noSupport();
    }
114433
@Override
    public <T> Parameter<T> getParameter(int paramInt, Class<T> paramClass)
    {
        onNativeCondition();
        getParameters();
        Parameter parameter = getParameterByOrdinal(paramInt);
        return onTypeCheck(paramClass, parameter);
    }
75175
public static <T> QueryParameterValue of(T value, Class<T> type) {
    return of(value, classToType(type));
  }
865067
@Override
    public void addParameterAnnotation(int param, AnnotationValue annotationValue) {
        HashMap<Integer, Map<ClassDescriptor, AnnotationValue>> updatedAnnotations = new HashMap<>(
                methodParameterAnnotations);
        Map<ClassDescriptor, AnnotationValue> paramMap = updatedAnnotations.get(param);
        if (paramMap == null) {
            paramMap = new HashMap<>();
            updatedAnnotations.put(param, paramMap);
        }
        paramMap.put(annotationValue.getAnnotationClass(), annotationValue);

        methodParameterAnnotations = updatedAnnotations;
        TypeQualifierApplications.updateAnnotations(this);
    }
86317
public static void parametersUsageNotAllowed(String methodName, String className){
		throw new DynamicConversionParameterException(MSG.INSTANCE.message(dynamicConversionParameterException,methodName,className));
	}
1331690
@Override
    public String getParameter(String name) {
        String[] vals = getParameterMap().get(name);

        return (vals != null && vals.length > 0) ? vals[0] : null;
    }
652899
public RequestBuilder<T,ID> setParameter(String name,String value)
    {
        parameters.set(name, value);
        return this;
    }
130307
@SuppressWarnings("unchecked")
	private static void bindRequestParameters(UriComponentsBuilder builder,
			AnnotatedParametersParameterAccessor.BoundMethodParameter parameter) {

		Object value = parameter.getValue();
		String key = parameter.getVariableName();

		if (value instanceof MultiValueMap) {

			MultiValueMap<String, String> requestParams = (MultiValueMap<String, String>) value;

			for (Map.Entry<String, List<String>> multiValueEntry : requestParams.entrySet()) {
				for (String singleEntryValue : multiValueEntry.getValue()) {
					builder.queryParam(multiValueEntry.getKey(), encodeParameter(singleEntryValue));
				}
			}

		} else if (value instanceof Map) {

			Map<String, String> requestParams = (Map<String, String>) value;

			for (Map.Entry<String, String> requestParamEntry : requestParams.entrySet()) {
				builder.queryParam(requestParamEntry.getKey(), encodeParameter(requestParamEntry.getValue()));
			}

		} else if (value instanceof Collection) {

			for (Object element : (Collection<?>) value) {
				if (key != null) {
					builder.queryParam(key, encodeParameter(element));
				}
			}

		} else if (SKIP_VALUE.equals(value)) {

			if (parameter.isRequired()) {
				if (key != null) {
					builder.queryParam(key, String.format("{%s}", parameter.getVariableName()));
				}
			}

		} else {
			if (key != null) {
				builder.queryParam(key, encodeParameter(parameter.asString()));
			}
		}
	}
1155679
@Override
    public Object convertParameter(Iterator<Object> parameters) {
        return binding.toColumnValue(parameters.next());
    }
1037519
void addParameter(String parameter) {

        TextField textField = new TextField();
        if (parameter != null) {
            textField.setValue(parameter);
        }
        CmsRemovableFormRow<TextField> row = new CmsRemovableFormRow<TextField>(
            textField,
            CmsVaadinUtils.getMessageText(Messages.GUI_SITE_REMOVE_PARAMETER_0));
        row.setCaption(CmsVaadinUtils.getMessageText(Messages.GUI_SITE_PARAMETER_0));
        row.setDescription(CmsVaadinUtils.getMessageText(Messages.GUI_SITE_PARAMETER_HELP_0));
        m_parameter.addComponent(row);
    }
1202112
@Override
    public <T> TypedQuery<X> setParameter(Parameter<T> arg0, T arg1)
    {
        query.setParameter(arg0, arg1);
        return this;
    }
1128433
private void _addParameter(String parameterName, String parameterValue) {
        if (parameterName == null) {
            throw new NullPointerException("parameterName");
        }
        if (parameterValue == null) {
            throw new NullPointerException("parameterValue");
        }
        List<String> parameterValues = _getParameterValues(parameterName);
        parameterValues.add(parameterValue);
    }