Initializes the values of the members.<p>

@param params the parameter map to get a value from
6362
protected void initMembers(Map<String, String> params) {

        clearDialogObject();

        m_webserverscript = getParameter(params, PARAM_WEBSERVER_SCRIPT, DEFAULT_PARAM_WEBSERVER_SCRIPT);
        m_targetpath = getParameter(params, PARAM_TARGET_PATH, DEFAULT_PARAM_TARGET_PATH);
        m_configtemplate = getParameter(params, PARAM_CONFIG_TEMPLATE, DEFAULT_PARAM_CONFIG_TEMPLATE);
        m_securetemplate = getParameter(params, PARAM_SECURE_TEMPLATE, DEFAULT_PARAM_SECURE_TEMPLATE);
        m_filenameprefix = getParameter(params, PARAM_FILENAME_PREFIX, DEFAULT_PARAM_FILENAME_PREFIX);
        m_loggingdir = getParameter(params, PARAM_LOGGING_DIR, DEFAULT_PARAM_LOGGING_DIR);

        if (DEFAULT_PARAM_WEBSERVER_SCRIPT.equals(m_webserverscript)
            || DEFAULT_PARAM_CONFIG_TEMPLATE.equals(m_configtemplate)
            || DEFAULT_PARAM_SECURE_TEMPLATE.equals(m_securetemplate)) {
            for (CmsExportPoint point : OpenCms.getModuleManager().getModule(MODULE_NAME).getExportPoints()) {
                if (DEFAULT_PATH_TEMPLATE.equals(point.getUri())) {
                    m_configtemplate = point.getDestinationPath();
                }
                if (DEFAULT_PATH_SECURE_TEMPLATE.equals(point.getUri())) {
                    m_securetemplate = point.getDestinationPath();
                }
                if (DEFAULT_PARAM_WEBSERVER_SCRIPT.equals(m_webserverscript)) {
                    if (DEFAULT_PATH_SCRIPT_WIDNOWS.equals(point.getUri()) && SystemUtils.IS_OS_WINDOWS) {
                        // only take the windows script if the OS is a windows
                        m_webserverscript = point.getDestinationPath();
                    } else if (DEFAULT_PATH_SCRIPT_LINUX.equals(point.getUri())) {
                        m_webserverscript = point.getDestinationPath();
                    }
                }
            }
        }

        if (DEFAULT_PARAM_TARGET_PATH.equals(m_targetpath)) {
            m_targetpath = PATH_WEBSERVER_CONFIG;
        }

        if (DEFAULT_PARAM_LOGGING_DIR.equals(m_loggingdir)) {
            m_loggingdir = SystemUtils.IS_OS_WINDOWS ? "" : DEFAULT_PATH_LOG_LINUX;
        }

        setDialogObject(this);
    }
557471
public void init(final MultivaluedMap<String, String> queryParameters) {
        final String scopeCompileParam = queryParameters.getFirst(ServerAPI.SCOPE_COMPILE_PARAM);
        if(scopeCompileParam != null){
            this.scopeComp = Boolean.valueOf(scopeCompileParam);
        }
        final String scopeProvidedParam = queryParameters.getFirst(ServerAPI.SCOPE_PROVIDED_PARAM);
        if(scopeProvidedParam != null){
            this.scopePro = Boolean.valueOf(scopeProvidedParam);
        }
        final String scopeRuntimeParam = queryParameters.getFirst(ServerAPI.SCOPE_RUNTIME_PARAM);
        if(scopeRuntimeParam != null){
            this.scopeRun = Boolean.valueOf(scopeRuntimeParam);
        }
        final String scopeTestParam = queryParameters.getFirst(ServerAPI.SCOPE_TEST_PARAM);
        if(scopeTestParam != null){
            this.scopeTest = Boolean.valueOf(scopeTestParam);
        }
    }
653625
@PostConstruct
    private void initialize() {
        final MultivaluedMap<String, String> queryParams = uriInfo.getQueryParameters();
        final String offset = multiParam(queryParams, "offset");
        final String page = multiParam(queryParams, "page", "pageNumber");
        final String size = multiParam(queryParams, "size", "pageSize", "limit");
        final String filter = multiParam(queryParams, "filter", "searchText");
        final String sort = multiParam(queryParams, "sort", "sortOrder");
        final OrderDirection orderDirection;
        String orderBy = multiParam(queryParams, "orderBy", "sortName");

        if (StringUtils.isBlank(orderBy) || !RegexSequence.Pattern.ALPHA_NUMERIC.matcher(orderBy).matches()) {
            orderBy = null;
        }

        if ("asc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.ASCENDING;
        } else if ("desc".equalsIgnoreCase(sort)) {
            orderDirection = OrderDirection.DESCENDING;
        } else {
            orderDirection = OrderDirection.UNSPECIFIED;
        }

        final Pagination pagination;
        if (StringUtils.isNotBlank(offset)) {
            pagination = new Pagination(Pagination.Strategy.OFFSET, offset, size);
        } else if (StringUtils.isNotBlank(page) && StringUtils.isNotBlank(size)) {
            pagination = new Pagination(Pagination.Strategy.PAGES, page, size);
        } else {
            pagination = new Pagination(Pagination.Strategy.OFFSET, 0, 100); // Always paginate queries from resources
        }
        this.alpineRequest = new AlpineRequest(getPrincipal(), pagination, filter, orderBy, orderDirection);
    }
866444
private String setParamsters(String value, final Object[] params) {
		for (int i = 0; i < params.length; i++) {
			value = value.replaceAll("\\{" + i + "\\}", params[i].toString());
		}
		return value;
	}
1121952
void addAnnotationParamDefaultValues(final AnnotationParameterValueList paramNamesAndValues) {
        if (this.annotationDefaultParamValues == null) {
            this.annotationDefaultParamValues = paramNamesAndValues;
        } else {
            this.annotationDefaultParamValues.addAll(paramNamesAndValues);
        }
    }
949937
public void init()
    {
        ServletContext config=getServletContext();
        _servletHandler=((ServletHandler.Context)config).getServletHandler();

        Enumeration e = getInitParameterNames();
        while(e.hasMoreElements())
        {
            String param=(String)e.nextElement();
            String value=getInitParameter(param);
            String lvalue=value.toLowerCase();
            if ("nonContextServlets".equals(param))
            {
                _nonContextServlets=value.length()>0 && lvalue.startsWith("t");
            }
            if ("verbose".equals(param))
            {
                _verbose=value.length()>0 && lvalue.startsWith("t");
            }
            else
            {
                if (_parameters==null)
                    _parameters=new HashMap();
                _parameters.put(param,value);
            }
        }
    }
1136535
public void addParameters(NameValuePair[] parameters) {
        log.trace("enter PostMethod.addParameters(NameValuePair[])");

        if (parameters == null) {
            log.warn("Attempt to addParameters(null) ignored");
        } else {
            super.clearRequestBody();
            for (int i = 0; i < parameters.length; i++) {
                this.params.add(parameters[i]);
            }
        }
    }
140237
@Override
    public void setParameter(Map<String, String> paraMap) {
        if (paraMap.containsKey("k")) {
            this.k = Integer.parseInt(paraMap.get("k"));
        }
        if (paraMap.containsKey("mode")) {
            this.mode = Integer.parseInt(paraMap.get("mode"));
        }
    }
260066
public void setParameterObjects(java.util.Collection<ParameterObject> parameterObjects) {
        if (parameterObjects == null) {
            this.parameterObjects = null;
            return;
        }

        this.parameterObjects = new com.amazonaws.internal.SdkInternalList<ParameterObject>(parameterObjects);
    }
280678
public void putParams(JSONObject params) throws JSONException {
        this.params = params;
        this.put(Defines.LinkParam.Data.getKey(), params);
    }
269972
public static void initDefaultParameterValues(QueryParameter param,
                                                  List<Serializable> defValues, Map<String, Object> parameterValues) throws QueryException {

        if (param.getSelection().equals(QueryParameter.SINGLE_SELECTION)) {
            parameterValues.put(param.getName(), defValues.get(0));
        } else {
            Object[] val = new Object[defValues.size()];
            for (int k = 0, size = defValues.size(); k < size; k++) {
                val[k] = defValues.get(k);
            }
            parameterValues.put(param.getName(), val);
        }
    }
1335210
def _initParams(self):
         
         params = SP.zeros(self.getNumberParams())
         self.setParams(params)
400250
<T> void parameters(Observable<T> params) {
        this.parameters = Observable.concat(parameters, params.map(Parameter.TO_PARAMETER));
    }
723222
private void setParameters(Map<Parameter, Object> parameterMap, Query q)
    {
        if (parameterMap != null && !parameterMap.isEmpty())
        {
            for (Parameter parameter : parameterMap.keySet())
            {
                Object paramObject = parameterMap.get(parameter);
                if (parameter.getName() != null)
                {
                    if (paramObject instanceof Collection)
                    {
                        q.setParameterList(parameter.getName(), (Collection) paramObject);
                    }
                    else
                    {
                        q.setParameter(parameter.getName(), paramObject);
                    }
                }
                else if (parameter.getPosition() != null)
                {
                    if (paramObject instanceof Collection)
                    {
                        q.setParameterList(Integer.toString(parameter.getPosition()), (Collection) paramObject);
                    }
                    else
                    {
                        q.setParameter(Integer.toString(parameter.getPosition()), paramObject);
                    }
                }
            }
        }
    }
1266670
public static void addParameters(final IRequestParameters parameters,
		final Map<String, String[]> parameterMap)
	{
		final Set<String> parameterNames = parameters.getParameterNames();
		for (final String parameterName : parameterNames)
		{
			final List<StringValue> parameterValues = parameters.getParameterValues(parameterName);
			String[] stringArray = { };
			if ((parameterValues != null) && !parameterValues.isEmpty())
			{
				stringArray = new String[parameterValues.size()];
				for (int i = 0; i < parameterValues.size(); i++)
				{
					stringArray[i] = parameterValues.get(i).toString();
				}
				if (parameterMap.containsKey(parameterName))
				{
					stringArray = ArrayUtils.addAll(parameterMap.get(parameterName), stringArray);
				}
			}
			parameterMap.put(parameterName, stringArray);
		}
	}
243814
protected void fillDefaultValues(Map<String, Value> params) {
        for (MethodParameter parameter : parameters.values()) {
            if (!parameter.isOptional() || parameter.getDefaultValue() == null || params.get(parameter.getName()) != null) continue;
            params.put(parameter.getName(), parameter.getDefaultValue());
        }
    }
1153348
public void setParams(Map<String, CharSequence> params) {
        if (this.params == null) {
            this.params = Collections.unmodifiableMap(params);
        } else {
            throw new IllegalStateException("Can't change parameters.");
        }
    }