<p>
The request omitted one or more required parameters.
</p>

@return The request omitted one or more required parameters.
8974
@com.fasterxml.jackson.annotation.JsonProperty("RequiredParameters")
    public java.util.List<String> getRequiredParameters() {
        return requiredParameters;
    }
1068408
public Map<String, Object> getHiddenParams()
    {
        Map<String, Object> mapParams = super.getHiddenParams();
        if (this.getTask() instanceof ServletTask)
            mapParams = ((ServletTask)this.getTask()).getRequestProperties(((ServletTask)this.getTask()).getServletRequest(), false);
        mapParams.remove(DBParams.USER_NAME);
        mapParams.remove(DBParams.USER_ID);
        return mapParams;
    }
1182687
public String allParamsAsRequest() {

        StringBuffer retValue = new StringBuffer(512);
        HttpServletRequest request = getJsp().getRequest();
        Iterator<String> paramNames = request.getParameterMap().keySet().iterator();
        while (paramNames.hasNext()) {
            String paramName = paramNames.next();
            String paramValue = request.getParameter(paramName);
            retValue.append(
                paramName + "=" + CmsEncoder.encode(paramValue, getCms().getRequestContext().getEncoding()));
            if (paramNames.hasNext()) {
                retValue.append("&");
            }
        }
        return retValue.toString();
    }
1242031
public Collection<Parameter<?>> getParameters() {
        if (_parameters == null) {
            return Collections.<Parameter<?>>emptyList();
        }
        
        return Collections.unmodifiableCollection(_parameters);
    }
213763
@Override
    public Set<String> paramKeys() {
        Set<String> set = new HashSet<String>();
        set.addAll(C.<String>list(request.paramNames()));
        set.addAll(extraParams.keySet());
        set.addAll(bodyParams().keySet());
        set.remove("_method");
        set.remove("_body");
        return set;
    }
82956
private void validateRequiredParams() {
        String[] uriStrings = getURI().split("\\?");       
        if (uriStrings.length > 0) {
	        List<String> requiredParms = extractRequiredParamsInURI(uriStrings[0]);
	        for (String param: requiredParms) {
	        	Utils.require(commandParams.containsKey(param), "missing param: " + param); 
	        }
        }
        if (metadataJson.containsKey(INPUT_ENTITY)) {
            String paramValue = metadataJson.getString(INPUT_ENTITY);
            if (paramValue != null) {
                JsonObject parametersNode = metadataJson.getJsonObject(PARAMETERS);
                if (parametersNode != null) {
                    if (parametersNode.keySet().size() == 1) {//parent node usually "params" 
                        JsonObject params = parametersNode.getJsonObject(parametersNode.keySet().iterator().next());
                        for (String param: params.keySet()) {
                            JsonObject paramNode = params.getJsonObject(param);                     
                            if (paramNode.keySet().contains(_REQUIRED)) {                                     
                                setCompound(true);
                                Utils.require(commandParams.containsKey(param), "missing param: " + param); 
                            }               
                        }       
                    }
                }
                else {
                    Utils.require(commandParams.containsKey(paramValue), "missing param: " + paramValue);       
                }
            }
        }       
 
    }
652480
public URLNormalizer removeEmptyParameters() {
        // Does it have query parameters?
        if (!url.contains("?")) {
            return this;
        }
        // It does, so proceed
        List<String> keyValues = new ArrayList<>();
        String queryString = StringUtils.substringAfter(url, "?");
        String[] params = StringUtils.split(queryString, '&');
        for (String param : params) {
            if (param.contains("=")
                    && StringUtils.isNotBlank(
                    StringUtils.substringAfter(param, "="))
                    && StringUtils.isNotBlank(
                    StringUtils.substringBefore(param, "="))) {
                keyValues.add(param);
            }
        }
        String cleanQueryString = StringUtils.join(keyValues, '&');
        if (StringUtils.isNotBlank(cleanQueryString)) {
            url = StringUtils.substringBefore(
                    url, "?") + "?" + cleanQueryString;
        }
        return this;
    }
508006
public T requestInstance() {
		T a;
		if( unused.size() > 0 ) {
			a = unused.pop();
		} else {
			a = createInstance();
		}
		return a;
	}
1156830
public HttpRequest withoutParameter(String parameter) {
		if(Strings.isValid(parameter)) {
			for(HttpParameter p : parameters) {
				if(parameter.equals(p.getName())) {
					parameters.remove(p);
				}
			}
		}
		return this;
	}
1952
public java.util.List<String> getRemoveAllowedPrincipals() {
        if (removeAllowedPrincipals == null) {
            removeAllowedPrincipals = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return removeAllowedPrincipals;
    }
440374
public List<?> getNotSelected() {
		List options = getOptions();
		if (options == null || options.isEmpty()) {
			return Collections.EMPTY_LIST;
		}

		List notSelected = new ArrayList(options);
		notSelected.removeAll(getSelected());
		return Collections.unmodifiableList(notSelected);
	}
1296781
public Type getMissingDropped()
    {
        List<Integer> hasNoMissing = new IntList();
        for (int i = 0; i < size(); i++)
        {
            DataPoint dp = getDataPoint(i);
            boolean missing =  dp.getNumericalValues().countNaNs() > 0;
            for(int c : dp.getCategoricalValues())
                if(c < 0)
                    missing = true;
            if(!missing)
                hasNoMissing.add(i);
        }
        return getSubset(hasNoMissing);
    }
186375
public List<ReqUrl> getReqUrls() {

        String url = this.getClassMappingUrl(this.getParentClass());
        RequestAnnotation requestAnnotation = new RequestAnnotation(this.getParentMethod());

        url += this.getRequestMappingUrl(requestAnnotation.getValue());

        List<ReqUrl> list = new ArrayList<>();

        for (RequestMethod requestMethod : requestAnnotation.getMethod()) {
            list.add(new ReqUrl(requestMethod.name(), url));
        }
        return list;
    }
972259
public boolean allParamsEmpty()
    {
        return ( StringUtils.isEmpty( family ) && StringUtils.isEmpty( arch ) && StringUtils.isEmpty( name ) && StringUtils.isEmpty( version ) );

    }
270123
@Override
    public Iterator<String> getExcludedValidatorIds()
    {
        if (_excludedValidatorIdsStack != null && !_excludedValidatorIdsStack.isEmpty())
        {
            return _excludedValidatorIdsStack.iterator();
        }
        return null;
    }
913009
public String allParamsAsHidden() {

        StringBuffer result = new StringBuffer(512);
        Map<String, Object> params = allParamValues();
        Iterator<Entry<String, Object>> i = params.entrySet().iterator();
        while (i.hasNext()) {
            Entry<String, Object> entry = i.next();
            result.append("<input type=\"hidden\" name=\"");
            result.append(entry.getKey());
            result.append("\" value=\"");
            String encoded = CmsEncoder.encode(entry.getValue().toString(), getCms().getRequestContext().getEncoding());
            result.append(encoded);
            result.append("\">\n");
        }
        return result.toString();
    }
1365812
public Excerpt typeParameters() {
    if (getTypeParameters().isEmpty()) {
      return Excerpts.EMPTY;
    } else {
      return Excerpts.add("<%s>", Excerpts.join(", ", getTypeParameters()));
    }
  }