Codota Logo
CharOperation.concatWith
Code IndexAdd Codota to your IDE (free)

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

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

  • Add the Codota plugin to your IDE and get smart completions
private void myMethod () {
Dictionary d =
  • Codota Iconnew Hashtable()
  • Codota IconBundle bundle;bundle.getHeaders()
  • Codota Iconnew Properties()
  • Smart code suggestions by Codota
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

public PackageVisibilityStatement(ImportReference pkgRef, ModuleReference[] targets) {
  this.pkgRef = pkgRef;
  this.pkgName = CharOperation.concatWith(this.pkgRef.tokens, '.');
  this.targets = targets;
}
public boolean isQualified() {
origin: org.eclipse.jdt/org.eclipse.jdt.core

public ModuleDeclaration(CompilationResult compilationResult, char[][] tokens, long[] positions) {
  this.compilationResult = compilationResult;
  this.exportsCount = 0;
  this.requiresCount = 0;
  this.tokens = tokens;
  this.moduleName = CharOperation.concatWith(tokens, '.');
  this.sourcePositions = positions;
  this.sourceEnd = (int) (positions[positions.length-1] & 0x00000000FFFFFFFF);
  this.sourceStart = (int) (positions[0] >>> 32);
}
origin: org.eclipse.jdt.core.compiler/ecj

public char[] readableName() {
  if (this.onDemand)
    return CharOperation.concat(CharOperation.concatWith(this.compoundName, '.'), ".*".toCharArray()); //$NON-NLS-1$
  else
    return CharOperation.concatWith(this.compoundName, '.');
}
public String toString() {
origin: org.eclipse.jdt/org.eclipse.jdt.core

@Override
public char[] readableName() {
  if (this.onDemand)
    return CharOperation.concat(CharOperation.concatWith(this.compoundName, '.'), ".*".toCharArray()); //$NON-NLS-1$
  else
    return CharOperation.concatWith(this.compoundName, '.');
}
@Override
origin: org.eclipse.jdt.core.compiler/ecj

public NameEnvironmentAnswer findType(char[][] compoundName) {
  if (compoundName != null)
    return findClass(
      new String(CharOperation.concatWith(compoundName, '/')),
      compoundName[compoundName.length - 1],
      false);
  return null;
}
public char[][][] findTypeNames(char[][] packageName) {
origin: org.eclipse.jdt.core.compiler/ecj

public String toString() {
  StringBuffer buffer = new StringBuffer(10);
  buffer.append("ProblemType:[compoundName="); //$NON-NLS-1$
  buffer.append(this.compoundName == null ? "<null>" : new String(CharOperation.concatWith(this.compoundName,'.'))); //$NON-NLS-1$
  buffer.append("][problemID=").append(problemReasonString(this.problemReason)); //$NON-NLS-1$
  buffer.append("][closestMatch="); //$NON-NLS-1$
  buffer.append(this.closestMatch == null ? "<null>" : this.closestMatch.toString()); //$NON-NLS-1$
  buffer.append("]"); //$NON-NLS-1$
  return buffer.toString();
}
}
origin: org.eclipse.jdt.core.compiler/ecj

public void contradictoryNullAnnotationsOnBounds(Annotation annotation, long previousTagBit) {
  char[][] annotationName = previousTagBit == TagBits.AnnotationNonNull ? this.options.nonNullAnnotationName : this.options.nullableAnnotationName;
  String[] arguments = {
    new String(CharOperation.concatWith(annotationName, '.')),
  };
  String[] shortArguments = {
    new String(annotationName[annotationName.length-1]),
  };
  this.handle(IProblem.ContradictoryNullAnnotationsOnBound, arguments, shortArguments, annotation.sourceStart, annotation.sourceEnd);
}

origin: org.eclipse.jdt/org.eclipse.jdt.core

@Override
public String toString() {
  StringBuffer buffer = new StringBuffer(10);
  buffer.append("ProblemType:[compoundName="); //$NON-NLS-1$
  buffer.append(this.compoundName == null ? "<null>" : new String(CharOperation.concatWith(this.compoundName,'.'))); //$NON-NLS-1$
  buffer.append("][problemID=").append(problemReasonString(this.problemReason)); //$NON-NLS-1$
  buffer.append("][closestMatch="); //$NON-NLS-1$
  buffer.append(this.closestMatch == null ? "<null>" : this.closestMatch.toString()); //$NON-NLS-1$
  buffer.append("]"); //$NON-NLS-1$
  return buffer.toString();
}
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

/**
 * @see ISourceElementRequestor#acceptPackage(ImportReference)
 */
@Override
public void acceptPackage(ImportReference importReference) {
  this.packageName = CharOperation.concatWith(importReference.getImportName(), '.');
}
/**
origin: org.eclipse.jdt/org.eclipse.jdt.core

private void acceptPackageVisibilityStatements(PackageVisibilityStatement[] pvs, Scope scope) {
  if (pvs != null) {
    for (PackageVisibilityStatement pv : pvs) {
      if (pv.pkgRef instanceof SelectionOnPackageVisibilityReference) {
        this.noProposal = false;
        this.requestor.acceptPackage(CharOperation.concatWith(((SelectionOnPackageVisibilityReference) pv.pkgRef).tokens, '.'));
      }
    }
  }
}
private void selectMemberTypeFromImport(CompilationUnitDeclaration parsedUnit, char[] lastToken, ReferenceBinding ref, boolean staticOnly) {
origin: org.eclipse.jdt/org.eclipse.jdt.core

public void contradictoryNullAnnotationsOnBounds(Annotation annotation, long previousTagBit) {
  char[][] annotationName = previousTagBit == TagBits.AnnotationNonNull ? this.options.nonNullAnnotationName : this.options.nullableAnnotationName;
  String[] arguments = {
    new String(CharOperation.concatWith(annotationName, '.')),
  };
  String[] shortArguments = {
    new String(annotationName[annotationName.length-1]),
  };
  this.handle(IProblem.ContradictoryNullAnnotationsOnBound, arguments, shortArguments, annotation.sourceStart, annotation.sourceEnd);
}

origin: org.eclipse.jdt.core.compiler/ecj

public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName) {
  if (typeName != null)
    return findClass(
      new String(CharOperation.concatWith(packageName, typeName, '/')),
      typeName,
      false);
  return null;
}
public boolean isPackage(char[][] compoundName, char[] packageName) {
origin: org.eclipse.jdt/org.eclipse.jdt.core

  @Override
  public StringBuffer print(int indent, StringBuffer output) {

    printIndent(indent, output).append("<SelectOnPackageVisibility:"); //$NON-NLS-1$
    output.append(new String(CharOperation.concatWith(this.tokens, '.')));
    return output.append('>');
  }
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

private static Service createService(TypeReference service, TypeReference[] with) {
  Service ser = new Service();
  ser.provides = CharOperation.concatWith(service.getTypeName(), '.');
  ser.with = new char[with.length][];
  for (int i = 0; i < with.length; i++) {
    ser.with[i] = CharOperation.concatWith(with[i].getTypeName(), '.');
  }
  return ser;
}
private static PackageExportImpl createPackageOpen(OpensStatement ref) {
origin: org.eclipse.jdt.core.compiler/ecj

@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);
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

private AccessRestriction getViolatedRestriction(String typeName, String packageName, ClasspathEntry entry, AccessRestriction accessRestriction) {
  AccessRuleSet accessRuleSet = entry.getAccessRuleSet();
  if (accessRuleSet != null) {
    // TODO (philippe) improve char[] <-> String conversions to avoid performing them on the fly
    char[][] packageChars = CharOperation.splitOn('.', packageName.toCharArray());
    char[] typeChars = typeName.toCharArray();
    accessRestriction = accessRuleSet.getViolatedRestriction(CharOperation.concatWith(packageChars, typeChars, '/'));
  }
  return accessRestriction;
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

@Override
public void acceptPackage(ImportReference importReference) {
  int[] sourceRange= new int[] {importReference.declarationSourceStart, importReference.declarationSourceEnd};
  char[] name = CharOperation.concatWith(importReference.getImportName(), '.');
  this.fNode= new DOMPackage(this.fDocument, sourceRange, new String(name));
  addChild(this.fNode);
}
/**
origin: org.eclipse.jdt.core.compiler/ecj

public char [][] getTypeName() {
  switch (this.kind) {
    case Wildcard.UNBOUND :
      return new char[][] { WILDCARD_NAME };
    case Wildcard.EXTENDS :
      return new char[][] { CharOperation.concat(WILDCARD_NAME, WILDCARD_EXTENDS, CharOperation.concatWith(this.bound.getTypeName(), '.')) };
    default: // SUPER
      return new char[][] { CharOperation.concat(WILDCARD_NAME, WILDCARD_SUPER, CharOperation.concatWith(this.bound.getTypeName(), '.')) };
  }
}
origin: org.eclipse.jdt/org.eclipse.jdt.core

private static String[] typeSignatures(TypeReference[] types) {
  int length = types.length;
  String[] typeSignatures = new String[length];
  for(int i = 0; i < length; i++) {
    char[][] compoundName = types[i].getParameterizedTypeName();
    char[] typeName = CharOperation.concatWith(compoundName, '.');
    typeSignatures[i] = Signature.createTypeSignature(typeName, false/*don't resolve*/);
  }
  return typeSignatures;
}
/**
origin: org.eclipse.jdt/org.eclipse.jdt.core

@Override
public NameEnvironmentAnswer findType(char[] typeName, char[][] packageName, char[] moduleName) {
  return findClass(
      String.valueOf(CharOperation.concatWith(packageName, typeName, '/')),
      typeName,
      LookupStrategy.get(moduleName),
      LookupStrategy.getStringName(moduleName));
}

org.eclipse.jdt.core.compilerCharOperationconcatWith

Javadoc

Answers the concatenation of the given array parts using the given separator between each part and prepending the given name at the beginning.

For example:
  1.  
    name = { 'c' } 
    array = { { 'a' }, { 'b' } } 
    separator = '.' 
    => result = { 'a', '.', 'b' , '.', 'c' } 
    
  2.  
    name = null 
    array = { { 'a' }, { 'b' } } 
    separator = '.' 
    => result = { 'a', '.', 'b' } 
    
  3.  
    name = { ' c' } 
    array = null 
    separator = '.' 
    => result = { 'c' } 
    

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[]
  • 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
  • replace
    Answers a new array of characters with substitutions. No side-effect is operated on the original arr
  • 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
  • compareTo,
  • concat,
  • fragmentEquals,
  • isWhitespace,
  • match,
  • replaceOnCopy,
  • hashCode,
  • prefixEquals,
  • deepCopy

Popular in Java

  • Reading from database using SQL prepared statement
  • getSharedPreferences (Context)
  • putExtra (Intent)
  • scheduleAtFixedRate (ScheduledExecutorService)
    Creates and executes a periodic action that becomes enabled first after the given initial delay, and
  • BufferedReader (java.io)
    Reads text from a character-input stream, buffering characters so as to provide for the efficient re
  • BigDecimal (java.math)
    An immutable arbitrary-precision signed decimal.A value is represented by an arbitrary-precision "un
  • Collection (java.util)
    Collection is the root of the collection hierarchy. It defines operations on data collections and t
  • Iterator (java.util)
    An iterator over a collection. Iterator takes the place of Enumeration in the Java Collections Frame
  • Queue (java.util)
    A collection designed for holding elements prior to processing. Besides basic java.util.Collection o
  • JList (javax.swing)
Codota Logo
  • Products

    Search for Java codeSearch for JavaScript codeEnterprise
  • IDE Plugins

    IntelliJ IDEAWebStormAndroid StudioEclipseVisual Studio CodePyCharmSublime TextPhpStormVimAtomGoLandRubyMineEmacsJupyter
  • Company

    About UsContact UsCareers
  • Resources

    FAQBlogCodota Academy Plugin user guide Terms of usePrivacy policyJava Code IndexJavascript Code Index
Get Codota for your IDE now