Inner method to check if the current parameter should be excluded
@param param the param object
@return true if it need to be excluded
488105
private boolean isToExclude(NameValuePair param) {
        List<ScannerParamFilter> excludedParameters = getParameterExclusionFilters(param);
        
        // We can use the base one, we don't do anything with it
        HttpMessage msg = getBaseMsg();
        
        for (ScannerParamFilter filter : excludedParameters) {
            if (filter.isToExclude(msg, param)) {
                return true;
            }
        }
        
        return false;
    }
1030885
private boolean isExcludedBinding(Key<?> key) {
    Class<?> rawType = key.getTypeLiteral().getRawType();
    for (Class<?> excludedClass : excludedBindings) {
      if (excludedClass.isAssignableFrom(rawType)) {
        return true;
      }
    }

    return false;
  }
400821
boolean declareParam(JSTypeExpression jsType, String parameter) {
    lazyInitInfo();
    if (info.parameters == null) {
      info.parameters = new LinkedHashMap<>();
    }
    if (!info.parameters.containsKey(parameter)) {
      info.parameters.put(parameter, jsType);
      return true;
    } else {
      return false;
    }
  }
599263
protected boolean excluded(String url) {
        for (final Pattern urlPattern : this.excludedUrls) {
            final Matcher matcher = urlPattern.matcher(url);
            if (matcher.matches()) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Exclude pattern " + urlPattern.pattern() + " matches " + url);
                }
                return true;
            }
        }
        
        return false;
    }
726179
public void removeParameter( String name )
    {
        if (_parameters == null || !_parameters.hasParameters())
            return;

        _parameters.removeParameter(name);
    }
1289033
def is_valid_int_param(param):
    
    if param is None:
        return False
    try:
        param = int(param)
        if param < 0:
            return False
    except (TypeError, ValueError):
        return False
    return True
596056
public final void containsNoneIn(Iterable<?> excluded) {
    Collection<?> actual = iterableToCollection(actual());
    Collection<Object> present = new ArrayList<>();
    for (Object item : Sets.newLinkedHashSet(excluded)) {
      if (actual.contains(item)) {
        present.add(item);
      }
    }
    if (!present.isEmpty()) {
      failWithoutActual(
          fact("expected not to contain any of", annotateEmptyStrings(excluded)),
          fact("but contained", annotateEmptyStrings(present)),
          fullContents());
    }
  }
169154
public boolean hasDeclaredMethodParameterAnnotation(final String methodParameterAnnotationName) {
        for (final MethodInfo mi : getDeclaredMethodInfo()) {
            if (mi.hasParameterAnnotation(methodParameterAnnotationName)) {
                return true;
            }
        }
        return false;
    }
889595
def hasParam(self, paramName):
        
        if isinstance(paramName, basestring):
            p = getattr(self, paramName, None)
            return isinstance(p, Param)
        else:
            raise TypeError("hasParam(): paramName must be a string")
86608
public void addHiddenParam(PrintWriter out, String strParam, String strValue)
    {
        // Override this (if you don't want straight XML written)
        out.print("<param name=\"" + strParam + "\">");
        if (strValue != null)
            out.print(strValue);
        out.println(Utility.endTag("param"));
    }
2335
public void addFunctionParameter(final String param) {
    if (param == null || param.isEmpty()) {
      throw new IllegalArgumentException("Parameter cannot be null or empty");
    }
    if (func_params == null) {
      func_params = Lists.newArrayList();
    }
    func_params.add(param);
  }
997982
@Override
    public boolean hasValue(String paramName) {
        return criterias.containsKey(paramName) || LIMIT_NAME.equals(paramName)
                || OFFSET_NAME.equals(paramName);
    }
1256898
public int setParam(String param, Object value) {
        int i = findParam(param);
        
        if (value == null && i < 0) {
            return i;
        }
        
        if (i < 0) {
            i = extraInfo.length;
            extraInfo = Arrays.copyOf(extraInfo, i + 1);
        }
        
        if (value == null) {
            extraInfo = (String[]) ArrayUtils.remove(extraInfo, i);
        } else {
            extraInfo[i] = param + "=" + value;
        }
        
        return i;
    }
681818
public boolean isExcluded(String endpoint) {
        for (int i = 0; i < exclusions.size(); i++) {
            if (exclusions.get(i).test(endpoint)) {
                return true;
            }
        }
        return false;
    }
542121
private void readAndValidateParameter (Param param) {

        try {
            param.readValue();
            param.validate();

        } catch (GeneralConfigException ex) {
            throw ex;

        } catch (Exception ex) {
            throw new GeneralConfigException("Configured value for '" + param.getName() + "' is invalid!", ex);
        }

    }
1202794
public void assertAtLeastOneDefined(final String param1, final String param2) {
    if (!isPresent(param1) && !isPresent(param2)) {
      throw new ParameterException(
          String.format("At least one of %s and %s must be defined.", param1, param2));
    }
  }
339355
public static boolean allParametersAreHidden(Map<String, QueryParameter> map) {
        for (QueryParameter qp : map.values()) {
            if (!qp.isHidden()) {
                return false;
            }
        }
        return true;
    }