Java StringUtilRt类代码示例

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
public static boolean equal(@Nullable CharSequence s1, @Nullable CharSequence s2, boolean caseSensitive) {
  if (s1 == s2) return true;
  if (s1 == null || s2 == null) return false;

  // Algorithm from String.regionMatches()

  if (s1.length() != s2.length()) return false;
  int to = 0;
  int po = 0;
  int len = s1.length();

  while (len-- > 0) {
    char c1 = s1.charAt(to++);
    char c2 = s2.charAt(po++);
    if (c1 == c2) {
      continue;
    }
    if (!caseSensitive && StringUtilRt.charsEqualIgnoreCase(c1, c2)) continue;
    return false;
  }

  return true;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
public SslSocketFactory() throws GeneralSecurityException, IOException {
  super();
  SSLContext ctx = SSLContext.getInstance("TLS");
  TrustManager[] tms;
  KeyManager[] kms;
  try {
    String caCertPath = System.getProperty(SSL_CA_CERT_PATH);
    String clientCertPath = System.getProperty(SSL_CLIENT_CERT_PATH);
    String clientKeyPath = System.getProperty(SSL_CLIENT_KEY_PATH);
    boolean trustEverybody = StringUtilRt.parseBoolean(System.getProperty(SSL_TRUST_EVERYBODY), false);

    tms = trustEverybody ? new TrustManager[]{new MyTrustEverybodyManager()} :
          caCertPath == null ? new TrustManager[]{} : new TrustManager[]{new MyTrustManager(caCertPath)};
    kms = clientCertPath != null && clientKeyPath != null
          ? new KeyManager[]{new MyKeyManager(clientCertPath, clientKeyPath)}
          : new KeyManager[]{};
  }
  catch (Exception e) {
    throw new RuntimeException(e);
  }

  ctx.init(kms, tms, null);
  myFactory = ctx.getSocketFactory();
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
public DefaultHtmlDoctypeInitialConfigurator(ProjectManager projectManager,
                                             PropertiesComponent propertiesComponent) {
  if (!propertiesComponent.getBoolean("DefaultHtmlDoctype.MigrateToHtml5")) {
    propertiesComponent.setValue("DefaultHtmlDoctype.MigrateToHtml5", true);
    ExternalResourceManagerEx.getInstanceEx()
      .setDefaultHtmlDoctype(Html5SchemaProvider.getHtml5SchemaLocation(), projectManager.getDefaultProject());
  }
  // sometimes VFS fails to pick up updated schema contents and we need to force refresh
  if (StringUtilRt.parseInt(propertiesComponent.getValue("DefaultHtmlDoctype.Refreshed"), 0) < VERSION) {
    propertiesComponent.setValue("DefaultHtmlDoctype.Refreshed", Integer.toString(VERSION));
    final String schemaUrl = VfsUtilCore.pathToUrl(Html5SchemaProvider.getHtml5SchemaLocation());
    final VirtualFile schemaFile = VirtualFileManager.getInstance().findFileByUrl(schemaUrl);
    if (schemaFile != null) {
      schemaFile.getParent().refresh(false, true);
    }
  }
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private static int extractArgNum(String[] options) {


    for (String value : options) {
      Integer parsedValue = parseArgNum(value);
      if (parsedValue != null) {
        return parsedValue;
      }
    }

    if (options.length == 1) {
      return StringUtilRt.parseInt(options[0], 0);
    }

    return 0;
  }
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
@Override
public void createFileTypes(FileTypeConsumer fileTypeConsumer) {
  fileTypeConsumer.consume(
      BuckFileType.INSTANCE, new FileNameMatcherEx() {
        @Override
        public String getPresentableString() {
          return BuckFileUtil.getBuildFileName();
        }

        @Override
        public boolean acceptsCharSequence(CharSequence fileName) {
          String buildFileName = BuckFileUtil.getBuildFileName();
          return StringUtilRt.endsWithIgnoreCase(fileName, buildFileName) ||
            Comparing.equal(fileName, buildFileName, true);
        }
      });
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
@Override
public void createFileTypes(FileTypeConsumer fileTypeConsumer) {
  fileTypeConsumer.consume(
      BuckFileType.INSTANCE,
      new FileNameMatcherEx() {
        @Override
        public String getPresentableString() {
          return BuckFileUtil.getBuildFileName();
        }

        @Override
        public boolean acceptsCharSequence(CharSequence fileName) {
          String buildFileName = BuckFileUtil.getBuildFileName();
          return StringUtilRt.endsWithIgnoreCase(fileName, buildFileName)
              || Comparing.equal(fileName, buildFileName, true);
        }
      });
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
public static String appendToPath(@NotNull String basePath, @NotNull String relativePath) {
  final boolean endsWithSlash = StringUtilRt.endsWithChar(basePath, '/') || StringUtilRt.endsWithChar(basePath, '\\');
  final boolean startsWithSlash = StringUtil.startsWithChar(relativePath, '/') || StringUtil.startsWithChar(relativePath, '\\');
  String tail;
  if (endsWithSlash && startsWithSlash) {
    tail = trimForwardSlashes(relativePath);
  }
  else if (!endsWithSlash && !startsWithSlash && basePath.length() > 0 && relativePath.length() > 0) {
    tail = "/" + relativePath;
  }
  else {
    tail = relativePath;
  }
  return basePath + tail;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private void setPort(String port) {
  if (isSocket()) {
    myPortField.setText(String.valueOf(StringUtilRt.parseInt(port, 0)));
  }
  else {
    myAddressField.setText(port);
  }
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private static void fillPrimitivesNames(final PsiPrimitiveType type) {
  PRIMITIVES_NAMES.add(type.getBoxedTypeName());
  PRIMITIVES_NAMES.add(type.getCanonicalText());

  PRIMITIVES_SHORT_NAMES.add(StringUtilRt.getShortName(type.getBoxedTypeName()));
  PRIMITIVES_SHORT_NAMES.add(type.getCanonicalText());
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
public CharSequence refFilter(final String root, @NotNull CharSequence read) {
  CharSequence toMatch = StringUtilRt.toUpperCase(read);
  StringBuilder ready = new StringBuilder();
  int prev = 0;
  Matcher matcher = mySelector.matcher(toMatch);

  while (matcher.find()) {
    CharSequence before = read.subSequence(prev, matcher.start(1) - 1);     // Before reference
    final CharSequence href = read.subSequence(matcher.start(1), matcher.end(1)); // The URL
    prev = matcher.end(1) + 1;
    ready.append(before);
    ready.append("\"");
    ready.append(ApplicationManager.getApplication().runReadAction(
      new Computable<String>() {
        @Override
        public String compute() {
          return convertReference(root, href.toString());
        }
      }
    ));
    ready.append("\"");
  }

  ready.append(read, prev, read.length());

  return ready;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
@NotNull
private static Pair<Boolean, String> parseArguments(@NotNull String arg) {
  boolean username = StringUtilRt.startsWithIgnoreCase(arg, "username");
  String url;
  String[] split = arg.split(" ");
  if (split.length > 2) {
    url = parseUrl(split[2]);
  }
  else {
    url = ""; // XML RPC doesn't like nulls
  }
  return Pair.create(username, url);
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private static boolean extractIndex(String[] options) {
  for (String value : options) {
    Boolean parsedValue = parseIndex(value);
    if (parsedValue != null) {
      return parsedValue;
    }
  }

  if (options.length == 1) {
    return StringUtilRt.parseBoolean(options[0], false);
  }

  return false;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private static Boolean parseIndex(String value) {
  Couple<String> pair = parseValue(value);
  if (pair == null) return null;

  Boolean parsedValue = StringUtilRt.parseBoolean(pair.getSecond(), false);
  if ("index".equals(pair.getFirst())) {
    return parsedValue;
  }

  return null;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
private static Integer parseArgNum(String value) {
  Couple<String> pair = parseValue(value);
  if (pair == null) return null;

  Integer parsedValue = StringUtilRt.parseInt(pair.getSecond(), 0);
  if ("argNum".equals(pair.getFirst())) {
    return parsedValue;
  }

  return null;
}
 

import com.intellij.openapi.util.text.StringUtilRt; //导入依赖的package包/类
@Nonnull
@RequiredUIAccess
public FormBuilder addLabeled(@Nonnull final String labelText, @Nonnull Component component) {
  String newLabelText = labelText;
  if (!StringUtilRt.endsWithChar(newLabelText, ':')) {
    newLabelText += ": ";
  }

  myLayout.add(Label.create(newLabelText), TableLayout.cell(myLineCount, 0));
  myLayout.add(component, TableLayout.cell(myLineCount, 1).fill());

  myLineCount++;
  return this;
}