org.eclipse.jdt.core.compiler.CharOperation.replace java code examples

Add the Codota plugin to your IDE and get smart completions

private void myMethod () {
 Dictionary d =new Hashtable()
Bundle bundle;bundle.getHeaders()
new Properties()
Smart code suggestions by Codota
}

public char[] normalizedPath() {
  if (this.normalizedPath == null) {
    this.normalizedPath = this.path.toCharArray();
    if (File.separatorChar == '\\') {
      CharOperation.replace(this.normalizedPath, '\\', '/');
    }
  }
  return this.normalizedPath;
}
public String getPath() {

public char[] normalizedPath() {
  if (this.normalizedPath == null) {
    this.normalizedPath = this.path.toCharArray();
    if (File.separatorChar == '\\') {
      CharOperation.replace(this.normalizedPath, '\\', '/');
    }
  }
  return this.normalizedPath;
}
public String getPath() {

@Override
public char[] normalizedPath() {
  if (this.normalizedPath == null) {
    this.normalizedPath = this.path.toCharArray();
    if (File.separatorChar == '\\') {
      CharOperation.replace(this.normalizedPath, '\\', '/');
    }
  }
  return this.normalizedPath;
}
@Override

public static char[] fullyQualifiedNameToFieldDescriptor(char[] fullyQualifiedName) {
  char[] result = CharArrayUtils.concat(FIELD_DESCRIPTOR_PREFIX, fullyQualifiedName, FIELD_DESCRIPTOR_SUFFIX);
  CharOperation.replace(result, '.', '/');
  return result;
}

public void consumeLocalType(char[] uniqueKey) {
  this.signature = new StringBuffer();
  // remove trailing semi-colon as it is added later in comsumeType()
  uniqueKey = CharOperation.subarray(uniqueKey, 0, uniqueKey.length-1);
  if (!this.asBinarySignature)
    CharOperation.replace(uniqueKey, '/', '.');
  this.signature.append(uniqueKey);
}

public void consumeLocalType(char[] uniqueKey) {
  this.signature = new StringBuffer();
  // remove trailing semi-colon as it is added later in comsumeType()
  uniqueKey = CharOperation.subarray(uniqueKey, 0, uniqueKey.length-1);
  CharOperation.replace(uniqueKey, '/', '.');
  this.signature.append(uniqueKey);
}

public static char[] createBindingKey(char[] packageName, char[] typeName) {
  char[] signature = createTypeSignature(packageName, typeName);
  CharOperation.replace(signature, '.', '/');
  return signature;
}

public void consumeLocalType(char[] uniqueKey) {
  this.signature = new StringBuffer();
  // remove trailing semi-colon as it is added later in comsumeType()
  uniqueKey = CharOperation.subarray(uniqueKey, 0, uniqueKey.length-1);
  CharOperation.replace(uniqueKey, '/', '.');
  this.signature.append(uniqueKey);
}

@Override
public void consumeLocalType(char[] uniqueKey) {
  this.signature = new StringBuffer();
  // remove trailing semi-colon as it is added later in comsumeType()
  uniqueKey = CharOperation.subarray(uniqueKey, 0, uniqueKey.length-1);
  if (!this.asBinarySignature)
    CharOperation.replace(uniqueKey, '/', '.');
  this.signature.append(uniqueKey);
}

public static char[] createBindingKey(char[] packageName, char[] typeName) {
  char[] signature = createTypeSignature(packageName, typeName);
  CharOperation.replace(signature, '.', '/');
  return signature;
}

public static char[] fullyQualifiedNameToFieldDescriptor(char[] fullyQualifiedName) {
  char[] result = CharArrayUtils.concat(FIELD_DESCRIPTOR_PREFIX, fullyQualifiedName, FIELD_DESCRIPTOR_SUFFIX);
  CharOperation.replace(result, '.', '/');
  return result;
}

@Override
public String toString() {
  ReferenceBinding binding = (ReferenceBinding) this._binding;
  char[] concatWith = CharOperation.concatWith(binding.compoundName, '.');
  if (binding.isNestedType()) {
    CharOperation.replace(concatWith, '$', '.');
    return new String(concatWith);
  }
  return new String(concatWith);
}

private String returnClassName(char[] classInfoName) {
  if (classInfoName.length == 0) {
    return EMPTY_CLASS_NAME;
  } else if (isCompact()) {
    int lastIndexOfSlash = CharOperation.lastIndexOf('/', classInfoName);
    if (lastIndexOfSlash != -1) {
      return new String(classInfoName, lastIndexOfSlash + 1, classInfoName.length - lastIndexOfSlash - 1);
    }
  }
  CharOperation.replace(classInfoName, '/', '.');
  return new String(classInfoName);
}

@Override
public String toString() {
  ReferenceBinding binding = (ReferenceBinding) this._binding;
  char[] concatWith = CharOperation.concatWith(binding.compoundName, '.');
  if (binding.isNestedType()) {
    CharOperation.replace(concatWith, '$', '.');
    return new String(concatWith);
  }
  return new String(concatWith);
}

private String returnMethodSignature(IConstantPoolEntry constantMethodref) {
  final char[] methodDescriptor = constantMethodref.getMethodDescriptor();
  CharOperation.replace(methodDescriptor, '$', '#');
  final char[] signature = Util.toString(
      constantMethodref.getClassName(),
      constantMethodref.getMethodName(),
      methodDescriptor,
      true,
      isCompact()).toCharArray();
  CharOperation.replace(signature, '#', '$');
  return String.valueOf(signature);
}

public char[] normalizedPath() {
  if (this.normalizedPath == null) {
    String path2 = this.getPath();
    char[] rawName = path2.toCharArray();
    if (File.separatorChar == '\\') {
      CharOperation.replace(rawName, '\\', '/');
    }
    this.normalizedPath = CharOperation.subarray(rawName, 0, CharOperation.lastIndexOf('.', rawName));
  }
  return this.normalizedPath;
}
public String getPath() {

@Override
public Name getQualifiedName() {
  ReferenceBinding binding = (ReferenceBinding)_binding;
  char[] qName;
  if (binding.isMemberType()) {
    qName = CharOperation.concatWith(binding.enclosingType().compoundName, binding.sourceName, '.');
    CharOperation.replace(qName, '$', '.');
  } else {
    qName = CharOperation.concatWith(binding.compoundName, '.');
  }
  return new NameImpl(qName);
}

@Override
public Name getQualifiedName() {
  ReferenceBinding binding = (ReferenceBinding)_binding;
  char[] qName;
  if (binding.isMemberType()) {
    qName = CharOperation.concatWith(binding.enclosingType().compoundName, binding.sourceName, '.');
    CharOperation.replace(qName, '$', '.');
  } else {
    qName = CharOperation.concatWith(binding.compoundName, '.');
  }
  return new NameImpl(qName);
}

@Override
public Name getQualifiedName() {
  ReferenceBinding binding = (ReferenceBinding)_binding;
  char[] qName;
  if (binding.isMemberType()) {
    qName = CharOperation.concatWith(binding.enclosingType().compoundName, binding.sourceName, '.');
    CharOperation.replace(qName, '$', '.');
  } else {
    qName = CharOperation.concatWith(binding.compoundName, '.');
  }
  return new NameImpl(qName);
}

@Override
public Name getQualifiedName() {
  ReferenceBinding binding = (ReferenceBinding)_binding;
  char[] qName;
  if (binding.isMemberType()) {
    qName = CharOperation.concatWith(binding.enclosingType().compoundName, binding.sourceName, '.');
    CharOperation.replace(qName, '$', '.');
  } else {
    qName = CharOperation.concatWith(binding.compoundName, '.');
  }
  return new NameImpl(qName);
}

Javadoc

Replace all occurrence of the character to be replaced with the replacement character in the given array.

For example:

 
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } 
toBeReplaced = 'b' 
replacementChar = 'a' 
result => No returned value, but array is now equals to { 'a' , 'a', 'a', 'a', 'a', 'a' }

 
array = { 'a' , 'b', 'b', 'a', 'b', 'a' } 
toBeReplaced = 'c' 
replacementChar = 'a' 
result => No returned value, but array is now equals to { 'a' , 'b', 'b', 'a', 'b', 'a' }

Popular methods of CharOperation

equals
If isCaseSensite is true, answers true if the two arrays are identical character by character, other
lastIndexOf
Answers the last index in the array for which the corresponding character is equal to toBeFound star
splitOn
Return a new array which is the split of the given array using the given divider. The given end is e
subarray
Answers a new array which is a copy of the given array starting at the given start and ending at the
toString
Answers a string which is the concatenation of the given array using the '.' as a separator. For ex
arrayConcat
Answers the concatenation of the two arrays. It answers null if the two arrays are null. If the firs
camelCaseMatch
Answers true if the pattern matches the given name using CamelCase rules, or false otherwise. char[]
concatWith
Answers the concatenation of the given array parts using the given separator between each part and a
pathMatch
Answers true if the pattern matches the filepath using the pathSepatator, false otherwise. Path char
indexOf
Answers the first index in the array for which the toBeFound array is a matching subarray following
compareTo
Compares the two char arrays lexicographically between the given start and end positions. Returns a
concat
Answers the concatenation of the three arrays. It answers null if the three arrays are null. If firs

Popular in Java

Start an intent from android
setScale (BigDecimal)
getExternalFilesDir (Context)
compareTo (BigDecimal)
Compares this BigDecimal with the specified BigDecimal. Two BigDecimal objects that are equal in val
OutputStream (java.io)
A writable sink for bytes.Most clients will use output streams that write data to the file system (
System (java.lang)
Provides access to system-related information and resources including standard input and output. Ena
URLConnection (java.net)
The abstract class URLConnection is the superclass of all classes that represent a communications li
ByteBuffer (java.nio)
A buffer for bytes. A byte buffer can be created in either one of the following ways: * #allocate(i
Executor (java.util.concurrent)
An object that executes submitted Runnable tasks. This interface provides a way of decoupling task s
TimeUnit (java.util.concurrent)
A TimeUnit represents time durations at a given unit of granularity and provides utility methods to

How to use replacemethodin org.eclipse.jdt.core.compiler.CharOperation

Best Java code snippets using org.eclipse.jdt.core.compiler.CharOperation.replace (Showing top 20 results out of 315)

How to use
replace
method
in
org.eclipse.jdt.core.compiler.CharOperation