Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
Copyright (c) 2000, 2010 IBM Corporation and others. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html Contributors: IBM Corporation - initial API and implementation Tim Hanson <thanson@bea.com> - fix for https://bugs.eclipse.org/bugs/show_bug.cgi?id=137634 /
 
 package org.eclipse.jdt.internal.core.builder;
 
 
 public class ReferenceCollection {
 
 char[][][] qualifiedNameReferences// contains no simple names as in just 'a' which is kept in simpleNameReferences instead
 char[][] rootReferences;
 
 protected ReferenceCollection(char[][][] qualifiedNameReferenceschar[][] simpleNameReferenceschar[][] rootReferences) {
 	this. = internQualifiedNames(qualifiedNameReferencesfalse);
 	this. = internSimpleNames(simpleNameReferencestrue);
 	this. = internSimpleNames(rootReferencesfalse);
 }
 
 public void addDependencies(String[] typeNameDependencies) {
 	// if each qualified type name is already known then all of its subNames can be skipped
 	// and its expected that very few qualified names in typeNameDependencies need to be added
 	// but could always take 'p1.p2.p3.X' and make all qualified names 'p1' 'p1.p2' 'p1.p2.p3' 'p1.p2.p3.X', then intern
 	char[][][] qNames = new char[typeNameDependencies.length][][];
 	for (int i = typeNameDependencies.length; --i >= 0;)
 		qNames[i] = CharOperation.splitOn('.'typeNameDependencies[i].toCharArray());
 	qNames = internQualifiedNames(qNamesfalse);
 
 	next : for (int i = qNames.length; --i >= 0;) {
 		char[][] qualifiedTypeName = qNames[i];
 		while (!includes(qualifiedTypeName)) {
 			if (!includes(qualifiedTypeName[qualifiedTypeName.length - 1])) {
 				int length = this..length;
 				System.arraycopy(this., 0, this. = new char[length + 1][], 0, length);
 				this.[length] = qualifiedTypeName[qualifiedTypeName.length - 1];
 			}
 			if (!insideRoot(qualifiedTypeName[0])) {
 				int length = this..length;
 				System.arraycopy(this., 0, this. = new char[length + 1][], 0, length);
 				this.[length] = qualifiedTypeName[0];
 			}
 			int length = this..length;
 			System.arraycopy(this., 0, this. = new char[length + 1][][], 0, length);
 			this.[length] = qualifiedTypeName;
 
 			qualifiedTypeName = CharOperation.subarray(qualifiedTypeName, 0, qualifiedTypeName.length - 1);
 			char[][][] temp = internQualifiedNames(new char[][][] {qualifiedTypeName}, false);
 			if (temp == )
 				continue next; // qualifiedTypeName is a well known name
 			qualifiedTypeName = temp[0];
 		}
 	}
 }
 
 public boolean includes(char[] simpleName) {
 	for (int i = 0, l = this..lengthi < li++)
 		if (simpleName == this.[i]) return true;
 	return false;
 }
 
 public boolean includes(char[][] qualifiedName) {
 	for (int i = 0, l = this..lengthi < li++)
 		if (qualifiedName == this.[i]) return true;
 	return false;
 }

Deprecated:
 
 public boolean includes(char[][][] qualifiedNameschar[][] simpleNames) {
 	return includes(qualifiedNamessimpleNamesnull);
 }
 
 public boolean includes(char[][][] qualifiedNameschar[][] simpleNameschar[][] rootNames) {
 	// if either collection of names is null, it means it contained a well known name so we know it already has a match
 	if (rootNames != null) {
 		boolean foundRoot = false;
 		for (int i = 0, l = rootNames.length; !foundRoot && i < li++)
 			foundRoot = insideRoot(rootNames[i]);
 		if (!foundRoot)
 			return false;
 	}
 	if (simpleNames == null || qualifiedNames == null) {
 		if (simpleNames == null && qualifiedNames == null) {
 				..println("Found well known match"); //$NON-NLS-1$
 			return true;
 		} else if (qualifiedNames == null) {
 			for (int i = 0, l = simpleNames.lengthi < li++) {
 				if (includes(simpleNames[i])) {
						..println("Found match in well known package to " + new String(simpleNames[i])); //$NON-NLS-1$
					return true;
				}
			}
else {
			for (int i = 0, l = qualifiedNames.lengthi < li++) {
				char[][] qualifiedName = qualifiedNames[i];
				if (qualifiedName.length == 1 ? includes(qualifiedName[0]) : includes(qualifiedName)) {
						..println("Found well known match in " + CharOperation.toString(qualifiedName)); //$NON-NLS-1$
					return true;
				}
			}
		}
		return false;
	}
	int sLength = simpleNames.length;
	int qLength = qualifiedNames.length;
	if (sLength <= qLength) {
		for (int i = 0; i < sLengthi++) {
			if (includes(simpleNames[i])) {
				for (int j = 0; j < qLengthj++) {
					char[][] qualifiedName = qualifiedNames[j];
					if (qualifiedName.length == 1 ? includes(qualifiedName[0]) : includes(qualifiedName)) {
							..println("Found match in " + CharOperation.toString(qualifiedName//$NON-NLS-1$
" to " + new String(simpleNames[i])); //$NON-NLS-1$
						return true;
					}
				}
				return false;
			}
		}
else {
		for (int i = 0; i < qLengthi++) {
			char[][] qualifiedName = qualifiedNames[i];
			if (qualifiedName.length == 1 ? includes(qualifiedName[0]) : includes(qualifiedName)) {
				for (int j = 0; j < sLengthj++) {
					if (includes(simpleNames[j])) {
							..println("Found match in " + CharOperation.toString(qualifiedName//$NON-NLS-1$
" to " + new String(simpleNames[j])); //$NON-NLS-1$
						return true;
					}
				}
				return false;
			}
		}
	}
	return false;
public boolean insideRoot(char[] rootName) {
	for (int i = 0, l = this..lengthi < li++)
		if (rootName == this.[i]) return true;
	return false;
// When any type is compiled, its methods are verified for certain problems
// the MethodVerifier requests 3 well known types which end up in the reference collection
// having WellKnownQualifiedNames & WellKnownSimpleNames, saves every type 40 bytes
// NOTE: These collections are sorted by length
static final char[][][] WellKnownQualifiedNames = new char[][][] {
	new char[][] {.},
	new char[][] {new char[] {'o''r''g'}},
	new char[][] {new char[] {'c''o''m'}},
	.}; // default package
static final char[][] WellKnownSimpleNames = new char[][] {
	new char[] {'o''r''g'},
	new char[] {'c''o''m'}};
static final char[][][] EmptyQualifiedNames = new char[0][][];
static final char[][] EmptySimpleNames = .;
// each array contains qualified char[][], one for size 2, 3, 4, 5, 6, 7 & the rest
static final int MaxQualifiedNames = 7;
// each array contains simple char[], one for size 1 to 29 & the rest
static final int MaxSimpleNames = 30;
static {
	for (int i = 0; i < i++)
	for (int i = 0; i < i++)
public static char[][][] internQualifiedNames(StringSet qualifiedStrings) {
	if (qualifiedStrings == nullreturn ;
	int length = qualifiedStrings.elementSize;
	if (length == 0) return ;
	char[][][] result = new char[length][][];
	String[] strings = qualifiedStrings.values;
	for (int i = 0, l = strings.lengthi < li++)
		if (strings[i] != null)
			result[--length] = CharOperation.splitOn('/'strings[i].toCharArray());
	return internQualifiedNames(resultfalse);
public static char[][][] internQualifiedNames(char[][][] qualifiedNames) {
	return internQualifiedNames(qualifiedNamesfalse);
public static char[][][] internQualifiedNames(char[][][] qualifiedNamesboolean keepWellKnown) {
	if (qualifiedNames == nullreturn ;
	int length = qualifiedNames.length;
	if (length == 0) return ;
	char[][][] keepers = new char[length][][];
	int index = 0;
	next : for (int i = 0; i < lengthi++) {
		char[][] qualifiedName = qualifiedNames[i];
		int qLength = qualifiedName.length;
		for (int j = 0, m = .j < mj++) {
			char[][] wellKnownName = [j];
			if (qLength > wellKnownName.length)
				break// all remaining well known names are shorter
			if (CharOperation.equals(qualifiedNamewellKnownName)) {
				if (keepWellKnown) {
					keepers[index++] = wellKnownName;
				}
				continue next;
			}
		}
		// InternedQualifiedNames[0] is for the rest (> 7 & 1)
		// InternedQualifiedNames[1] is for size 2...
		// InternedQualifiedNames[6] is for size 7
		QualifiedNameSet internedNames = [qLength <=  ? qLength - 1 : 0];
		qualifiedName = internSimpleNames(qualifiedNamefalse);
		keepers[index++] = internedNames.add(qualifiedName);
	}
	if (length > index) {
		if (index == 0) return ;
		System.arraycopy(keepers, 0, keepers = new char[index][][], 0, index);
	}
	return keepers;

Deprecated:
public static char[][] internSimpleNames(StringSet simpleStrings) {
	return internSimpleNames(simpleStringstrue);
public static char[][] internSimpleNames(StringSet simpleStringsboolean removeWellKnown) {
	if (simpleStrings == nullreturn ;
	int length = simpleStrings.elementSize;
	if (length == 0) return ;
	char[][] result = new char[length][];
	String[] strings = simpleStrings.values;
	for (int i = 0, l = strings.lengthi < li++)
		if (strings[i] != null)
			result[--length] = strings[i].toCharArray();
	return internSimpleNames(resultremoveWellKnown);
public static char[][] internSimpleNames(char[][] simpleNamesboolean removeWellKnown) {
	if (simpleNames == nullreturn ;
	int length = simpleNames.length;
	if (length == 0) return ;
	char[][] keepers = new char[length][];
	int index = 0;
	next : for (int i = 0; i < lengthi++) {
		char[] name = simpleNames[i];
		int sLength = name.length;
		for (int j = 0, m = .j < mj++) {
			char[] wellKnownName = [j];
			if (sLength > wellKnownName.length)
				break// all remaining well known names are shorter
			if (CharOperation.equals(namewellKnownName)) {
				if (!removeWellKnown)
					keepers[index++] = [j];
				continue next;
			}
		}
		// InternedSimpleNames[0] is for the rest (> 29)
		// InternedSimpleNames[1] is for size 1...
		// InternedSimpleNames[29] is for size 29
		NameSet internedNames = [sLength <  ? sLength : 0];
		keepers[index++] = internedNames.add(name);
	}
	if (length > index) {
		if (index == 0) return ;
		System.arraycopy(keepers, 0, keepers = new char[index][], 0, index);
	}
	return keepers;
New to GrepCode? Check out our FAQ X