Returns true if the passed {@link IGeneratorParameter}s has been
registered.

@param  param   parameter for which it is tested if it is registered
@return boolean indicating the parameters is registered
180843
public <T extends IGeneratorParameter<?>> boolean hasParameter(Class<T> param) {
        return renderingParameters.containsKey(param.getName());
    }
1020613
private static ParameterFiller parseParameter(String parameter) {
    String wrappedParameter = "{" + parameter + "}";
    String trimmedParameter = parameter.trim();
    ParameterFiller parameterFiller = parseDateParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseLevelParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseTagParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    parameterFiller = parseMessageParameter(wrappedParameter, trimmedParameter);
    if (parameterFiller != null) {
      return parameterFiller;
    }

    return null;
  }
1077430
public static boolean lambdaParamIsImplicitlyTyped(VariableTree lambdaParameter) {
    // kind of a hack; the "preferred position" seems to be the position
    // of the variable name.  if this differs from the start position, it
    // means there is an explicit type declaration
    JCDiagnostic.DiagnosticPosition diagnosticPosition =
        (JCDiagnostic.DiagnosticPosition) lambdaParameter;
    return diagnosticPosition.getStartPosition() == diagnosticPosition.getPreferredPosition();
  }
1244490
private void validateParameterProviders() {
    Set<String> parameterNames = new HashSet<>();
    for (ParameterProvider provider : this.parameterProviders) {
      Set<String> applicationIdsOfThisProvider = new HashSet<>();
      for (Parameter<?> parameter : provider.getParameters()) {
        if (StringUtils.isNotEmpty(parameter.getApplicationId())) {
          applicationIdsOfThisProvider.add(parameter.getApplicationId());
        }
        if (parameterNames.contains(parameter.getName())) {
          log.warn("Parameter name is not unique: {} (application: {})", parameter.getName(), parameter.getApplicationId());
        }
        else {
          parameterNames.add(parameter.getName());
        }
      }
      if (applicationIdsOfThisProvider.size() > 1) { //NOPMD
        log.warn("Parameter provider {} defines parameters with multiple application Ids: {}", provider,
            applicationIdsOfThisProvider.toArray(new String[applicationIdsOfThisProvider.size()]));
      }
    }
  }
680078
private static boolean isRepoWS(String parameter)
   {
      String repWS = parameter;
      repWS = repWS.replaceAll("\\\\", "/");

      if ( !repWS.matches("[/][^/]+") && !repWS.matches("[/][^/]+[/][^/]+"))
      {
         return false;
      }
      else
      {
         return true;
      }
   }
1149999
private function validateParameter(\ReflectionParameter $parameter)
    {
        $catcher = function ($className) {
            $generator = $this->generator($className);
            if ($generator) {
                include $generator->generate();
            }
        };
        
        if (($reflectionClass = $parameter->getDeclaringClass())
            && ($reflectionMethod = $parameter->getDeclaringFunction())) {
            $type = $this->typeHintIndex->lookup(
                $reflectionClass->getName(),
                $reflectionMethod->getName(),
                '$' . $parameter->getName()
            );

            if ($type && !class_exists($type) && !interface_exists($type)) {
                $catcher($type);
                return $this;
            }
        }

        spl_autoload_register($catcher);
        try {
            $parameter->getClass();
        } catch (\ReflectionException $e) {
            // Ignore reflection exception, as it is an intended behaviour for our catcher
        }
        spl_autoload_unregister($catcher);
        return $this;
    }
1119566
public boolean recordParameter(String parameterName, JSTypeExpression type) {
    if (!hasAnySingletonTypeTags()
        && currentInfo.declareParam(type, parameterName)) {
      populated = true;
      return true;
    } else {
      return false;
    }
  }
1303804
protected void verifyParameterLegality(Parameter... parameters) {
    for (Parameter parameter : parameters)
      if (illegalParamNames.contains(parameter.name)) {
        throw new IllegalArgumentException(
                "Parameter '" + parameter.name + "' is reserved for RestFB use - you cannot specify it yourself.");
      }
  }
471416
private String getParameterName(AnnotatedParameter<?> parameter) {
        try {
            Method method = Method.class.getMethod("getParameters");
            Object[] parameters = (Object[]) method.invoke(parameter.getDeclaringCallable().getJavaMember());
            Object param = parameters[parameter.getPosition()];
            Class<?> Parameter = Class.forName("java.lang.reflect.Parameter");
            if ((Boolean) Parameter.getMethod("isNamePresent").invoke(param))
                return (String) Parameter.getMethod("getName").invoke(param);
            else
                throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter
                                                        + "], activate the -parameters compiler argument or annotate the injected parameter with the @Metric annotation");
        } catch (NoSuchMethodException | IllegalAccessException | InvocationTargetException | ClassNotFoundException cause) {
            throw new UnsupportedOperationException("Unable to retrieve name for parameter [" + parameter
                                                    + "], @Metric annotation on injected parameter is required before Java 8");
        }
    }
778173
private boolean containerOfSubtyping(
      Set<String> containerTypeParameters,
      AnnotationInfo annotation,
      TypeVariableSymbol typaram,
      Type tyargument) {
    // (1)
    if (!tyargument.hasTag(TypeTag.TYPEVAR)) {
      return false;
    }
    // (2)
    if (!containerTypeParameters.contains(tyargument.asElement().getSimpleName().toString())
        || isTypeParameterThreadSafe(
            (TypeVariableSymbol) tyargument.asElement(), containerTypeParameters)) {
      return false;
    }
    // (3)
    if (annotation.containerOf().contains(typaram.getSimpleName().toString())) {
      return false;
    }
    return true;
  }
738668
public static boolean containsSyntheticParameterName(MethodSymbol sym) {
    return sym.getParameters().stream()
        .anyMatch(p -> SYNTHETIC_PARAMETER_NAME.matcher(p.getSimpleName()).matches());
  }
649456
public String getParameterName(Parameter parameter) {
    Name annotation = parameter.getAnnotation(Name.class);

    if (null == annotation) {
      return parameter.getName();
    }

    return annotation.value();
  }
440152
private boolean hasTimeoutCallbackParameters(MethodMap.MethodInfo methodInfo) {
        int numParams = methodInfo.getNumParameters();
        return numParams == 0 ||
               (numParams == 1 && methodInfo.getParameterType(0) == Timer.class);
    }
245406
@Override
    public void visit(PrimitiveParameter primitiveParameter) {
        assert this.kh != null : "kh wasn't set";
        PrimitiveParameter param = new PrimitiveParameter(propId, this.uniqueIdProvider.getInstance());
        param.setPosition(primitiveParameter.getPosition());
        param.setGranularity(primitiveParameter.getGranularity());
        param.setValue(primitiveParameter.getValue());
        param.setSourceSystem(SourceSystem.DERIVED);
        param.setCreateDate(new Date());
        this.kh.insertLogical(param);
        this.derivationsBuilder.propositionAsserted(primitiveParameter, param);
        LOGGER.log(Level.FINER, "Asserted derived proposition {0}", param);
    }
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;
    }
  }
127591
public boolean hasParameterAnnotation(final String annotationName) {
        for (final MethodParameterInfo methodParameterInfo : getParameterInfo()) {
            if (methodParameterInfo.hasAnnotation(annotationName)) {
                return true;
            }
        }
        return false;
    }
225156
protected boolean parametersAreAdequate(Map<String, String> oauthParams) {
    return oauthParams.containsKey(OAuthConsumerParameter.oauth_consumer_key.toString());
  }