How to use

insert

method

in

java.lang.StringBuilder

private static void convertRemainingAccentCharacters(final StringBuilder decomposed) {
  for (int i = 0; i < decomposed.length(); i++) {
    if (decomposed.charAt(i) == '\u0141') {
      decomposed.deleteCharAt(i);
      decomposed.insert(i, 'L');
    } else if (decomposed.charAt(i) == '\u0142') {
      decomposed.deleteCharAt(i);
      decomposed.insert(i, 'l');
    }
  }
}

public static String dbName(String javaName) {
  StringBuilder builder = new StringBuilder(javaName);
  for (int i = 1; i < builder.length(); i++) {
    boolean lastWasUpper = Character.isUpperCase(builder.charAt(i - 1));
    boolean isUpper = Character.isUpperCase(builder.charAt(i));
    if (isUpper && !lastWasUpper) {
      builder.insert(i, '_');
      i++;
    }
  }
  return builder.toString().toUpperCase();
}

@Override
public String toString() {
  StringBuilder sb = new StringBuilder();
  sb.append(getLocale());
  if (sb.length() != 0) {
    sb.insert(0, " [");
    sb.append(']');
  }
  return sb.toString();
}

public void prependWhereConditions(String conditions) {
  if ( where.length() > 0 ) {
    where.insert( 0, conditions + " and " );
  }
  else {
    where.append( conditions );
  }
}

private static String zeroPad(int value, int padding){
 StringBuilder b = new StringBuilder();
 b.append(value);
 while(b.length() < padding){
  b.insert(0,"0");
 }
 return b.toString();
}

/**
 * Inserts a string on provided offset.
 */
public static String insert(String src, String insert, int offset) {
  if (offset < 0) {
    offset = 0;
  }
  if (offset > src.length()) {
    offset = src.length();
  }
  StringBuilder sb = new StringBuilder(src);
  sb.insert(offset, insert);
  return sb.toString();
}

 private String getPath(String prefix, String path) {
  // return prefix + path;
  int insertAt = path.lastIndexOf('/');
  insertAt = insertAt == -1 ? 0 : insertAt + 1;
  return new StringBuilder(path).insert(insertAt, prefix + "/").toString();
 }
}

@NotNull
public static String rightJustify(@NotNull String text, int width, char fillChar) {
 final StringBuilder builder = new StringBuilder(text);
 for (int i = text.length(); i < width; i++) {
  builder.insert(0, fillChar);
 }
 return builder.toString();
}

  private static String insertTop(Matcher matcher, String sql, int top) {
    int end = matcher.end( 1 );

    if ( TOP_PATTERN.matcher( sql.substring( end ) ).matches() ) {
      return sql;
    }

    StringBuilder sb = new StringBuilder( sql );
    sb.insert( end, "top " + top + " " );
    return sb.toString();
  }
}

private void insert(String binding) {
  currentInput.insert(cursorPos, binding);
  cursorPos += binding.length();
  // reset view
  resetMainPart();
}

private static String appendService(String serviceKey) {
  StringBuilder sb = new StringBuilder();
  if (StringUtils.isEmpty(serviceKey)) {
    throw new IllegalStateException("service field in configuration is null.");
  }
  String interfaceName = serviceKey;
  int i = interfaceName.indexOf("/");
  if (i > 0) {
    sb.append("group=");
    sb.append(interfaceName, 0, i);
    sb.append("&");
    interfaceName = interfaceName.substring(i + 1);
  }
  int j = interfaceName.indexOf(":");
  if (j > 0) {
    sb.append("version=");
    sb.append(interfaceName.substring(j + 1));
    sb.append("&");
    interfaceName = interfaceName.substring(0, j);
  }
  sb.insert(0, interfaceName + "?");
  return sb.toString();
}

private static String appendService(String serviceKey) {
  StringBuilder sb = new StringBuilder();
  if (StringUtils.isEmpty(serviceKey)) {
    throw new IllegalStateException("service field in configuration is null.");
  }
  String interfaceName = serviceKey;
  int i = interfaceName.indexOf("/");
  if (i > 0) {
    sb.append("group=");
    sb.append(interfaceName, 0, i);
    sb.append("&");
    interfaceName = interfaceName.substring(i + 1);
  }
  int j = interfaceName.indexOf(":");
  if (j > 0) {
    sb.append("version=");
    sb.append(interfaceName.substring(j + 1));
    sb.append("&");
    interfaceName = interfaceName.substring(0, j);
  }
  sb.insert(0, interfaceName + "?");
  return sb.toString();
}

/**
 * {@inheritDoc}
 */
@Override
protected String getShortClassName(final java.lang.Class<?> cls) {
  Class<? extends Annotation> annotationType = null;
  for (final Class<?> iface : ClassUtils.getAllInterfaces(cls)) {
    if (Annotation.class.isAssignableFrom(iface)) {
      @SuppressWarnings("unchecked") // OK because we just checked the assignability
      final
      Class<? extends Annotation> found = (Class<? extends Annotation>) iface;
      annotationType = found;
      break;
    }
  }
  return new StringBuilder(annotationType == null ? StringUtils.EMPTY : annotationType.getName())
      .insert(0, '@').toString();
}

@Override
public String getLimitString(String querySelect, int offset, int limit) {
  if ( offset > 0 ) {
    throw new UnsupportedOperationException( "query result offset is not supported" );
  }
  return new StringBuilder( querySelect.length() + 8 )
      .append( querySelect )
      .insert( getAfterSelectInsertPoint( querySelect ), " top " + limit )
      .toString();
}

/**
 * Inspect the {@code expectedModel} to see if all elements in the
 * model appear and are equal.
 * @param mav the ModelAndView to test against (never {@code null})
 * @param expectedModel the expected model
 */
public static void assertModelAttributeValues(ModelAndView mav, Map<String, Object> expectedModel) {
  Map<String, Object> model = mav.getModel();
  if (!model.keySet().equals(expectedModel.keySet())) {
    StringBuilder sb = new StringBuilder("Keyset of expected model does not match.\n");
    appendNonMatchingSetsErrorMessage(expectedModel.keySet(), model.keySet(), sb);
    fail(sb.toString());
  }
  StringBuilder sb = new StringBuilder();
  model.forEach((modelName, mavValue) -> {
    Object assertionValue = expectedModel.get(modelName);
    if (!assertionValue.equals(mavValue)) {
      sb.append("Value under name '").append(modelName).append("' differs, should have been '").append(
        assertionValue).append("' but was '").append(mavValue).append("'\n");
    }
  });
  if (sb.length() != 0) {
    sb.insert(0, "Values of expected model do not match.\n");
    fail(sb.toString());
  }
}

private List<Object> evaluate(final List<String> inlineExpressions) {
  List<Object> result = new ArrayList<>(inlineExpressions.size());
  for (String each : inlineExpressions) {
    StringBuilder expression = new StringBuilder(handlePlaceHolder(each));
    if (!each.startsWith("\"")) {
      expression.insert(0, "\"");
    }
    if (!each.endsWith("\"")) {
      expression.append("\"");
    }
    result.add(evaluate(expression.toString()));
  }
  return result;
}

static String getClassFQName(TypeElement elem) {
 StringBuilder name = new StringBuilder();
 while (isClassy(elem.getEnclosingElement().getKind())) {
  name.insert(0, "$" + elem.getSimpleName());
  elem = (TypeElement) elem.getEnclosingElement();
 }
 name.insert(0, elem.getQualifiedName());
 return name.toString();
}

private String getFullPath(ConfigOption<?> opt) {
  StringBuilder sb = new StringBuilder(64);
  sb.insert(0, opt.getName());
  for (ConfigNamespace parent = opt.getNamespace();
     null != parent && !parent.isRoot();
     parent = parent.getNamespace()) {
    if (parent.isUmbrella())
      sb.insert(0, "[X].");
    sb.insert(0, ".");
    sb.insert(0, parent.getName());
  }
  return sb.toString();
}

@Override
public String processSql(String sql, RowSelection selection) {
  final boolean hasOffset = LimitHelper.hasFirstRow( selection );
  String sqlOffset = hasOffset ? " SKIP " + selection.getFirstRow() : "";
  String sqlLimit = " FIRST " + getMaxOrLimit( selection );
  String sqlOffsetLimit = sqlOffset + sqlLimit;
  String result = new StringBuilder( sql.length() + 10 )
      .append( sql )
      .insert( sql.toLowerCase( Locale.ROOT ).indexOf( "select" ) + 6, sqlOffsetLimit ).toString();
  return result;
}

@Test
public void testDecodeWithWhitespace() throws Exception {
  final String orig = "I am a late night coder.";
  final byte[] encodedArray = Base64.encodeBase64(orig.getBytes(CHARSET_UTF8));
  final StringBuilder intermediate = new StringBuilder(new String(encodedArray));
  intermediate.insert(2, ' ');
  intermediate.insert(5, '\t');
  intermediate.insert(10, '\r');
  intermediate.insert(15, '\n');
  final byte[] encodedWithWS = intermediate.toString().getBytes(CHARSET_UTF8);
  final byte[] decodedWithWS = Base64.decodeBase64(encodedWithWS);
  final String dest = new String(decodedWithWS);
  assertEquals("Dest string doesn't equal the original", orig, dest);
}