Java Code Examples for org.eclipse.jdt.core.compiler.CharOperation#NO_STRINGS

public IJavaElement getHandleFromMemento(String token, MementoTokenizer memento, WorkingCopyOwner owner) {
	switch (token.charAt(0)) {
		case JEM_PACKAGEFRAGMENT:
			String[] pkgName;
			if (memento.hasMoreTokens()) {
				token = memento.nextToken();
				char firstChar = token.charAt(0);
				if (firstChar == JEM_CLASSFILE || firstChar == JEM_COMPILATIONUNIT || firstChar == JEM_COUNT) {
					pkgName = CharOperation.NO_STRINGS;
				} else {
					pkgName = Util.splitOn('.', token, 0, token.length());
					token = null;
				}
			} else {
				pkgName = CharOperation.NO_STRINGS;
				token = null;
			}
			JavaElement pkg = getPackageFragment(pkgName);
			if (token == null) {
				return pkg.getHandleFromMemento(memento, owner);
			} else {
				return pkg.getHandleFromMemento(token, memento, owner);
			}
	}
	return null;
}
 

/**
 * Return a new array which is the split of the given string using the given divider. The given end
 * is exclusive and the given start is inclusive.
 * <br>
 * <br>
 * For example:
 * <ol>
 * <li><pre>
 *    divider = 'b'
 *    string = "abbaba"
 *    start = 2
 *    end = 5
 *    result => { "", "a", "" }
 * </pre>
 * </li>
 * </ol>
 *
 * @param divider the given divider
 * @param string the given string
 * @param start the given starting index
 * @param end the given ending index
 * @return a new array which is the split of the given string using the given divider
 * @throws ArrayIndexOutOfBoundsException if start is lower than 0 or end is greater than the array length
 */
public static final String[] splitOn(
	char divider,
	String string,
	int start,
	int end) {
	int length = string == null ? 0 : string.length();
	if (length == 0 || start > end)
		return CharOperation.NO_STRINGS;

	int wordCount = 1;
	for (int i = start; i < end; i++)
		if (string.charAt(i) == divider)
			wordCount++;
	String[] split = new String[wordCount];
	int last = start, currentWord = 0;
	for (int i = start; i < end; i++) {
		if (string.charAt(i) == divider) {
			split[currentWord++] = string.substring(last, i);
			last = i + 1;
		}
	}
	split[currentWord] = string.substring(last, end);
	return split;
}
 

/**
 * @see IDOMType#setSuperInterfaces(String[])
 */
public void setSuperInterfaces(String[] names) {
	becomeDetailed();
	if (names == null) {
		throw new IllegalArgumentException(Messages.dom_nullInterfaces);
	}
	fragment();
	this.fSuperInterfaces= names;
	if (names.length == 0) {
		this.fInterfaces= null;
		this.fSuperInterfaces= CharOperation.NO_STRINGS;
		setMask(MASK_TYPE_HAS_INTERFACES, false);
	} else {
		setMask(MASK_TYPE_HAS_INTERFACES, true);
		CharArrayBuffer buffer = new CharArrayBuffer();
		for (int i = 0; i < names.length; i++) {
			if (i > 0) {
				buffer.append(", "); //$NON-NLS-1$
			}
			buffer.append(names[i]);
		}
		this.fInterfaces = buffer.getContents();
	}
}
 

private synchronized String[] readAllDocumentNames() throws IOException {
	if (this.numberOfChunks <= 0)
		return CharOperation.NO_STRINGS;

	InputStream stream = this.indexLocation.getInputStream();
	try {
		int offset = this.chunkOffsets[0];
		stream.skip(offset);
		this.streamBuffer = new byte[BUFFER_READ_SIZE];
		this.bufferIndex = 0;
		this.bufferEnd = stream.read(this.streamBuffer, 0, this.streamBuffer.length);
		int lastIndex = this.numberOfChunks - 1;
		String[] docNames = new String[lastIndex * CHUNK_SIZE + this.sizeOfLastChunk];
		for (int i = 0; i < this.numberOfChunks; i++)
			readChunk(docNames, stream, i * CHUNK_SIZE, i < lastIndex ? CHUNK_SIZE : this.sizeOfLastChunk);
		return docNames;
	} finally {
		stream.close();
		this.streamBuffer = null;
	}
}
 

public String[] getBoundsSignatures() throws JavaModelException {
	
	String[] boundSignatures = null;
	TypeParameterElementInfo info = (TypeParameterElementInfo) this.getElementInfo();
	
	// For a binary type or method, the signature is already available from the .class file.
	// No need to construct again
	if (this.parent instanceof BinaryMember) {
		char[][] boundsSignatures = info.boundsSignatures;
		if (boundsSignatures == null || boundsSignatures.length == 0) {
			return CharOperation.NO_STRINGS;	
		}
		return CharOperation.toStrings(info.boundsSignatures);
	}
	
	char[][] bounds = info.bounds;
	if (bounds == null || bounds.length == 0) {
		return CharOperation.NO_STRINGS;
	}

	int boundsLength = bounds.length;
	boundSignatures = new String[boundsLength];
	for (int i = 0; i < boundsLength; i++) {
		boundSignatures[i] = new String(Signature.createCharArrayTypeSignature(bounds[i], false));
	}
	return boundSignatures;
}
 

private static String[] filterFromList(List imports, char prefix) {
	if (imports == null) {
		return CharOperation.NO_STRINGS;
	}
	ArrayList res= new ArrayList();
	for (int i= 0; i < imports.size(); i++) {
		String curr= (String) imports.get(i);
		if (prefix == curr.charAt(0)) {
			res.add(curr.substring(1));
		}
	}
	return (String[]) res.toArray(new String[res.size()]);
}
 

private ImportRewrite(ICompilationUnit cu, CompilationUnit astRoot, List existingImports) {
	this.compilationUnit= cu;
	this.astRoot= astRoot; // might be null
	if (existingImports != null) {
		this.existingImports= existingImports;
		this.restoreExistingImports= !existingImports.isEmpty();
	} else {
		this.existingImports= new ArrayList();
		this.restoreExistingImports= false;
	}
	this.filterImplicitImports= true;
	// consider that no contexts are used
	this.useContextToFilterImplicitImports = false;

	this.defaultContext= new ImportRewriteContext() {
		public int findInContext(String qualifier, String name, int kind) {
			return findInImports(qualifier, name, kind);
		}
	};
	this.addedImports= null; // Initialized on use
	this.removedImports= null; // Initialized on use
	this.createdImports= null;
	this.createdStaticImports= null;

	this.importOrder= CharOperation.NO_STRINGS;
	this.importOnDemandThreshold= 99;
	this.staticImportOnDemandThreshold= 99;
	
	this.importsKindMap = new HashMap();
}
 

/**
 * @see IMethod#getTypeParameterSignatures()
 * @since 3.0
 * @deprecated
 */
public String[] getTypeParameterSignatures() throws JavaModelException {
	IBinaryMethod info = (IBinaryMethod) getElementInfo();
	char[] genericSignature = info.getGenericSignature();
	if (genericSignature == null)
		return CharOperation.NO_STRINGS;
	char[] dotBasedSignature = CharOperation.replaceOnCopy(genericSignature, '/', '.');
	char[][] typeParams = Signature.getTypeParameters(dotBasedSignature);
	return CharOperation.toStrings(typeParams);
}
 

public String[] getExceptionTypes() throws JavaModelException {
	if (this.exceptionTypes == null) {
		IBinaryMethod info = (IBinaryMethod) getElementInfo();
		char[] genericSignature = info.getGenericSignature();
		if (genericSignature != null) {
			char[] dotBasedSignature = CharOperation.replaceOnCopy(genericSignature, '/', '.');
			this.exceptionTypes = Signature.getThrownExceptionTypes(new String(dotBasedSignature));
		}
		if (this.exceptionTypes == null || this.exceptionTypes.length == 0) {
			char[][] eTypeNames = info.getExceptionTypeNames();
			if (eTypeNames == null || eTypeNames.length == 0) {
				this.exceptionTypes = CharOperation.NO_STRINGS;
			} else {
				eTypeNames = ClassFile.translatedNames(eTypeNames);
				this.exceptionTypes = new String[eTypeNames.length];
				for (int j = 0, length = eTypeNames.length; j < length; j++) {
					// 1G01HRY: ITPJCORE:WINNT - method.getExceptionType not in correct format
					int nameLength = eTypeNames[j].length;
					char[] convertedName = new char[nameLength + 2];
					System.arraycopy(eTypeNames[j], 0, convertedName, 1, nameLength);
					convertedName[0] = 'L';
					convertedName[nameLength + 1] = ';';
					this.exceptionTypes[j] = new String(convertedName);
				}
			}
		}
	}
	return this.exceptionTypes;
}
 

protected BinaryMethod(JavaElement parent, String name, String[] paramTypes) {
	super(parent, name);
	// Assertion disabled since bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=179011
	// Assert.isTrue(name.indexOf('.') == -1);
	if (paramTypes == null) {
		this.parameterTypes= CharOperation.NO_STRINGS;
	} else {
		this.parameterTypes= paramTypes;
	}
}
 

public static String[] typeParameterSignatures(AbstractMethodDeclaration method) {
	Argument[] args = method.arguments;
	if (args != null) {
		int length = args.length;
		String[] signatures = new String[length];
		for (int i = 0; i < args.length; i++) {
			Argument arg = args[i];
			signatures[i] = typeSignature(arg.type);
		}
		return signatures;
	}
	return CharOperation.NO_STRINGS;
}
 

/**
 * @see IType#getTypeParameterSignatures()
 * @since 3.0
 */
public String[] getTypeParameterSignatures() throws JavaModelException {
	IBinaryType info = (IBinaryType) getElementInfo();
	char[] genericSignature = info.getGenericSignature();
	if (genericSignature == null)
		return CharOperation.NO_STRINGS;

	char[] dotBaseSignature = CharOperation.replaceOnCopy(genericSignature, '/', '.');
	char[][] typeParams = Signature.getTypeParameters(dotBaseSignature);
	return CharOperation.toStrings(typeParams);
}
 

public String[] getSuperInterfaceNames() throws JavaModelException {
	IBinaryType info = (IBinaryType) getElementInfo();
	char[][] names= info.getInterfaceNames();
	int length;
	if (names == null || (length = names.length) == 0) {
		return CharOperation.NO_STRINGS;
	}
	names= ClassFile.translatedNames(names);
	String[] strings= new String[length];
	for (int i= 0; i < length; i++) {
		strings[i]= new String(names[i]);
	}
	return strings;
}
 

protected SourceMethod(JavaElement parent, String name, String[] parameterTypes) {
	super(parent, name);
	// Assertion disabled since bug https://bugs.eclipse.org/bugs/show_bug.cgi?id=179011
	// Assert.isTrue(name.indexOf('.') == -1);
	if (parameterTypes == null) {
		this.parameterTypes= CharOperation.NO_STRINGS;
	} else {
		this.parameterTypes= parameterTypes;
	}
}
 

/**
 * Returns the <code>ICompilationUnit</code> which defines the type
 * named <code>qualifiedTypeName</code>, or <code>null</code> if
 * none exists. The domain of the search is bounded by the classpath
 * of the <code>IJavaProject</code> this <code>NameLookup</code> was
 * obtained from.
 * <p>
 * The name must be fully qualified (eg "java.lang.Object", "java.util.Hashtable$Entry")
 */
public ICompilationUnit findCompilationUnit(String qualifiedTypeName) {
	String[] pkgName = CharOperation.NO_STRINGS;
	String cuName = qualifiedTypeName;

	int index= qualifiedTypeName.lastIndexOf('.');
	if (index != -1) {
		pkgName= Util.splitOn('.', qualifiedTypeName, 0, index);
		cuName= qualifiedTypeName.substring(index + 1);
	}
	index= cuName.indexOf('$');
	if (index != -1) {
		cuName= cuName.substring(0, index);
	}
	int pkgIndex = this.packageFragments.getIndex(pkgName);
	if (pkgIndex != -1) {
		Object value = this.packageFragments.valueTable[pkgIndex];
		// reuse existing String[]
		pkgName = (String[]) this.packageFragments.keyTable[pkgIndex];
		if (value instanceof PackageFragmentRoot) {
			return findCompilationUnit(pkgName, cuName, (PackageFragmentRoot) value);
		} else {
			IPackageFragmentRoot[] roots = (IPackageFragmentRoot[]) value;
			for (int i= 0; i < roots.length; i++) {
				PackageFragmentRoot root= (PackageFragmentRoot) roots[i];
				ICompilationUnit cu = findCompilationUnit(pkgName, cuName, root);
				if (cu != null)
					return cu;
			}
		}
	}
	return null;
}
 

String[] directoryList(String qualifiedPackageName) {
	String[] dirList = (String[]) this.directoryCache.get(qualifiedPackageName);
	if (dirList == this.missingPackageHolder) return null; // package exists in another classpath directory or jar
	if (dirList != null) return dirList;

	File dir = new File(this.path + qualifiedPackageName);
	notFound : if (dir.isDirectory()) {
		// must protect against a case insensitive File call
		// walk the qualifiedPackageName backwards looking for an uppercase character before the '/'
		int index = qualifiedPackageName.length();
		int last = qualifiedPackageName.lastIndexOf(File.separatorChar);
		while (--index > last && !ScannerHelper.isUpperCase(qualifiedPackageName.charAt(index))){/*empty*/}
		if (index > last) {
			if (last == -1) {
				if (!doesFileExist(qualifiedPackageName, Util.EMPTY_STRING))
					break notFound;
			} else {
				String packageName = qualifiedPackageName.substring(last + 1);
				String parentPackage = qualifiedPackageName.substring(0, last);
				if (!doesFileExist(packageName, parentPackage))
					break notFound;
			}
		}
		if ((dirList = dir.list()) == null)
			dirList = CharOperation.NO_STRINGS;
		this.directoryCache.put(qualifiedPackageName, dirList);
		return dirList;
	}
	this.directoryCache.put(qualifiedPackageName, this.missingPackageHolder);
	return null;
}
 

public String[] getCategories() throws JavaModelException {
	IType type = (IType) getAncestor(IJavaElement.TYPE);
	if (type == null) return CharOperation.NO_STRINGS;
	if (type.isBinary()) {
		return CharOperation.NO_STRINGS;
	} else {
		SourceTypeElementInfo info = (SourceTypeElementInfo) ((SourceType) type).getElementInfo();
		HashMap map = info.getCategories();
		if (map == null) return CharOperation.NO_STRINGS;
		String[] categories = (String[]) map.get(this);
		if (categories == null) return CharOperation.NO_STRINGS;
		return categories;
	}
}
 

public void build(boolean computeSubtypes) {
	JavaModelManager manager = JavaModelManager.getJavaModelManager();
	try {
		// optimize access to zip files while building hierarchy
		manager.cacheZipFiles(this);

		if (computeSubtypes) {
			// Note by construction there always is a focus type here
			IType focusType = getType();
			boolean focusIsObject = focusType.getElementName().equals(new String(IIndexConstants.OBJECT));
			int amountOfWorkForSubtypes = focusIsObject ? 5 : 80; // percentage of work needed to get possible subtypes
			IProgressMonitor possibleSubtypesMonitor =
				this.hierarchy.progressMonitor == null ?
					null :
					new SubProgressMonitor(this.hierarchy.progressMonitor, amountOfWorkForSubtypes);
			HashSet localTypes = new HashSet(10); // contains the paths that have potential subtypes that are local/anonymous types
			String[] allPossibleSubtypes;
			if (((Member)focusType).getOuterMostLocalContext() == null) {
				// top level or member type
				allPossibleSubtypes = determinePossibleSubTypes(localTypes, possibleSubtypesMonitor);
			} else {
				// local or anonymous type
				allPossibleSubtypes = CharOperation.NO_STRINGS;
			}
			if (allPossibleSubtypes != null) {
				IProgressMonitor buildMonitor =
					this.hierarchy.progressMonitor == null ?
						null :
						new SubProgressMonitor(this.hierarchy.progressMonitor, 100 - amountOfWorkForSubtypes);
				this.hierarchy.initialize(allPossibleSubtypes.length);
				buildFromPotentialSubtypes(allPossibleSubtypes, localTypes, buildMonitor);
			}
		} else {
			this.hierarchy.initialize(1);
			buildSupertypes();
		}
	} finally {
		manager.flushZipFiles(this);
	}
}
 

private IMemberValuePair[] getTargetElementTypes(long tagBits) {
	ArrayList values = new ArrayList();
	String elementType = new String(CharOperation.concatWith(TypeConstants.JAVA_LANG_ANNOTATION_ELEMENTTYPE, '.')) + '.';
	if ((tagBits & TagBits.AnnotationForType) != 0) {
		values.add(elementType + new String(TypeConstants.TYPE));
	}
	if ((tagBits & TagBits.AnnotationForField) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_FIELD));
	}
	if ((tagBits & TagBits.AnnotationForMethod) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_METHOD));
	}
	if ((tagBits & TagBits.AnnotationForParameter) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_PARAMETER));
	}
	if ((tagBits & TagBits.AnnotationForConstructor) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_CONSTRUCTOR));
	}
	if ((tagBits & TagBits.AnnotationForLocalVariable) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_LOCAL_VARIABLE));
	}
	if ((tagBits & TagBits.AnnotationForAnnotationType) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_ANNOTATION_TYPE));
	}
	if ((tagBits & TagBits.AnnotationForPackage) != 0) {
		values.add(elementType + new String(TypeConstants.UPPER_PACKAGE));
	}
	final Object value;
	if (values.size() == 0) {
		if ((tagBits & TagBits.AnnotationTarget) != 0)
			value = CharOperation.NO_STRINGS;
		else
			return Annotation.NO_MEMBER_VALUE_PAIRS;
	} else if (values.size() == 1) {
		value = values.get(0);
	} else {
		value = values.toArray(new String[values.size()]);
	}
	return new IMemberValuePair[] {
		new IMemberValuePair() {
			public int getValueKind() {
				return IMemberValuePair.K_QUALIFIED_NAME;
			}
			public Object getValue() {
				return value;
			}
			public String getMemberName() {
				return new String(TypeConstants.VALUE);
			}
		}
	};
}
 

/**
 * Record a new marker denoting a classpath problem
 */
public void createClasspathProblemMarker(IJavaModelStatus status) {

	IMarker marker = null;
	int severity;
	String[] arguments = CharOperation.NO_STRINGS;
	boolean isCycleProblem = false, isClasspathFileFormatProblem = false, isOutputOverlapping = false;
	switch (status.getCode()) {

		case  IJavaModelStatusConstants.CLASSPATH_CYCLE :
			isCycleProblem = true;
			if (JavaCore.ERROR.equals(getOption(JavaCore.CORE_CIRCULAR_CLASSPATH, true))) {
				severity = IMarker.SEVERITY_ERROR;
			} else {
				severity = IMarker.SEVERITY_WARNING;
			}
			break;

		case  IJavaModelStatusConstants.INVALID_CLASSPATH_FILE_FORMAT :
			isClasspathFileFormatProblem = true;
			severity = IMarker.SEVERITY_ERROR;
			break;

		case  IJavaModelStatusConstants.INCOMPATIBLE_JDK_LEVEL :
			String setting = getOption(JavaCore.CORE_INCOMPATIBLE_JDK_LEVEL, true);
			if (JavaCore.ERROR.equals(setting)) {
				severity = IMarker.SEVERITY_ERROR;
			} else if (JavaCore.WARNING.equals(setting)) {
				severity = IMarker.SEVERITY_WARNING;
			} else {
				return; // setting == IGNORE
			}
			break;
		case IJavaModelStatusConstants.OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE :
			isOutputOverlapping = true;
			setting = getOption(JavaCore.CORE_OUTPUT_LOCATION_OVERLAPPING_ANOTHER_SOURCE, true);
			if (JavaCore.ERROR.equals(setting)) {
				severity = IMarker.SEVERITY_ERROR;
			} else if (JavaCore.WARNING.equals(setting)) {
				severity = IMarker.SEVERITY_WARNING;
			} else {
				return; // setting == IGNORE
			}
			break;
		default:
			IPath path = status.getPath();
			if (path != null) arguments = new String[] { path.toString() };
			if (JavaCore.ERROR.equals(getOption(JavaCore.CORE_INCOMPLETE_CLASSPATH, true)) &&
				status.getSeverity() != IStatus.WARNING) {
				severity = IMarker.SEVERITY_ERROR;
			} else {
				severity = IMarker.SEVERITY_WARNING;
			}
			break;
	}

	try {
		marker = this.project.createMarker(IJavaModelMarker.BUILDPATH_PROBLEM_MARKER);
		marker.setAttributes(
			new String[] {
				IMarker.MESSAGE,
				IMarker.SEVERITY,
				IMarker.LOCATION,
				IJavaModelMarker.CYCLE_DETECTED,
				IJavaModelMarker.CLASSPATH_FILE_FORMAT,
				IJavaModelMarker.OUTPUT_OVERLAPPING_SOURCE,
				IJavaModelMarker.ID,
				IJavaModelMarker.ARGUMENTS ,
				IJavaModelMarker.CATEGORY_ID,
				IMarker.SOURCE_ID,
			},
			new Object[] {
				status.getMessage(),
				new Integer(severity),
				Messages.classpath_buildPath,
				isCycleProblem ? "true" : "false",//$NON-NLS-1$ //$NON-NLS-2$
				isClasspathFileFormatProblem ? "true" : "false",//$NON-NLS-1$ //$NON-NLS-2$
				isOutputOverlapping ? "true" : "false", //$NON-NLS-1$ //$NON-NLS-2$
				new Integer(status.getCode()),
				Util.getProblemArgumentsForMarker(arguments) ,
				new Integer(CategorizedProblem.CAT_BUILDPATH),
				JavaBuilder.SOURCE_ID,
			}
		);
	} catch (CoreException e) {
		// could not create marker: cannot do much
		if (JavaModelManager.VERBOSE) {
			e.printStackTrace();
		}
	}
}