Java StringUtils类代码示例

import org.parboiled.common.StringUtils; //导入依赖的package包/类
/**
 * Formats a ZonedDateTime into a string with the given DateTimeFormatter pattern
 * @param date
 * @param formatPattern
 * @return
 */
public static String formatLocalDateFromZonedDate(ZonedDateTime date, String formatPattern) {
    if (date == null) {
        return "";
    }

    ZonedDateTime localDt = date.withZoneSameInstant(Context.getSettings().getTimeZoneId());

    DateTimeFormatter formatter;
    if (StringUtils.isEmpty(formatPattern)) {
        formatter = DEFAULT_FORMAT;
    } else if ("iso".equals(formatPattern.toLowerCase())) {
        formatter = DateTimeFormatter.ISO_OFFSET_DATE_TIME;
    } else {
        formatter = DateTimeFormatter.ofPattern(formatPattern);
    }
    return localDt.format(formatter);
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
@Override
public void serialize(final VerbatimNode node, final Printer printer) {
    printer.println().print("<pre><code");
    String className = "prettyprint";
    if (!StringUtils.isEmpty(node.getType())) {
        className = className.concat(" " + node.getType());
    }
    printAttribute(printer, "class", className);
    printer.print(">");
    String text = node.getText();
    // print HTML breaks for all initial newlines
    while (text.charAt(0) == '\n') {
        printer.print("<br/>");
        text = text.substring(1);
    }
    printer.printEncoded(text);
    printer.print("</code></pre>");

}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
@Override
public void visit(OrderedListNode oln) {

    ++listLevel;
    try {
        _buffer.append('\n');
        for (Node child : oln.getChildren()) {
            _buffer.append( StringUtils.repeat('#', listLevel) ).append(' ');
            child.accept(this);
            _buffer.append('\n');
        }
        _buffer.append('\n');
    }finally {
        --listLevel;
    }

}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
/**
 * Returns the node underneath the given parents that matches the given path.
 * See {@link #findNodeByPath(org.parboiled.Node, String)} )} for a description of the path argument.
 * If the given collections of parents is null or empty or no node is found the method returns null.
 *
 * @param parents the parent Nodes to look through
 * @param path    the path to the Node being searched for
 * @return the Node if found or null if not found
 */
public static <V> Node<V> findNodeByPath(List<Node<V>> parents, String path) {
    checkArgNotNull(path, "path");
    if (parents != null && !parents.isEmpty()) {
        int separatorIndex = path.indexOf('/');
        String prefix = separatorIndex != -1 ? path.substring(0, separatorIndex) : path;
        int start = 0, step = 1;
        if (prefix.startsWith("last:")) {
            prefix = prefix.substring(5);
            start = parents.size() - 1;
            step = -1;
        }
        for (int i = start; 0 <= i && i < parents.size(); i += step) {
            Node<V> child = parents.get(i);
            if (StringUtils.startsWith(child.getLabel(), prefix)) {
                return separatorIndex == -1 ? child : findNodeByPath(child, path.substring(separatorIndex + 1));
            }
        }
    }
    return null;
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
/**
 * Collects all nodes underneath the given parents that match the given path.
 * The path is a '/' separated list of node label prefixes describing the ancestor chain of the node to look for
 * relative to the given parent nodes.
 *
 * @param parents    the parent Nodes to look through
 * @param path       the path to the Nodes being searched for
 * @param collection the collection to collect the found Nodes into
 * @return the same collection instance passed as a parameter
 */
public static <V, C extends Collection<Node<V>>> C collectNodesByPath(List<Node<V>> parents, String path,
                                                                      C collection) {
    checkArgNotNull(path, "path");
    checkArgNotNull(collection, "collection");
    if (parents != null && !parents.isEmpty()) {
        int separatorIndex = path.indexOf('/');
        String prefix = separatorIndex != -1 ? path.substring(0, separatorIndex) : path;
        for (Node<V> child : parents) {
            if (StringUtils.startsWith(child.getLabel(), prefix)) {
                if (separatorIndex == -1) {
                    collection.add(child);
                } else {
                    collectNodesByPath(child, path.substring(separatorIndex + 1), collection);
                }
            }
        }
    }
    return collection;
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public String format(InvalidInputError error) {
    if (error == null) return "";

    int len = error.getEndIndex() - error.getStartIndex();
    StringBuilder sb = new StringBuilder();
    if (len > 0) {
        char c = error.getInputBuffer().charAt(error.getStartIndex());
        if (c == Chars.EOI) {
            sb.append("Unexpected end of input");
        } else {
            sb.append("Invalid input '")
                    .append(StringUtils.escape(String.valueOf(c)));
            if (len > 1) sb.append("...");
            sb.append('\'');
        }
    } else {
        sb.append("Invalid input");
    }
    String expectedString = getExpectedString(error);
    if (StringUtils.isNotEmpty(expectedString)) {
        sb.append(", expected ").append(expectedString);
    }
    return sb.toString();
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public static void main(String[] args) {
    TimeParser parser = Parboiled.createParser(TimeParser.class);
    
    while (true) {
        System.out.print("Enter a time expression (hh:mm(:ss)?, hh(mm(ss)?)? or h(mm)?, single RETURN to exit)!\n");
        String input = new Scanner(System.in).nextLine();
        if (StringUtils.isEmpty(input)) break;

        ParsingResult<?> result = new RecoveringParseRunner(parser.Time()).run(input);

        System.out.println(input + " = " + result.parseTreeRoot.getValue() + '\n');
        System.out.println(printNodeTree(result) + '\n');

        if (!result.matched) {
            System.out.println(StringUtils.join(result.parseErrors, "---\n"));
        }
    }
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public static void main(String[] args) {
    AbcParser parser = Parboiled.createParser(AbcParser.class);

    while (true) {
        System.out.print("Enter an a^n b^n c^n expression (single RETURN to exit)!\n");
        String input = new Scanner(System.in).nextLine();
        if (StringUtils.isEmpty(input)) break;

        ParsingResult<?> result = new ReportingParseRunner(parser.S()).run(input);

        if (!result.parseErrors.isEmpty())
            System.out.println(ErrorUtils.printParseError(result.parseErrors.get(0)));
        else
            System.out.println(printNodeTree(result) + '\n');
    }
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public static String getMethodInstructionList(MethodNode methodNode) {
    checkArgNotNull(methodNode, "methodNode");
    Printer printer = new NonMaxTextifier();
    TraceMethodVisitor traceMethodVisitor = new TraceMethodVisitor(printer);
    methodNode.accept(traceMethodVisitor);
    StringWriter stringWriter = new StringWriter();
    PrintWriter printWriter = new PrintWriter(stringWriter);
    printer.print(printWriter);
    printWriter.flush();
    String[] lines = stringWriter.toString().split("\n");
    int lineNr = 0;
    for (int i = 0; i < lines.length; i++) {
        if (!lines[i].startsWith("  @")) {
            lines[i] = String.format("%2d %s", lineNr++, lines[i]);
        }
    }
    return "Method '" + methodNode.name + "':\n" + StringUtils.join(lines, "\n") + '\n';
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public static void main(String[] args) {
    TimeParser parser = Parboiled.createParser(TimeParser.class);
    
    while (true) {
        System.out.print("Enter a time expression (hh:mm(:ss)?, hh(mm(ss)?)? or h(mm)?, single RETURN to exit)!\n");
        String input = new Scanner(System.in).nextLine();
        if (StringUtils.isEmpty(input)) break;

        ParsingResult<?> result = new RecoveringParseRunner(parser.time()).run(input);

        System.out.println(input + " = " + result.parseTreeRoot.getValue() + '\n');
        System.out.println(printNodeTree(result) + '\n');

        if (!result.matched) {
            System.out.println(StringUtils.join(result.parseErrors, "---\n"));
        }
    }
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
private static void debugTree(AbcNode node, int level) {
	AbcNode parent = node.getParent();
	if ((level >= DEBUG_LEVEL) && !DEBUG && !node.hasError()
		&& (parent!=null) && !parent.hasError()) return;
	StringBuffer sb = new StringBuffer();
	sb.append(StringUtils.repeat(' ', level * 2));
	sb.append(node.getLabel());
	if (node.hasError())
		sb.append("!E!");
	sb.append(" = '");
	String v = node.getValue();
	if (v.length() > 103) {
		v = v.substring(0, 50) + "..."
			+ v.substring(v.length() - 50)
			+ " (length="+v.length()+")";
	}
	sb.append(v.replaceAll("\n", "<LF>").replaceAll("\r", "<CR>"));
	sb.append("' (" + node.getCharStreamPosition().toString() + ")");
	System.out.println(sb.toString());
	Iterator it = node.getChilds().iterator();
	level++;
	while (it.hasNext()) {
		debugTree((AbcNode) it.next(), level);
	}
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
private void print(Node n) {
  try {
    writer.write(StringUtils.repeat(' ', level * indentation));
    if (n.hasLabel(Labels.SYNONYM)) {
      writer.write(SYNONYM_SYMBOL);
    }
    if (n.hasLabel(Labels.BASIONYM)) {
      writer.write(BASIONYM_SYMBOL);
    }
    writer.write(getTitle.apply(n));
    if (n.hasProperty(NeoProperties.RANK)) {
      writer.write(" [");
      writer.write(Rank.values()[(Integer) n.getProperty(NeoProperties.RANK)].name().toLowerCase());
      if (showIds) {
        writer.write(",");
        writer.write(String.valueOf(n.getId()));
      }
      writer.write("]");
    }
    writer.write("\n");

  } catch (IOException e) {
    Throwables.propagate(e);
  }
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public void visit(RefLinkNode refLinkNode) {
    // TODO reference link require implement
    // to expand sentence
    String linkName = printChildrenToString(refLinkNode);
    String url = getRefLinkUrl(refLinkNode.referenceKey, linkName);
    // FIXME how to handle url, if linkName include period character?
    // TODO temporary implementation
    if (candidateSentences.size() == 0) { return; }
    CandidateSentence lastCandidateSentence =
            candidateSentences.get(candidateSentences.size() - 1);
    if (StringUtils.isNotEmpty(url)) {
        lastCandidateSentence.setLink(url);
    } else {
        lastCandidateSentence.setContent(
                lastCandidateSentence.getContent());
    }
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
public static String encode(String string) {
	if (StringUtils.isNotEmpty(string)) {
		for (int i = 0; i < string.length(); i++) {
			if (encode(string.charAt(i)) != null) {
				// we have at least one character that needs encoding, so do
				// it one by one
				StringBuilder sb = new StringBuilder();
				for (i = 0; i < string.length(); i++) {
					char c = string.charAt(i);
					String encoded = encode(c);
					if (encoded != null)
						sb.append(encoded);
					else
						sb.append(c);
				}
				return sb.toString();
			}
		}
		return string;
	} else
		return "";
}
 

import org.parboiled.common.StringUtils; //导入依赖的package包/类
/**
 * Parse the expression into a type and check it against expected values
 *
 * @param expr
 * @param typeSig
 * @param isNullable
 * @param isStatic
 * @throws Exception
 */
private AstNode checkExpr(String expr, String typeSig, boolean isNullable, boolean isStatic) throws Exception {
    FanParserTask task = new FanParserTask(null);
    FantomParser parser = Parboiled.createParser(FantomParser.class, task);
    ParsingResult<AstNode> result = new RecoveringParseRunner<AstNode>(parser.testExpr()).run(expr);
    JOTTester.checkIf("Checking for parsing errors: " + expr, !result.hasErrors(), StringUtils.join(result.parseErrors, "\n"));
    AstNode node = result.parseTreeRoot.getValue();
    FantomParserAstActions.linkNodes(result.valueStack);

    addUsingsToNode(node, testUsings);
    addTypeSlotsToNode(node, task, testSlots);
    task.parseVars(node, null);
    //System.out.println("Node for "+expr+" : ");
    if(!task.getDiagnostics().isEmpty())
    {
        FanLexAstUtils.dumpTree(node, 0);
    }
    JOTTester.checkIf("Checking for Semantic errors: " + expr, task.getDiagnostics().isEmpty(), StringUtils.join(task.getDiagnostics(), "\n"));
    FanResolvedType t = node.getType();
    check(expr, t, typeSig, isNullable, isStatic);
    return node;
}