Example usage for org.apache.commons.lang StringUtils substringBetween

Introduction

In this page you can find the example usage for org.apache.commons.lang StringUtils substringBetween.

Prototype

public static String substringBetween(String str, String open, String close)

Source Link

Document

Gets the String that is nested in between two Strings.

Usage

From source file:Main.java

public static void main(String[] args) {
    String helloHtml = "<html>" + "<head>" + "   <title>Hello World from Java</title>" + "<body>"
            + "Hello, today is: " + new Date() + "</body>" + "</html>";

    String title = StringUtils.substringBetween(helloHtml, "<title>", "</title>");
    String content = StringUtils.substringBetween(helloHtml, "<body>", "</body>");

    System.out.println("title = " + title);
    System.out.println("content = " + content);
}

From source file:com.intel.cosbench.driver.generator.ConstantIntGenerator.java

private static ConstantIntGenerator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ',');
    int value = Integer.parseInt(args[0]);
    return new ConstantIntGenerator(value);
}

From source file:com.intel.cosbench.driver.generator.BimodalIntGenerator.java

private static BimodalIntGenerator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ',');
    double mean1 = Double.parseDouble(args[0]);
    double stdDeviation1 = Double.parseDouble(args[1]);
    double mean2 = Double.parseDouble(args[2]);
    double stdDeviation2 = Double.parseDouble(args[3]);
    double coinFlip = Double.parseDouble(args[4]);
    return new BimodalIntGenerator(mean1, stdDeviation1, mean2, stdDeviation2, coinFlip);
}

From source file:de.shadowhunt.sonar.plugins.ignorecode.model.AbstractPattern.java

static SortedSet<Integer> parseLineValues(final String lineValues) {
    final SortedSet<Integer> lines = new TreeSet<>();
    if ("*".equals(lineValues)) {
        return lines;
    }/*from  w  w w .ja v  a 2  s.c o m*/

    final String s = StringUtils.substringBetween(StringUtils.trim(lineValues), "[", "]");
    final String[] parts = StringUtils.split(s, ',');
    for (final String part : parts) {
        if (StringUtils.contains(part, '-')) {
            final String[] range = StringUtils.split(part, '-');
            final int from = Integer.parseInt(range[0]);
            final int to = Integer.parseInt(range[1]);
            addLines(lines, from, to);
        } else {
            lines.add(Integer.parseInt(part));
        }
    }
    return lines;
}

From source file:com.intel.cosbench.driver.iterator.RangeIterator.java

private static RangeIterator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ",");
    int lower = Integer.parseInt(args[0]);
    int upper = Integer.parseInt(args[1]);
    return new RangeIterator(lower, upper);
}

From source file:com.intel.cosbench.driver.random.UniformIntGenerator.java

private static UniformIntGenerator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ',');
    int lower = Integer.parseInt(args[0]);
    int upper = Integer.parseInt(args[1]);
    return new UniformIntGenerator(lower, upper);
}

From source file:com.intel.cosbench.driver.generator.SequentialIntGenerator.java

private static SequentialIntGenerator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ",");
    int lower = Integer.parseInt(args[0]);
    int upper = Integer.parseInt(args[1]);
    return new SequentialIntGenerator(lower, upper);
}

From source file:com.intel.cosbench.driver.generator.UniformIntGenerator.java

private static UniformIntGenerator tryParse(String pattern) {
    pattern = StringUtils.substringBetween(pattern, "(", ")");
    String[] args = StringUtils.split(pattern, ',');
    int lower = Integer.parseInt(args[0]);
    int upper = (args.length == 2) ? Integer.parseInt(args[1]) : MAXupper;
    return new UniformIntGenerator(lower, upper);
}

From source file:gr.xe.conf.lines.PathLine.java

private ConfNode openTag() {
    String name = StringUtils.substringBetween(line, "<", ">");
    if (now.getChildren().containsKey(name)) {
        return now.getChildren().get(name);
    } else {//from   w w w  .  j av a 2s. co  m
        PathNode newNode = new PathNode(now);
        newNode.setName(name);
        now.getChildren().put(name, newNode);
        return newNode;
    }

}

From source file:com.btobits.automator.fix.comparator.MailComparator.java

public static void compare(final FixMessageType inMsg, final SMTPMessage inSmtpMessage) throws Exception {

    final List<String> errors = new ArrayList<String>();
    try {//w  w w  .  ja  v  a2 s  . c o  m
        // compare header field             
        for (final FixMessageType.Field field : inMsg.getFields()) {
            if (!field.isGroup()) {
                final String value = getHeaderField(field.getName(), inSmtpMessage);
                if (StringUtils.isBlank(value) && StringUtils.isBlank(field.getValue())) {
                    continue;
                } else if (StringUtils.isBlank(value)) {
                    errors.add("Field [" + field.getName() + "] is absend in receive email.");
                } else if (!StringUtils.equals(field.getValue(), value) && StringUtils.startsWith(value, "<")
                        && StringUtils.endsWith(value, ">")) {

                    final String subValue = StringUtils.substringBetween(value, "<", ">");
                    if (StringUtils.isBlank(subValue)) {
                        errors.add("Field [" + field.getName() + "] is not eq receive email field ['"
                                + field.getValue() + " != " + value + "'].");
                    } else if (!StringUtils.equalsIgnoreCase(subValue, field.getValue())) {
                        errors.add("Field [" + field.getName() + "] is not eq receive email field ['"
                                + field.getValue() + " != " + value + "'].");
                    }
                } else if (!StringUtils.equals(field.getValue(), value)) {
                    errors.add("Field [" + field.getName() + "] is not eq receive email field ['"
                            + field.getValue() + " != " + value + "'].");
                }
            } else {
                // compare group
                final List<String> body = getDataFields(inSmtpMessage);
                final LinkedList<FixMessageType.Field> fields = field.getFields();
                int count = 0;
                for (FixMessageType.Field grFld : fields) {
                    final String value = getValueOnPosition(body, count);
                    if (StringUtils.equals(grFld.getName(), FIX_MESSAGE_FLD)) {
                        String fixMessage = getFixField("Original FIX message:", inSmtpMessage);
                        if (!StringUtils.equals(fixMessage, grFld.getValue())) {
                            errors.add(
                                    "Data fix field [" + grFld.getName() + "] is not eq receive email field ['"
                                            + grFld.getValue() + " != " + fixMessage + "'].");
                        }
                    } else {
                        if (StringUtils.isBlank(value) && StringUtils.isBlank(grFld.getValue())) {
                        } else {
                            if (!StringUtils.equals(value, grFld.getValue())) {
                                errors.add(
                                        "Data field [" + grFld.getName() + "] is not eq receive email field ['"
                                                + grFld.getValue() + " != " + value + "'].");
                            }
                        }
                    }
                    count++;
                }
            }
        }
    } catch (Exception ex) {
        throw new BuildException("Error compare message", ex);
    }

    if (!errors.isEmpty()) {
        throw new MessageDifferenceException(FixUtils.toString(errors));
    }
}