Get the next (String) param.
@param strName The param name (in most implementations this is optional).
@return The next param as a string.
169679
public int getNextIntParam(InputStream in, String strName, Map<String, Object> properties)
    {
        return m_proxyTask.getNextIntParam(in, strName, properties);
    }
1222182
public String getString( int m )
    {
        StringBuffer charbuff = new StringBuffer();
        
        for (int n = 0; n < getN(); n++)
        {
            charbuff.append(getChar(m, n));
        }
        
        return charbuff.toString().trim();
    }
1287244
public String next(int length) {
    StringBuilder result = new StringBuilder(length);
    for (int i = 0; i < length; i++) {
      result.append(WEB64_ALPHABET[random.nextInt(64)]);
    }
    return result.toString();
  }
1106212
@Override
    public DataSet next(int num) {
        DataSet ret = iter.next(num);
        ret.setLabels(ret.getFeatures());
        return ret;
    }
1293953
public boolean next() {
        int len = queryString.length();
        while (true) {
            if (paramEnd == len) {
                return false;
            }
            paramBegin = paramEnd == -1 ? 0 : paramEnd + 1;
            int idx = queryString.indexOf('&', paramBegin);
            paramEnd = idx == -1 ? len : idx;
            if (paramEnd > paramBegin) {
                idx = queryString.indexOf('=', paramBegin);
                paramNameEnd = idx == -1 || idx > paramEnd ? paramEnd : idx;
                paramName = null;
                paramValue = null;
                return true;
            }
        }
    }
37843
public ValueNumber getEntryValueForParameter(int param) {

        SignatureParser sigParser = new SignatureParser(methodGen.getSignature());
        int p = 0;
        int slotOffset =  methodGen.isStatic() ? 0 : 1;

        for ( String paramSig : sigParser.parameterSignatures()) {
            if (p == param) {
                return getEntryValue(slotOffset);
            }
            p++;
            slotOffset += SignatureParser.getNumSlotsForType(paramSig);
        }

        throw new IllegalStateException();
    }
214627
public static function reset($strName = 'default')
    {
        $objTimer = static::getTimerInstance($strName, false);
        if ($objTimer) {
            return $objTimer->resetTimer();
        }
        return null;
    }
111161
public static String getRandomString(final int size, final String stringSet) {

		final StringBuilder buff = new StringBuilder(size);

		for (int i = 0; i < size; i++) {
			final char nextChar = stringSet.charAt(RAN.nextInt(stringSet.length()));
			buff.append(nextChar);
		}
		return buff.toString();
	}
686177
public final <R> R getProperty(final String aName) {
        for (final T p : this) {
            if (p.getName().equalsIgnoreCase(aName)) {
                return (R) p;
            }
        }
        return null;
    }
805545
@Nullable
  private static Node nameOfParam(Node param) {
    switch (param.getToken()) {
      case NAME:
        return param;
      case DEFAULT_VALUE:
        return nameOfParam(param.getFirstChild());
      case REST:
        return nameOfParam(param.getOnlyChild());
      case ARRAY_PATTERN:
      case OBJECT_PATTERN:
        return null;
      default:
        throw new IllegalStateException("Unexpected child of PARAM_LIST: " + param.toStringTree());
    }
  }
662654
public static List<String> getParameterList(String parameterString) {
        List<String> parameterList = new ArrayList<>();

        StringTokenizer tok = new StringTokenizer(parameterString, ",");
        while (tok.hasMoreElements()) {
            String param = tok.nextToken().trim();
            parameterList.add(cutOffSingleQuotes(param));
        }

        List<String> postProcessed = new ArrayList<>();
        for (int i = 0; i < parameterList.size(); i++) {
            int next = i + 1;

            String processed = parameterList.get(i);

            if (processed.startsWith("'") && !processed.endsWith("'")) {
                while (next < parameterList.size()) {
                    if (parameterString.contains(processed + ", " + parameterList.get(next))) {
                        processed += ", " + parameterList.get(next);
                    } else if (parameterString.contains(processed + "," + parameterList.get(next))) {
                        processed += "," + parameterList.get(next);
                    } else if (parameterString.contains(processed + " , " + parameterList.get(next))) {
                        processed += " , " + parameterList.get(next);
                    } else {
                        processed += parameterList.get(next);
                    }

                    i++;
                    if (parameterList.get(next).endsWith("'")) {
                        break;
                    } else {
                        next++;
                    }
                }

            }

            postProcessed.add(cutOffSingleQuotes(processed));
        }

        return postProcessed;
    }
1132659
public static String getParam(String[] args, String strParam)
    {
        if ((args != null) && (strParam != null))
        {
            for (int i = 0; i < args.length; i++)
            {
                if (args[i] != null)
                {
                    int iIndex = args[i].indexOf('=');
                    if (iIndex != -1)
                    {
                        if (strParam.equalsIgnoreCase(args[i].substring(0, iIndex)))
                            return args[i].substring(iIndex + 1, args[i].length());
                    }
                }
            }
        }
        return null;
    }
108424
@Override
  public String getNext() {
    try {
      int nextTok = st.nextToken();
      switch (nextTok) {
        case java.io.StreamTokenizer.TT_EOL:
          return eolString;
        case java.io.StreamTokenizer.TT_EOF:
          return null;
        case java.io.StreamTokenizer.TT_WORD:
          return st.sval;
        case java.io.StreamTokenizer.TT_NUMBER:
          return Double.toString(st.nval);
        default:
          char[] t = { (char) nextTok };    // (array initialization)
          return new String(t);
      }
    } catch (IOException ioe) {
      // do nothing, return null
      return null;
    }
  }
1342538
public Set<String> getStringSet(final String param) {
    return get(param, new StringToStringSet(","),
        new AlwaysValid<Set<String>>(),
        "comma-separated list of strings");
  }
974377
public List<String> getStringList(final String param) {
    return get(param, new StringToStringList(","),
        new AlwaysValid<List<String>>(),
        "comma-separated list of strings");
  }
1310910
public static String getStrCode(int length) {
        StringBuffer str = new StringBuffer();
        while (str.length() <= length - 1)
            str.append(strArray[new Random().nextInt(strArray.length)]);
        return str.toString();
    }
278399
@Override
	public String next() {
		Long current = next;
		next += 1;

		return String.format(format, current);
	}