Example usage for org.apache.commons.lang.text StrBuilder appendSeparator

Introduction

In this page you can find the example usage for org.apache.commons.lang.text StrBuilder appendSeparator.

Prototype

public StrBuilder appendSeparator(char separator) 

Source Link

Document

Appends a separator if the builder is currently non-empty.

Usage

From source file:me.taylorkelly.mywarp.util.CommandUtils.java

/**
 * Joins all warps in the given collection in one string, separated by {@code ", "}.
 *
 * @param warps a collection of warps/*from   ww  w .  jav  a  2s  .c o  m*/
 * @return a string with all warp-names or {@code -} if the collection was empty
 */
public static String joinWarps(Collection<Warp> warps) {
    if (warps.isEmpty()) {
        return "-";
    }

    StrBuilder ret = new StrBuilder();
    for (Warp warp : warps) {
        ret.appendSeparator(", ");
        ret.append(warp.getName());
    }
    return ret.toString();
}

---

From source file:me.taylorkelly.mywarp.util.CommandUtils.java

/**
 * Joins all worlds in the given collection in one string, separated by {@code ", "}.
 *
 * @param worlds a collection of worlds//  w  ww.  jav  a 2s.c o m
 * @return a string with all world-names or {@code -} if the collection was empty
 */
public static String joinWorlds(Collection<LocalWorld> worlds) {
    if (worlds.isEmpty()) {
        return "-";
    }

    StrBuilder ret = new StrBuilder();
    for (LocalWorld world : worlds) {
        ret.appendSeparator(", ");
        ret.append(world.getName());
    }
    return ret.toString();
}

---

From source file:com.mgmtp.perfload.perfmon.util.PerfMonUtils.java

/**
 * Appends a line break if the buffer is not empty.
 * /*  w  ww. j av  a2 s  . com*/
 * @param buffer
 *            the buffer to append to
 */
public static void appendLineBreakIfNotEmpty(final StrBuilder buffer) {
    buffer.appendSeparator(LINE_SEP);
}

---

From source file:mitm.common.security.crl.X509CRLInspector.java

/**
 * Returns a string representation of the certificate which can be used for logging etc.
 *//*from  w  ww .j  av a 2  s. c o m*/
public static String toString(X509CRL crl) {
    if (crl == null) {
        return "";
    }

    StrBuilder sb = new StrBuilder(1024);

    sb.append("Issuer: ");
    sb.append(getIssuerFriendly(crl));
    sb.appendSeparator("; ");
    sb.append("CRL number: ");
    try {
        sb.append(getCRLNumber(crl));
    } catch (IOException e1) {
        // ignore
    }
    sb.appendSeparator("; ");
    sb.append("Thumbprint: ");
    try {
        sb.append(getThumbprint(crl));
    } catch (CRLException e) {
        // ignore
    } catch (NoSuchAlgorithmException e) {
        // ignore
    } catch (NoSuchProviderException e) {
        // ignore
    }
    sb.appendSeparator("; ");
    sb.append("SHA1: ");
    try {
        sb.append(getThumbprint(crl, Digest.SHA1));
    } catch (CRLException e) {
        // ignore
    } catch (NoSuchAlgorithmException e) {
        // ignore
    } catch (NoSuchProviderException e) {
        // ignore
    }

    return sb.toString();
}

---

From source file:mitm.common.security.certificate.X509CertificateInspector.java

/**
 * Returns a string representation of the certificate which can be used for logging etc.
 *//* w ww  .  j  a v  a 2 s.  com*/
public static String toString(X509Certificate certificate) {
    StrBuilder sb = new StrBuilder(1024);

    sb.append("Issuer: ");
    sb.append(getIssuerFriendly(certificate));
    sb.appendSeparator("; ");
    sb.append("Subject: ");
    sb.append(getSubjectFriendly(certificate));
    sb.appendSeparator("; ");
    sb.append("Serial: ");
    sb.append(getSerialNumberHex(certificate));
    sb.appendSeparator("; ");
    sb.append("Thumbprint: ");
    try {
        sb.append(getThumbprint(certificate));
    } catch (CertificateEncodingException e) {
        /* ignored */
    } catch (NoSuchAlgorithmException e) {
        /* ignored */
    } catch (NoSuchProviderException e) {
        /* ignored */
    }
    sb.appendSeparator("; ");
    sb.append("SHA1: ");
    try {
        sb.append(getThumbprint(certificate, Digest.SHA1));
    } catch (CertificateEncodingException e) {
        /* ignored */
    } catch (NoSuchAlgorithmException e) {
        /* ignored */
    } catch (NoSuchProviderException e) {
        /* ignored */
    }

    return sb.toString();
}

---

From source file:com.evolveum.midpoint.common.policy.ValuePolicyGenerator.java

public static String generate(StringPolicyType policy, int defaultLength, boolean generateMinimalSize,
        OperationResult inputResult) {/*w w w  . ja v a2s .  c o  m*/

    if (null == policy) {
        throw new IllegalArgumentException("Provided password policy can not be null.");
    }

    if (null == inputResult) {
        throw new IllegalArgumentException("Provided operation result cannot be null");
    }
    // Define result from generator
    OperationResult generatorResult = new OperationResult(
            "Password generator running policy :" + policy.getDescription());
    inputResult.addSubresult(generatorResult);

    // if (policy.getLimitations() != null &&
    // policy.getLimitations().getMinLength() != null){
    // generateMinimalSize = true;
    // }
    // setup default values where missing
    // PasswordPolicyUtils.normalize(pp);

    // Optimize usage of limits ass hashmap of limitas and key is set of
    // valid chars for each limitation
    HashMap<StringLimitType, ArrayList<String>> lims = new HashMap<StringLimitType, ArrayList<String>>();
    for (StringLimitType l : policy.getLimitations().getLimit()) {
        if (null != l.getCharacterClass().getValue()) {
            lims.put(l, StringPolicyUtils.stringTokenizer(l.getCharacterClass().getValue()));
        } else {
            lims.put(l, StringPolicyUtils.stringTokenizer(StringPolicyUtils
                    .collectCharacterClass(policy.getCharacterClass(), l.getCharacterClass().getRef())));
        }
    }

    // Get global limitations
    int minLen = policy.getLimitations().getMinLength() == null ? 0
            : policy.getLimitations().getMinLength().intValue();
    if (minLen != 0 && minLen > defaultLength) {
        defaultLength = minLen;
    }
    int maxLen = (policy.getLimitations().getMaxLength() == null ? 0
            : policy.getLimitations().getMaxLength().intValue());
    int unique = policy.getLimitations().getMinUniqueChars() == null ? minLen
            : policy.getLimitations().getMinUniqueChars().intValue();

    // test correctness of definition
    if (unique > minLen) {
        minLen = unique;
        OperationResult reportBug = new OperationResult("Global limitation check");
        reportBug.recordWarning(
                "There is more required uniq characters then definied minimum. Raise minimum to number of required uniq chars.");
    }

    if (minLen == 0 && maxLen == 0) {
        minLen = defaultLength;
        maxLen = defaultLength;
        generateMinimalSize = true;
    }

    if (maxLen == 0) {
        if (minLen > defaultLength) {
            maxLen = minLen;
        } else {
            maxLen = defaultLength;
        }
    }

    // Initialize generator
    StringBuilder password = new StringBuilder();

    /* **********************************
     * Try to find best characters to be first in password
     */
    HashMap<StringLimitType, ArrayList<String>> mustBeFirst = new HashMap<StringLimitType, ArrayList<String>>();
    for (StringLimitType l : lims.keySet()) {
        if (l.isMustBeFirst() != null && l.isMustBeFirst()) {
            mustBeFirst.put(l, lims.get(l));
        }
    }

    // If any limitation was found to be first
    if (!mustBeFirst.isEmpty()) {
        HashMap<Integer, ArrayList<String>> posibleFirstChars = cardinalityCounter(mustBeFirst, null, false,
                false, generatorResult);
        int intersectionCardinality = mustBeFirst.keySet().size();
        ArrayList<String> intersectionCharacters = posibleFirstChars.get(intersectionCardinality);
        // If no intersection was found then raise error
        if (null == intersectionCharacters || intersectionCharacters.size() == 0) {
            generatorResult
                    .recordFatalError("No intersection for required first character sets in password policy:"
                            + policy.getDescription());
            // Log error
            if (LOGGER.isErrorEnabled()) {
                LOGGER.error(
                        "Unable to generate password: No intersection for required first character sets in password policy: ["
                                + policy.getDescription()
                                + "] following character limitation and sets are used:");
                for (StringLimitType l : mustBeFirst.keySet()) {
                    StrBuilder tmp = new StrBuilder();
                    tmp.appendSeparator(", ");
                    tmp.appendAll(mustBeFirst.get(l));
                    LOGGER.error("L:" + l.getDescription() + " -> [" + tmp + "]");
                }
            }
            // No more processing unrecoverable conflict
            return null; // EXIT
        } else {
            if (LOGGER.isDebugEnabled()) {
                StrBuilder tmp = new StrBuilder();
                tmp.appendSeparator(", ");
                tmp.appendAll(intersectionCharacters);
                LOGGER.trace("Generate first character intersection items [" + tmp + "] into password.");
            }
            // Generate random char into password from intersection
            password.append(intersectionCharacters.get(rand.nextInt(intersectionCharacters.size())));
        }
    }

    /* **************************************
     * Generate rest to fulfill minimal criteria
     */

    boolean uniquenessReached = false;

    // Count cardinality of elements
    HashMap<Integer, ArrayList<String>> chars;
    for (int i = 0; i < minLen; i++) {

        // Check if still unique chars are needed
        if (password.length() >= unique) {
            uniquenessReached = true;
        }
        // Find all usable characters
        chars = cardinalityCounter(lims, StringPolicyUtils.stringTokenizer(password.toString()), false,
                uniquenessReached, generatorResult);
        // If something goes badly then go out
        if (null == chars) {
            return null;
        }

        if (chars.isEmpty()) {
            LOGGER.trace("Minimal criterias was met. No more characters");
            break;
        }
        // Find lowest possible cardinality and then generate char
        for (int card = 1; card < lims.keySet().size(); card++) {
            if (chars.containsKey(card)) {
                ArrayList<String> validChars = chars.get(card);
                password.append(validChars.get(rand.nextInt(validChars.size())));
                //               LOGGER.trace(password.toString());
                break;
            }
        }
    }

    // test if maximum is not exceeded
    if (password.length() > maxLen) {
        generatorResult
                .recordFatalError("Unable to meet minimal criteria and not exceed maximxal size of password.");
        return null;
    }

    /* ***************************************
     * Generate chars to not exceed maximal
     */

    for (int i = 0; i < minLen; i++) {
        // test if max is reached
        if (password.length() == maxLen) {
            // no more characters maximal size is reached
            break;
        }

        if (password.length() >= minLen && generateMinimalSize) {
            // no more characters are needed
            break;
        }

        // Check if still unique chars are needed
        if (password.length() >= unique) {
            uniquenessReached = true;
        }
        // find all usable characters
        chars = cardinalityCounter(lims, StringPolicyUtils.stringTokenizer(password.toString()), true,
                uniquenessReached, generatorResult);

        // If something goes badly then go out
        if (null == chars) {
            // we hope this never happend.
            generatorResult
                    .recordFatalError("No valid characters to generate, but no all limitation are reached");
            return null;
        }

        // if selection is empty then no more characters and we can close
        // our work
        if (chars.isEmpty()) {
            if (i == 0) {
                password.append(RandomStringUtils.randomAlphanumeric(minLen));

            }
            break;
            //            if (!StringUtils.isBlank(password.toString()) && password.length() >= minLen) {
            //               break;
            //            }
            // check uf this is a firs cycle and if we need to user some
            // default (alphanum) character class.

        }

        // Find lowest possible cardinality and then generate char
        for (int card = 1; card <= lims.keySet().size(); card++) {
            if (chars.containsKey(card)) {
                ArrayList<String> validChars = chars.get(card);
                password.append(validChars.get(rand.nextInt(validChars.size())));
                //               LOGGER.trace(password.toString());
                break;
            }
        }
    }

    if (password.length() < minLen) {
        generatorResult.recordFatalError(
                "Unable to generate password and meet minimal size of password. Password lenght: "
                        + password.length() + ", required: " + minLen);
        LOGGER.trace(
                "Unable to generate password and meet minimal size of password. Password lenght: {}, required: {}",
                password.length(), minLen);
        return null;
    }

    generatorResult.recordSuccess();

    // Shuffle output to solve pattern like output
    StrBuilder sb = new StrBuilder(password.substring(0, 1));
    ArrayList<String> shuffleBuffer = StringPolicyUtils.stringTokenizer(password.substring(1));
    Collections.shuffle(shuffleBuffer);
    sb.appendAll(shuffleBuffer);

    return sb.toString();
}

---

From source file:mitm.application.djigzo.james.matchers.HeaderValueRegEx.java

@Override
public void init() {
    getLogger().info("Initializing matcher: " + getMatcherName());

    String condition = getCondition();

    if (condition == null || "".equals(condition)) {
        throw new IllegalArgumentException("Condition is missing.");
    }//from w w  w.  jav  a2  s.com

    String[] pair = NameValueUtils.nameValueToPair(condition);

    if (pair.length != 2) {
        throw new IllegalArgumentException("Condition is invalid. It should be 'name=value'");
    }

    header = pair[0];
    headerValuePattern = Pattern.compile(pair[1]);

    StrBuilder sb = new StrBuilder();

    sb.append("Header: ");
    sb.append(header);
    sb.appendSeparator("; ");
    sb.append("pattern: ");
    sb.append(headerValuePattern);

    getLogger().info(sb.toString());
}

---

From source file:mitm.application.djigzo.james.smtpserver.CheckDatabaseBlockingRcptCmdHandler.java

@Override
public void configure(Configuration handlerConfiguration) throws ConfigurationException {
    logger.info("Configuring CommandHandler");

    Configuration config = handlerConfiguration.getChild("rejectCode", false);

    if (config != null) {
        rejectCode = config.getValue("452");
    }/*  w  w w .j  a v a2s .c o m*/

    config = handlerConfiguration.getChild("checkInterval", false);

    if (config != null) {
        checkInterval = config.getValueAsInteger(1);
    }

    config = handlerConfiguration.getChild("testQuery", false);

    if (config == null || config.getValue() == null) {
        throw new ConfigurationException("testQuery is missing.");
    }

    testQuery = config.getValue();

    StrBuilder sb = new StrBuilder();

    sb.append("rejectCode: ");
    sb.append(rejectCode);
    sb.appendSeparator("; ");
    sb.append("checkInterval: ");
    sb.append(checkInterval);
    sb.appendSeparator("; ");
    sb.append("testQuery: ");
    sb.append(testQuery);

    logger.info(sb.toString());
}

---

From source file:mitm.common.util.StandardHttpURLBuilder.java

@Override
public String buildQueury() throws URLBuilderException {
    StrBuilder sb = new StrBuilder(256);

    for (Parameter parameter : parameters) {
        try {// ww w  .j  a v a2  s.c om
            sb.appendSeparator("&");
            sb.append(URLEncoder.encode(parameter.getName(), "UTF-8"));
            sb.append("=");
            sb.append(URLEncoder.encode(parameter.getValue(), "UTF-8"));
        } catch (UnsupportedEncodingException e) {
            throw new URLBuilderException(e);
        }

    }

    return sb.toString();
}

---

From source file:mitm.application.djigzo.james.smtpserver.XForwardEhloCmdHandler.java

@Override
public void configure(Configuration handlerConfiguration) throws ConfigurationException {
    logger.info("Configuring CommandHandler");

    Configuration config = handlerConfiguration.getChild("xForward", false);

    if (config != null) {
        xForward = config.getValueAsBoolean();
    }/*  w  w  w  . j a va2 s. c om*/

    config = handlerConfiguration.getChild("xClient", false);

    if (config != null) {
        xClient = config.getValueAsBoolean();
    }

    config = handlerConfiguration.getChild("dsn", false);

    if (config != null) {
        dsn = config.getValueAsBoolean();
    }

    StrBuilder sb = new StrBuilder();

    sb.append("xForward: ");
    sb.append(xForward);
    sb.appendSeparator("; ");
    sb.append("xClient: ");
    sb.append(xClient);
    sb.appendSeparator("; ");
    sb.append("dsn: ");
    sb.append(dsn);

    logger.info(sb.toString());
}

---

• «
• 1
• 2
• 3
• 4
• »