Get the number of parameters in the signature.

@return the number of parameters
5771
public int getNumParameters() {
        int count = 0;
        for (Iterator<String> i = parameterSignatureIterator(); i.hasNext();) {
            i.next();
            ++count;
        }
        return count;
    }
173804
public String getSignature() {
        final StringBuilder builder = new StringBuilder("(");
        parameters.forEach(builder::append);
        return builder.append(')').append(returnType).toString();
    }
1153824
@Override
    public String parameters() {
        FllExporter exporter = new FllExporter();
        String result = String.format("%s %s %s", Op.str(degree),
                exporter.toString(implication), exporter.toString(term));
        return result;
    }
734418
public java.util.List<ParameterStringFilter> getParameterFilters() {
        if (parameterFilters == null) {
            parameterFilters = new com.amazonaws.internal.SdkInternalList<ParameterStringFilter>();
        }
        return parameterFilters;
    }
878168
public List<String> getParamNames() {
    if (!Strings.contains(content, ":")) { return Collections.emptyList(); }
    final List<String> params = new ArrayList<String>();
    int index = 0;
    do {
      final int colonIndex = content.indexOf(':', index);
      if (-1 == colonIndex) {
        break;
      }
      index = colonIndex + 1;
      while (index < content.length()) {
        final char c = content.charAt(index);
        if (isValidIdentifierStarter(c)) {
          index++;
        } else {
          break;
        }
      }
      final String paramName = content.substring(colonIndex + 1, index);
      if (!params.contains(paramName)) {
        params.add(paramName);
      }
    } while (index < content.length());
    return params;
  }
691640
public int numFeatureTokens() {
    int x = 0;
    for (int i = 0, m = size; i < m; i++) {
      x += data[i].length;
    }
    return x;
  }
1114096
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        if (parameters != null)
            ret.addAll(parameters);

        if (terms != null) {
            for (final Term t : terms) {
                ret.addAll(t.getAllParameters());
            }
        }

        return ret;
    }
288965
public static int getNumParametersForInvocation(InvokeInstruction inv, ConstantPoolGen cpg) {
        SignatureParser sigParser = new SignatureParser(inv.getSignature(cpg));
        return sigParser.getNumParameters();
    }
449451
public int getNumberOfAttempts() {
        String value = Optional.fromNullable(getParameter(SignalParameters.NUMBER_OF_ATTEMPTS.symbol())).or("1");
        return Integer.parseInt(value);
    }
1017365
def parameters_signature(self):
        '''
            
        '''
        # Use x.type
        # x.name may be empty
        params = ",".join([str(x.type) for x in self._params])
        return '({})'.format(params)
188460
public SignatureAttr getSignatureAttr() {
        for (int i = mAttributes.size(); --i >= 0; ) {
            Attribute attr = mAttributes.get(i);
            if (attr instanceof SignatureAttr) {
                return (SignatureAttr) attr;
            }
        }
        return null;
    }
633240
public static int getNumParameters(String methodSignature) {
        int start = methodSignature.indexOf('(') + 1;
        int limit = methodSignature.lastIndexOf(')');

        if ((limit - start) == 0) {
            return 0;
        }

        int numParms = 0;
        for (int i = start; i < limit; i++) {
            if (!methodSignature.startsWith(Values.SIG_ARRAY_PREFIX, i)) {
                if (methodSignature.startsWith(Values.SIG_QUALIFIED_CLASS_PREFIX, i)) {
                    i = methodSignature.indexOf(Values.SIG_QUALIFIED_CLASS_SUFFIX_CHAR, i + 1);
                } else if (isWonkyEclipseSignature(methodSignature, i)) {
                    continue;
                }
                numParms++;
            }
        }

        return numParms;
    }
1254714
public String [] getNames() {
		String [] result = new String[parameters.size()];
		parameters.keySet().toArray(result);
		return result;
	}
647965
public Annotation[] getParameterAnnotations() {
        if (this.parameterAnnotations == null) {
            Annotation[][] annotationArray = (this.method != null ? this.method.getParameterAnnotations()
                    : this.constructor.getParameterAnnotations());
            if (this.parameterIndex >= 0 && this.parameterIndex < annotationArray.length) {
                this.parameterAnnotations = adaptAnnotationArray(annotationArray[this.parameterIndex]);
            } else {
                this.parameterAnnotations = new Annotation[0];
            }
        }
        return this.parameterAnnotations;
    }
3115
def signature_str(self):
        
        name, parameters, returnVars = self.signature
        return name+'('+','.join(parameters)+') returns('+','.join(returnVars)+')'
756387
public String getReturnTypeSignature() {
        int endOfParams = signature.lastIndexOf(')');
        if (endOfParams < 0) {
            throw new IllegalArgumentException("Bad method signature: " + signature);
        }
        return signature.substring(endOfParams + 1);
    }
179847
public final Collection<String> getParameters() {
        ArrayList<String> params = new ArrayList<String>();
        
        if( parameters == null ) {
            return params;
        }
        // we copy to guarantee that the caller does not screw up our internal storage
        params.addAll(Arrays.asList(parameters));
        return params;
    }