if (!memoryProfiling) {
return;
}
- Reference r = null;
+ Reference<? extends ResolvedType> r = null;
while ((r=rq.poll()) != null) {
collectedTypes++;
}
import org.aspectj.weaver.AjAttribute.WeaverVersionInfo;
import org.aspectj.weaver.AnnotationAJ;
import org.aspectj.weaver.AnnotationTargetKind;
+import org.aspectj.weaver.ConcreteTypeMunger;
import org.aspectj.weaver.ISourceContext;
import org.aspectj.weaver.ReferenceType;
import org.aspectj.weaver.ReferenceTypeDelegate;
import org.aspectj.weaver.WeakClassLoaderReference;
import org.aspectj.weaver.WeaverStateInfo;
import org.aspectj.weaver.World;
+import org.aspectj.weaver.patterns.Declare;
import org.aspectj.weaver.patterns.PerClause;
/**
public ReflectionBasedReferenceTypeDelegate() {
}
- public void initialize(ReferenceType aType, Class aClass, ClassLoader aClassLoader, World aWorld) {
+ public void initialize(ReferenceType aType, Class<?> aClass, ClassLoader aClassLoader, World aWorld) {
this.myClass = aClass;
this.resolvedType = aType;
this.world = aWorld;
return null;
}
- /*
- * (non-Javadoc)
- *
- * @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclares()
- */
- public Collection getDeclares() {
- // no declares
- return Collections.EMPTY_SET;
+ public Collection<Declare> getDeclares() {
+ return Collections.emptySet();
}
- /*
- * @see org.aspectj.weaver.ReferenceTypeDelegate#getTypeMungers()
- */
- public Collection getTypeMungers() {
- // no type mungers
- return Collections.EMPTY_SET;
+ public Collection<ConcreteTypeMunger> getTypeMungers() {
+ return Collections.emptySet();
}
/*
return null;
}
- /*
- * (non-Javadoc)
- *
- * @see org.aspectj.weaver.ReferenceTypeDelegate#getResolvedTypeX()
- */
public ReferenceType getResolvedTypeX() {
return this.resolvedType;
}
- /*
- * (non-Javadoc)
- *
- * @see org.aspectj.weaver.ReferenceTypeDelegate#doesNotExposeShadowMungers()
- */
public boolean doesNotExposeShadowMungers() {
return false;
}
- /*
- * (non-Javadoc)
- *
- * @see org.aspectj.weaver.ReferenceTypeDelegate#getDeclaredGenericSignature()
- */
public String getDeclaredGenericSignature() {
// no generic sig in 1.4
return null;
}
}
- protected String formatArray (Object obj) {
+ protected String formatArray(Object obj) {
return obj.getClass().getComponentType().getName() + "[" + Array.getLength(obj) + "]";
}
- protected String formatCollection (Collection c) {
+ protected String formatCollection(Collection<?> c) {
return c.getClass().getName() + "(" + c.size() + ")";
}
* @param array the Object[] to convert (may be null)
* @return the List corresponding to array (never null)
*/
- public static List<Object> arrayAsList(Object[] array) {
+ public static <T> List<T> arrayAsList(T[] array) {
if ((null == array) || (1 > array.length)) {
return Collections.emptyList();
}
- ArrayList<Object> list = new ArrayList<Object>();
+ ArrayList<T> list = new ArrayList<>();
list.addAll(Arrays.asList(array));
return list;
}
public int fallbackCompareTo(Object other);
}
- private static class SortObject {
- PartialComparable object;
- List<SortObject> smallerObjects = new LinkedList<SortObject>();
- List<SortObject> biggerObjects = new LinkedList<SortObject>();
+ private static class SortObject<T extends PartialComparable> {
+ T object;
+ List<SortObject<T>> smallerObjects = new LinkedList<SortObject<T>>();
+ List<SortObject<T>> biggerObjects = new LinkedList<SortObject<T>>();
- public SortObject(PartialComparable o) {
+ public SortObject(T o) {
object = o;
}
return smallerObjects.size() == 0;
}
- boolean removeSmallerObject(SortObject o) {
+ boolean removeSmallerObject(SortObject<T> o) {
smallerObjects.remove(o);
return hasNoSmallerObjects();
}
- void addDirectedLinks(SortObject other) {
+ void addDirectedLinks(SortObject<T> other) {
int cmp = object.compareTo(other.object);
if (cmp == 0) {
return;
}
}
- private static void addNewPartialComparable(List<SortObject> graph, PartialComparable o) {
- SortObject so = new SortObject(o);
- for (Iterator<SortObject> i = graph.iterator(); i.hasNext();) {
- SortObject other = i.next();
+ private static <T extends PartialComparable> void addNewPartialComparable(List<SortObject<T>> graph, T o) {
+ SortObject<T> so = new SortObject<T>(o);
+ for (Iterator<SortObject<T>> i = graph.iterator(); i.hasNext();) {
+ SortObject<T> other = i.next();
so.addDirectedLinks(other);
}
graph.add(so);
}
- private static void removeFromGraph(List<SortObject> graph, SortObject o) {
- for (Iterator<SortObject> i = graph.iterator(); i.hasNext();) {
- SortObject other = i.next();
+ private static <T extends PartialComparable> void removeFromGraph(List<SortObject<T>> graph, SortObject<T> o) {
+ for (Iterator<SortObject<T>> i = graph.iterator(); i.hasNext();) {
+ SortObject<T> other = i.next();
if (o == other) {
i.remove();
* @returns the same members as objects, but sorted according to their partial order. returns null if the objects are cyclical
*
*/
- public static List sort(List objects) {
+ public static <T extends PartialComparable> List<T> sort(List<T> objects) {
// lists of size 0 or 1 don't need any sorting
if (objects.size() < 2) {
return objects;
// ??? I don't like creating this data structure, but it does give good
// ??? separation of concerns.
- List<SortObject> sortList = new LinkedList<SortObject>(); // objects.size());
- for (Iterator i = objects.iterator(); i.hasNext();) {
- addNewPartialComparable(sortList, (PartialComparable) i.next());
+ List<SortObject<T>> sortList = new LinkedList<SortObject<T>>();
+ for (Iterator<T> i = objects.iterator(); i.hasNext();) {
+ addNewPartialComparable(sortList, i.next());
}
// System.out.println(sortList);
// System.out.println(sortList);
// System.out.println("-->" + ret);
- SortObject leastWithNoSmallers = null;
+ SortObject<T> leastWithNoSmallers = null;
- for (Iterator i = sortList.iterator(); i.hasNext();) {
- SortObject so = (SortObject) i.next();
- // System.out.println(so);
+ for (SortObject<T> so: sortList) {
if (so.hasNoSmallerObjects()) {
if (leastWithNoSmallers == null || so.object.fallbackCompareTo(leastWithNoSmallers.object) < 0) {
leastWithNoSmallers = so;
* @throws AssertionFailedError if any names are not in dir
*/
public static String[] dirContains(File dir, final String[] filenames) {
- final ArrayList sought = new ArrayList(LangUtil.arrayAsList(filenames));
+ final ArrayList<String> sought = new ArrayList<>(LangUtil.arrayAsList(filenames));
FilenameFilter filter = new FilenameFilter() {
public boolean accept(File d, String name) {
return !sought.remove(name);
* @return sorted String[] of all paths to all files under dir ending with one of the listed suffixes but not starting with "."
*/
public static String[] dirPaths(File dir, String[] suffixes) {
- ArrayList result = new ArrayList();
+ ArrayList<String> result = new ArrayList<String>();
doDirPaths(dir, result);
// if suffixes required, remove those without suffixes
if (!LangUtil.isEmpty(suffixes)) {
- for (ListIterator iter = result.listIterator(); iter.hasNext();) {
+ for (ListIterator<String> iter = result.listIterator(); iter.hasNext();) {
String path = iter.next().toString();
boolean hasSuffix = false;
for (int i = 0; !hasSuffix && (i < suffixes.length); i++) {
* @param dir the File to read - ignored if null, not a directory, or has "CVS" in its path
* @param useSuffix if true, then use dir as suffix to path
*/
- private static void doDirPaths(File dir, ArrayList paths) {
+ private static void doDirPaths(File dir, ArrayList<String> paths) {
if ((null == dir) || !dir.canRead() || (-1 != dir.getPath().indexOf("CVS"))) {
return;
}
}
/** List of File files or directories to delete when exiting */
- final ArrayList tempFiles;
+ final ArrayList<File> tempFiles;
public FileUtilTest(String s) {
super(s);
- tempFiles = new ArrayList();
+ tempFiles = new ArrayList<File>();
}
public void tearDown() {
- for (ListIterator iter = tempFiles.listIterator(); iter.hasNext();) {
+ for (ListIterator<File> iter = tempFiles.listIterator(); iter.hasNext();) {
File dir = (File) iter.next();
log("removing " + dir);
FileUtil.deleteContents(dir);
public void testCopyFiles() {
// bad input
- Class iaxClass = IllegalArgumentException.class;
+ Class<?> iaxClass = IllegalArgumentException.class;
checkCopyFiles(null, null, iaxClass, false);
}
public void testRandomFileString() {
- ArrayList results = new ArrayList();
+ ArrayList<String> results = new ArrayList<>();
for (int i = 0; i < 1000; i++) {
String s = FileUtil.randomFileString();
if (results.contains(s)) {
}
};
for (int i = 0; i < 10; i++) {
- List result = FileUtil.lineSeek("" + i, sourceList, true, errorSink);
+ List<String> result = FileUtil.lineSeek("" + i, sourceList, true, errorSink);
assertEquals(2, result.size());
assertEquals(path + ":1:" + i, result.get(0));
assertEquals(path + ":2:" + i, result.get(1));
tempFiles.add(file);
}
// now test
- final ArrayList errors = new ArrayList();
+ final ArrayList<String> errors = new ArrayList<>();
final PrintStream errorSink = new PrintStream(System.err, true) {
public void println(String error) {
errors.add(error);
}
};
- List sourceList = new ArrayList();
+ List<String> sourceList = new ArrayList<>();
sourceList.addAll(Arrays.asList(sources));
sourceList = Collections.unmodifiableList(sourceList);
for (int k = 0; k < sources.length; k++) {
- List result = FileUtil.lineSeek("" + k, sourceList, true, errorSink);
+ List<String> result = FileUtil.lineSeek("" + k, sourceList, true, errorSink);
// number k found in every other line of every file at index k
- Iterator iter = result.iterator();
+ Iterator<String> iter = result.iterator();
for (int i = 0; i < MAX; i++) { // for each file
for (int j = 1; j < (MAX + 1); j++) { // for every other line
assertTrue(iter.hasNext());
projects / aspectj.git / commitdiff