Java Completer.complete方法代码示例

import jline.console.completer.Completer; //导入方法依赖的package包/类
@Override
public int complete(String buffer, int cursor, List<CharSequence> candidates) {
	int completionIndex = super.complete(buffer, cursor, candidates);
	int spaceIndex = buffer.indexOf(' ');
	String commandName = (spaceIndex == -1) ? "" : buffer.substring(0, spaceIndex);
	if (!"".equals(commandName.trim())) {
		for (Command command : this.commands) {
			if (command.getName().equals(commandName)) {
				if (cursor == buffer.length() && buffer.endsWith(" ")) {
					printUsage(command);
					break;
				}
				Completer completer = this.commandCompleters.get(command.getName());
				if (completer != null) {
					completionIndex = completer.complete(buffer, cursor, candidates);
					break;
				}
			}
		}
	}
	return completionIndex;
}
 

import jline.console.completer.Completer; //导入方法依赖的package包/类
/**
 * Use the completers to modify the buffer with the appropriate completions.
 *
 * @return true if successful
 */
protected boolean complete() throws IOException {
    // debug ("tab for (" + buf + ")");
    if (completers.size() == 0) {
        return false;
    }

    List<CharSequence> candidates = new LinkedList<CharSequence>();
    String bufstr = buf.buffer.toString();
    int cursor = buf.cursor;

    int position = -1;

    for (Completer comp : completers) {
        if ((position = comp.complete(bufstr, cursor, candidates)) != -1) {
            break;
        }
    }

    return candidates.size() != 0 && getCompletionHandler().complete(this, candidates, position);
}
 

import jline.console.completer.Completer; //导入方法依赖的package包/类
protected void printCompletionCandidates() throws IOException {
    // debug ("tab for (" + buf + ")");
    if (completers.size() == 0) {
        return;
    }

    List<CharSequence> candidates = new LinkedList<CharSequence>();
    String bufstr = buf.buffer.toString();
    int cursor = buf.cursor;

    for (Completer comp : completers) {
        if (comp.complete(bufstr, cursor, candidates) != -1) {
            break;
        }
    }
    CandidateListCompletionHandler.printCandidates(this, candidates);
    drawLine();
}
 

import jline.console.completer.Completer; //导入方法依赖的package包/类
@Override
public int complete(String buffer, final int cursor, final List<CharSequence> candidates) {
    // candidates can be null
    checkNotNull(candidates);

    if (buffer == null) {
        buffer = "";
    }
    ArgumentDelimiter delim = getDelimiter();
    ArgumentList list = delim.delimit(buffer, cursor);
    int argpos = list.getArgumentPosition();
    int argIndex = list.getCursorArgumentIndex();

    if (argIndex < 0) {
        return -1;
    }

    List<Completer> completers = getCompleters();
    Completer completer;

    // if we are beyond the end of the completers, just use the last one
    if (argIndex >= completers.size()) {
        completer = completers.get(completers.size() - 1);
    }
    else {
        completer = completers.get(argIndex);
    }

    // ensure that all the previous completers are successful before allowing this completer to pass (only if strict).
    for (int i = 0; isStrict() && (i < argIndex); i++) {
        Completer sub = completers.get(i >= completers.size() ? (completers.size() - 1) : i);
        String[] args = list.getArguments();
        String arg = (args == null || i >= args.length) ? "" : args[i];

        List<CharSequence> subCandidates = new LinkedList<CharSequence>();
        if (sub instanceof ArgumentListAware) {
            ((ArgumentListAware) sub).setArgumentList(list);
        }

        if (sub.complete(arg, arg.length(), subCandidates) == -1) {
            return -1;
        }

        if (subCandidates.size() == 0) {
            return -1;
        }
    }

    if (completer instanceof ArgumentListAware) {
        ((ArgumentListAware) completer).setArgumentList(list);
    }

    int ret = completer.complete(list.getCursorArgument(), argpos, candidates);
    if (ret == -1) {
        return -1;
    }

    int pos = ret + list.getBufferPosition() - argpos;

    // Special case: when completing in the middle of a line, and the area under the cursor is a delimiter,
    // then trim any delimiters from the candidates, since we do not need to have an extra delimiter.
    //
    // E.g., if we have a completion for "foo", and we enter "f bar" into the buffer, and move to after the "f"
    // and hit TAB, we want "foo bar" instead of "foo  bar".

    if ((cursor != buffer.length()) && delim.isDelimiter(buffer, cursor)) {
        for (int i = 0; i < candidates.size(); i++) {
            CharSequence val = candidates.get(i);

            while (val.length() > 0 && delim.isDelimiter(val, val.length() - 1)) {
                val = val.subSequence(0, val.length() - 1);
            }

            candidates.set(i, val);
        }
    }

    Log.trace("Completing ", buffer, " (pos=", cursor, ") with: ", candidates, ": offset=", pos);

    return pos;
}
 

import jline.console.completer.Completer; //导入方法依赖的package包/类
@Override
public int complete(String buffer, int cursor, List<CharSequence> candidates) {

    if (buffer.contains(CliConstants.RESOURCE_PATH_LONG_OPTION)) {
        return fileNameCompleter.complete(buffer, cursor, candidates);
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Buffer: {}, cursor: {}", buffer, cursor);
        logger.trace("Candidates {}", candidates);
    }
    if (StringUtils.isNotBlank(buffer)) {
        // User is typing a command
        StrTokenizer strTokenizer = new StrTokenizer(buffer);
        String action = strTokenizer.next();
        Collection<String> arguments = argumentMap.get(action);
        if (arguments != null) {
            if (logger.isTraceEnabled()) {
                logger.trace("Arguments found for {}, Tokens: {}", action, strTokenizer.getTokenList());
                logger.trace("Arguments for {}: {}", action, arguments);
            }
            List<String> args = new ArrayList<String>(arguments);
            List<Completer> completers = new ArrayList<Completer>();
            for (String token : strTokenizer.getTokenList()) {
                boolean argContains = arguments.contains(token);
                if (token.startsWith("-") && !argContains) {
                    continue;
                }
                if (argContains) {
                    if (logger.isTraceEnabled()) {
                        logger.trace("Removing argument {}", token);
                    }
                    args.remove(token);
                }
                completers.add(new StringsCompleter(token));
            }
            completers.add(new StringsCompleter(args));
            Completer completer = new ArgumentCompleter(completers);
            return completer.complete(buffer, cursor, candidates);
        } else if (CliConstants.HELP_ACTION.equals(action)) {
            // For help action, we need to display available commands as arguments
            return helpCommandCompleter.complete(buffer, cursor, candidates);
        }
    }
    if (logger.isTraceEnabled()) {
        logger.trace("Using Default Completer...");
    }
    return defaultCommandCompleter.complete(buffer, cursor, candidates);
}