issue_id int64 2.04k 425k | title stringlengths 9 251 | body stringlengths 4 32.8k ⌀ | status stringclasses 6
values | after_fix_sha stringlengths 7 7 | project_name stringclasses 6
values | repo_url stringclasses 6
values | repo_name stringclasses 6
values | language stringclasses 1
value | issue_url null | before_fix_sha null | pull_url null | commit_datetime timestamp[us, tz=UTC] | report_datetime timestamp[us, tz=UTC] | updated_file stringlengths 23 187 | chunk_content stringlengths 1 22k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | * @return the woven bytes
* @exception IOException weave failed
*/
public byte[] weaveClass(String name, byte[] bytes, boolean mustWeave) throws IOException {
if (trace == null) {
System.err
.println("AspectJ Weaver cannot continue to weave, static state has been cleared. Are you under Tomcat? In or... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | name = name.replace('/', '.');
if (couldWeave(name, bytes)) {
if (accept(name, bytes)) {
CachedClassReference cacheKey = null;
byte[] original_bytes = bytes;
if (cache != null && !mustWeave) {
cacheKey = cache.createCacheKey(name, bytes);
CachedClassEntry entry = cache.ge... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | if (cacheKey != null) {
if (Arrays.equals(original_bytes, bytes)) {
cache.ignore(cacheKey);
} else {
cache.put(cacheKey, bytes);
}
}
} else if (debugOn) {
debug("not weaving '" + name + "'");
}
} else if (debugOn) {
debug("cannot weave ... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | } finally {
delegateForCurrentClass = null;
}
if (trace.isTraceEnabled()) {
trace.exit("weaveClass", bytes);
}
return bytes;
} finally {
weaverRunning.set(false);
}
}
/**
* @param name
* @return true if even valid to weave: either with an accept check or to munge it for @AspectJ aspecto... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | Properties p = weaver.getWorld().getExtraConfiguration();
if (p != null) {
boolean b = p.getProperty(World.xsetWEAVE_JAVA_PACKAGES, "false").equalsIgnoreCase("true");
if (b) {
weavingSpecialTypes |= WEAVE_JAVA_PACKAGE;
}
b = p.getProperty(World.xsetWEAVE_JAVAX_PACKAGES, "false").equalsIgno... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | if ((weavingSpecialTypes & WEAVE_JAVA_PACKAGE) != 0) {
return true;
} else {
return false;
}
}
}
return true;
}
/**
* We allow @AJ aspect weaving so that we can add aspectOf() as part of the weaving (and not part of the source compilation)
*
* @param name
* @param byte... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | protected void ensureDelegateInitialized(String name, byte[] bytes) {
if (delegateForCurrentClass == null) {
BcelWorld world = (BcelWorld) weaver.getWorld();
delegateForCurrentClass = world.addSourceObjectType(name, bytes, false);
}
}
/**
* Weave a set of bytes defining a class.
*
* @param name the n... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | weaver.weave(wcp);
return wcp.getBytes();
}
/**
* Weave a set of bytes defining a class for only what is needed to turn @AspectJ aspect in a usefull form ie with aspectOf
* method - see #113587
*
* @param name the name of the class being woven
* @param bytes the bytes that define the class
* @return by... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | *
* @param aspectLibraryJarFile a jar file representing an aspect library
*
* @throws IOException
*/
private void addAspectLibrary(String aspectLibraryName) {
File aspectLibrary = new File(aspectLibraryName);
if (aspectLibrary.isDirectory() || (FileUtil.isZipFile(aspectLibrary))) {
try {
info("add... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | }
protected boolean info(String message) {
return MessageUtil.info(messageHandler, message);
}
protected boolean warn(String message) {
return MessageUtil.warn(messageHandler, message);
}
protected boolean warn(String message, Throwable th) {
return messageHandler.handleMessage(new Message(message, IMessage.... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | dirName = dirName + File.separator + "_before";
}
String className = name.replace('.', '/');
final File dir;
if (className.indexOf('/') > 0) {
dir = new File(dirName + File.separator + className.substring(0, className.lastIndexOf('/')));
} else {
dir = new File(dirName);
}
dir.mkdirs();
String fil... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | private IMessageHandler delegate;
private List<IMessage> savedMessages;
protected boolean traceMessages = Boolean.getBoolean(TRACE_MESSAGES_PROPERTY);
public WeavingAdaptorMessageHolder(PrintWriter writer) {
this.delegate = new WeavingAdaptorMessageWriter(writer);
super.dontIgnore(IMessage.WEAVEINFO);
}
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | if (message instanceof WeaveMessage) {
trace.debug(render(message));
} else if (message.isDebug()) {
trace.debug(render(message));
} else if (message.isInfo()) {
trace.info(render(message));
} else if (message.isWarning()) {
trace.warn(render(message), message.getThrown());
} else if (messag... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | }
public void setDelegate(IMessageHandler messageHandler) {
delegate = messageHandler;
}
/*
* IMessageHandler
*/
@Override
public boolean handleMessage(IMessage message) throws AbortException {
if (traceMessages) {
traceMessage(message);
}
super.handleMessage(message);
if (abortOnErro... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | }
@Override
public boolean isIgnoring(Kind kind) {
return delegate.isIgnoring(kind);
}
@Override
public void dontIgnore(IMessage.Kind kind) {
if (null != kind && delegate != null) {
delegate.dontIgnore(kind);
}
}
@Override
public void ignore(Kind kind) {
if (null != kind && delegate != n... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | private final Set<IMessage.Kind> ignoring = new HashSet<IMessage.Kind>();
private final IMessage.Kind failKind;
public WeavingAdaptorMessageWriter(PrintWriter writer) {
super(writer, true);
ignore(IMessage.WEAVEINFO);
ignore(IMessage.DEBUG);
ignore(IMessage.INFO);
this.failKind = IMessage.ERROR;
}
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | */
@Override
public void ignore(IMessage.Kind kind) {
if ((null != kind) && (!ignoring.contains(kind))) {
ignoring.add(kind);
}
}
/**
* Remove a message kind from the list of those ignored from now on.
*/
@Override
public void dontIgnore(IMessage.Kind kind) {
if (null != kind) {
ignor... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | if (shouldDump(name.replace('/', '.'), true)) {
dump(name, bytes, true);
}
}
public void setApplyAtAspectJMungersOnly() {
isApplyAtAspectJMungersOnly = true;
}
public boolean isApplyAtAspectJMungersOnly() {
return isApplyAtAspectJMungersOnly;
}
public byte[] getBytes() {
if (wovenClass != nu... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/WeavingAdaptor.java | String className = result.getClassName();
generatedClasses.put(className, result);
generatedClasses.put(wovenClass.getClassName(), result);
generatedClassHandler.acceptClass(className, result.getBytes());
}
}
public void processingReweavableState() {
}
public void addingTypeMunger... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CacheBacking.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CacheBacking.java | *
* @param regex
* @return
*/
public String[] getKeys(String regex);
/**
* Remove an entry from the cache
*
* @param ref
*/
public void remove(CachedClassReference ref);
/**
* Clear the entire cache
*/
public void clear();
/**
* Get a cache entry
*
* @param ref entry to retrieve
* @retur... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CacheStatistics.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CacheStatistics.java | misses++;
}
public void weaved() {
weaved++;
}
public void generated() {
generated++;
}
public void ignored() {
ignored++;
}
public void put() {
puts++;
}
public void putIgnored() {
puts_ignored++;
}
public int getHits() {
return hits;
}
public int getMisses() {
return misses;
}
public int... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CacheStatistics.java | return ignored;
}
public int getPuts() {
return puts;
}
public int getPutsIgnored() {
return puts_ignored;
}
public void reset() {
hits = 0;
misses = 0;
weaved = 0;
generated = 0;
ignored = 0;
puts = 0;
puts_ignored = 0;
}
public String toString() {
return "CacheStatistics{" +
"hits=" + ... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CachedClassEntry.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CachedClassEntry.java | IGNORED,
}
private final CachedClassReference ref;
private final byte[] bytes;
private final EntryType type;
public CachedClassEntry(CachedClassReference ref, byte[] bytes, EntryType type) {
this.bytes = bytes;
this.ref = ref;
this.type = type;
}
public String getClassName() {
return ref.getClassName();
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CachedClassReference.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/CachedClassReference.java | enum EntryType {
GENERATED,
WEAVED,
IGNORED,
}
private final String key;
private final String className;
protected CachedClassReference(String key, CacheKeyResolver resolver) {
this.key = key;
this.className = resolver.keyToClass(key);
}
/**
* Protected to allow only the WeavedClassCache initializatio... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultCacheFactory.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultCacheKeyResolver.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultCacheKeyResolver.java | import java.net.URLClassLoader;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.Collections;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.zip.CRC32;
/**
* Naive default class and classloader hashing implementation us... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultCacheKeyResolver.java | * @param aspects the aspects
* @return a unique string for URLClassloaders, otherwise a non-unique classname
*/
public String createClassLoaderScope(ClassLoader cl, List<String> aspects) {
String name = cl != null ? cl.getClass().getSimpleName() : "unknown";
List<String> hashableStrings = new LinkedList<String... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultCacheKeyResolver.java | public String getGeneratedRegex() {
return ".*" + GENERATED_SUFFIX;
}
public String getWeavedRegex() {
return ".*" + WEAVED_SUFFIX;
}
/**
* Converts a cache key back to a className
*
* @param key to convert
* @return className, e.g. "com.foo.Bar"
*/
public String keyToClass(String key) {
if (key.en... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | import org.aspectj.bridge.MessageUtil;
import org.aspectj.util.FileUtil;
import java.io.*;
import java.util.HashMap;
import java.util.zip.CRC32;
/**
* Naive File-Backed Class Cache with no expiry or application
* centric invalidation.
* <p/>
* Enabled with the system property, "aj.weaving.cache.dir"
* If this syst... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | public long crc;
}
private final File cacheDirectory;
private final CacheKeyResolver resolver;
private final HashMap<String, IndexEntry> index = new HashMap<String, IndexEntry>();
private static final Object LOCK = new Object();
protected DefaultFileCacheBacking(File cacheDirectory, CacheKeyResolver resolver) {
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | return iea;
}
fis = new FileInputStream(indexFile);
ois = new ObjectInputStream(fis);
iea = (IndexEntry[]) ois.readObject();
} catch (Exception e) {
delete(indexFile);
} finally {
close(fis, indexFile);
close(ois, indexFile);
}
return iea;
}
private void readIndex() {
synchronized (LOCK... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | ObjectOutputStream oos = null;
try {
delete(indexFile);
fos = new FileOutputStream(indexFile);
oos = new ObjectOutputStream(fos);
oos.writeObject(index.values().toArray(new IndexEntry[0]));
} catch (Exception e) {
throw new RuntimeException(e);
} finally {
close(fos, indexFile);
clo... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | }
public static CacheBacking createBacking(String scope, CacheKeyResolver resolver) {
String cache = System.getProperty(WEAVED_CLASS_CACHE_DIR);
if (cache == null) {
return null;
}
File cacheDir = new File(cache, scope);
return createBacking(cacheDir, resolver);
}
public String[] getKeys(final String re... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | return new CachedClassEntry(ref, WeavedClassCache.ZERO_BYTES, CachedClassEntry.EntryType.IGNORED);
}
File cacheFile = new File(cacheDirectory, ref.getKey());
if (cacheFile.canRead()) {
if (ie == null) {
delete(cacheFile);
return null;
}
byte[] bytes = read(cacheFile, ie.crc);
if (bytes !=... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | addIndexEntry(ie);
}
}
public void remove(CachedClassReference ref) {
synchronized (LOCK) {
File cacheFile = new File(cacheDirectory, ref.getKey());
removeIndexEntry(ref.getKey());
delete(cacheFile);
}
}
protected byte[] read(File file, long expectedCRC) {
CRC32 checksum = new CRC32();
synchroniz... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | delete(file);
}
return null;
}
protected long write(File file, byte[] bytes) {
if (file.exists()) {
return -1;
}
synchronized (LOCK) {
if (file.exists()) {
return -1;
}
OutputStream out = null;
ObjectOutputStream crcOut = null;
CRC32 checksum = new CRC32();
try {
out = new FileO... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/DefaultFileCacheBacking.java | }
return -1;
}
protected static void delete(File file) {
if (file.exists()) {
file.delete();
}
}
protected static void close(OutputStream out, File file) {
if (out != null) {
try {
out.close();
} catch (IOException e) {
MessageUtil.error("Error closing write file " + file.getName());
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/GeneratedCachedClassHandler.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/GeneratedCachedClassHandler.java | private final WeavedClassCache cache;
private final GeneratedClassHandler nextGeneratedClassHandler;
public GeneratedCachedClassHandler(WeavedClassCache cache, GeneratedClassHandler nextHandler) {
this.cache = cache;
this.nextGeneratedClassHandler = nextHandler;
}
public void acceptClass(String name, byte[] byt... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | * "-Daj.weaving.cache.dir=/some/directory"
* </pre>
* <p/>
* The class cache is often something that application developers or
* containers would like to manage, so there are a few interfaces for overriding the
* default behavior and performing other management functions.
* <p/>
* {@link CacheBacking} <br/>
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | * be reconstruct the class incorrectly.
* 3. Similarly to (2), the addition of fields or methods on classes which have
* already been weaved and cached could have inter-type conflicts.
* </pre>
*/
public class WeavedClassCache {
public static final String WEAVED_CLASS_CACHE_ENABLED = "aj.weaving.cac... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | cacheRegistry.add(this);
}
}
/**
* Creates a new cache using the resolver and backing returned by the DefaultCacheFactory.
*
* @param loader classloader for this cache
* @param aspects list of aspects used by the WeavingAdapter
* @param existingClassHandler the existing GeneratedClassHandler used... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | * be set with this method. Since each weaver will create a cache, this method must be
* called before the weaver is first initialized.
*
* @param factory
*/
public static void setDefaultCacheFactory(CacheFactory factory) {
DEFAULT_FACTORY = factory;
}
/**
* Created a key for a generated class
*
* @pa... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | * to the cache
*/
public GeneratedClassHandler getCachingClassHandler() {
return cachingClassHandler;
}
/**
* Has caching been enabled through the System property,
* WEAVED_CLASS_CACHE_ENABLED
*
* @return true if caching is enabled
*/
public static boolean isEnabled() {
return System.getProperty(WEA... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | *
* @param ref reference to the cache entry, created through createCacheKey
* @return the CacheEntry, or null if no entry exists in the cache
*/
public CachedClassEntry get(CachedClassReference ref) {
CachedClassEntry entry = backing.get(ref);
if (entry == null) {
stats.miss();
} else {
stats.hit();
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | */
public void remove(CachedClassReference ref) {
backing.remove(ref);
}
/**
* Clear the entire cache
*/
public void clear() {
backing.clear();
}
/**
* Get the statistics associated with this cache, or
* null if statistics have not been enabled.
*
* @return
*/
public CacheStatistics getStats() ... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | * Get all generated classes which have been cached
*
* @return
*/
protected CachedClassEntry[] getGeneratedClasses() {
return getEntries(resolver.getGeneratedRegex());
}
/**
* Get all weaved classes which have been cached
*
* @return
*/
protected CachedClassEntry[] getWeavedClasses() {
return getE... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/src/org/aspectj/weaver/tools/cache/WeavedClassCache.java | /**
* Gets an array of CacheClassEntries with the given regex
*
* @param regex filter
* @return array of entries
*/
protected CachedClassEntry[] getEntries(String regex) {
String[] keys = backing.getKeys(regex);
List<CachedClassEntry> entries = new LinkedList<CachedClassEntry>();
for (int i = 0; i < ke... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/DefaultFileCacheBackingTest.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/DefaultFileCacheBackingTest.java | }
public void tearDown() throws Exception {
FileUtil.deleteContents(root);
root = null;
}
public void testCreateBacking() throws Exception {
CacheBacking backing = DefaultFileCacheBacking.createBacking(root, resolver);
assertNotNull(backing);
assertTrue(root.exists());
assertTrue(root.isDirectory());
}
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/DefaultFileCacheBackingTest.java | assertEquals("orange", matches[0]);
}
public void testPut() throws Exception {
CacheBacking backing = DefaultFileCacheBacking.createBacking(root, resolver);
backing.put(new CachedClassEntry(fakeRef, FAKE_BYTES, CachedClassEntry.EntryType.WEAVED));
File cachedFile = new File(root, fakeRef.getKey());
assertTrue... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/DefaultFileCacheBackingTest.java | backing.put(new CachedClassEntry(fakeRef, FAKE_BYTES, CachedClassEntry.EntryType.WEAVED));
File cachedFile = new File(root, fakeRef.getKey());
assertTrue(cachedFile.isFile());
assertEquals(FAKE_BYTES.length, cachedFile.length());
CRC32 expectedCRC = new CRC32();
expectedCRC.update(FAKE_BYTES);
assertTrue(in... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/DefaultFileCacheBackingTest.java | CacheBacking backing = DefaultFileCacheBacking.createBacking(root, resolver);
CachedClassReference wref = resolver.weavedKey(FAKE_CLASS + "WEAVED", FAKE_BYTES);
entry = new CachedClassEntry(wref, FAKE_BYTES, CachedClassEntry.EntryType.WEAVED);
backing.put(entry);
cachedFile = new File(root, wref.getKey());
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/WeavedClassCacheTest.java | /*******************************************************************************
* Copyright (c) 2012 Contributors.
* 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
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/WeavedClassCacheTest.java | String FAKE_CLASS = "com.example.foo.Bar";
byte[] FAKE_BYTES = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
public class MemoryCacheBacking implements CacheBacking {
HashMap<String, CachedClassEntry> cache = new HashMap<String, CachedClassEntry>();
public String[] getKeys(String regex) {
Set<String> keys = cache.keySet();
... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/WeavedClassCacheTest.java | }
public CachedClassEntry get(CachedClassReference ref) {
return cache.get(ref.getKey());
}
public void put(CachedClassEntry entry) {
cache.put(entry.getKey(), entry);
}
}
MemoryCacheBacking memoryBacking = new MemoryCacheBacking();
IMessageHandler messageHandler = new IMessageHandler() {
public bool... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/WeavedClassCacheTest.java | CacheKeyResolver resolver = new DefaultCacheKeyResolver();
private WeavedClassCache createCache() throws Exception {
return new WeavedClassCache(generatedClassHandler, messageHandler, "test", memoryBacking, resolver);
}
private void reset() throws Exception {
memoryBacking.cache.clear();
generatedClassHandler.... |
389,967 | Bug 389967 Weaved aspects mechanism does not take into account modified classes | The current caching mechanism assumes that if the same class is encountered then its cached weaved version can be used. However, the mechanism uses only the (fully qualified) class name to identify the class and does not take into account the fact that the class bytes may have changed (e.g., the user re-compiled and re... | resolved fixed | 9a3cc2b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-01T20:22:37Z | 2012-09-20T05:46:40Z | weaver/testsrc/org/aspectj/weaver/tools/cache/WeavedClassCacheTest.java | CacheStatistics stats = cache.getStats();
CachedClassReference ref = cache.createCacheKey(FAKE_CLASS, FAKE_BYTES);
assertNull(cache.get(ref));
cache.put(ref, FAKE_BYTES);
assertNotNull(cache.get(ref));
assertEquals(new String(FAKE_BYTES), new String(cache.get(ref).getBytes()));
assertEquals(1, cache.getWeav... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | /* *******************************************************************
* Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).
* All rights reserved.
* This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0 |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | * which accompanies this distribution and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Xerox/PARC initial implementation
* ******************************************************************/
package org.aspectj.internal.tools.ant.taskdefs;
import java.io.BufferedRea... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | /*
* This does not enforce that copyrights are correct/current, only that they exist. E.g., the default behavior requires MPL but
* permits either Xerox or PARC copyright holders and any valid year.
*/
public static final String MPL_TAG = "mpl";
public static final String APACHE_TAG = "apache";
public static f... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | final String LIC_CPL = "Eclipse Public License";
final String LIC_ECPL = " Public License";
License APL = new License(APACHE_TAG, LIC_APL, APACHE);
License MPL = new License(MPL_TAG, LIC_MPL, XEROX);
License MPL_XEROX_PARC = new License(DEFAULT, LIC_MPL, XEROX, PARC);
License CPL_IBM_PARC = new License(CPL_IB... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | switch (args.length) {
case 1:
runDirect(args[0], null, false);
break;
case 2:
runDirect(args[0], args[1], false);
break;
default:
String options = "{replace-headers|get-years|list|{licenseTag}}";
System.err.println("java {me} sourcepath " + options);
break;
}
}
/**
* Run the license ch... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | me.setProject(p);
me.setFailOnError(failonerror);
me.setSourcepath(new Path(p, sourcepath));
if (null != license) {
if ("replace-headers".equals(license)) {
me.setReplaceheaders(true);
} else if ("get-years".equals(license)) {
me.setGetYears(true);
} else if ("list".equals(license)) {
me.setL... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | }
public void setPrintDirectories(boolean print) {
printDirectories = print;
}
/**
* When failOnError is true, if any file failed, throw BuildException listing number of files that file failed to pass license
* check
*
* @param fail if true, report errors by throwing BuildException
*/
public void setFa... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | }
public void setSourcepathRef(Reference id) {
createSourcepath().setRefid(id);
}
public void setOutputStream(String out) {
this.streamTag = out;
}
public void setReplaceheaders(boolean replaceHeaders) {
this.replaceHeaders = replaceHeaders;
}
public void setGetYears(boolean getYears) {
this.getYears =... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | void visit(File file);
}
private void visitAll(FileVisitor visitor) {
String[] dirs = sourcepath.list();
for (int i = 0; i < dirs.length; i++) {
File dir = project.resolveFile(dirs[i]);
String[] files = getDirectoryScanner(dir).getIncludedFiles();
for (int j = 0; j < files.length; j++) {
File fi... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | public void visit(File file) {
HeaderInfo info = Header.checkFile(file);
if (!Header.replaceHeader(file, info)) {
throw new BuildException("failed to replace header for " + file + " using " + info);
}
}
}
visitAll(new YearVisitor());
}
private void getYears() {
final PrintStream out = getOut... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | int failed = 0;
int passed = 0;
public void visit(File file) {
if (license.checkFile(file)) {
passed++;
} else {
failed++;
String path = file.getPath();
if (!license.foundLicense()) {
out.println(license.tag + " LICENSE FAIL: " + path);
}
if (!license.foundCopyright()... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | if (failOnError) {
throw new BuildException(failed + " files failed license check");
}
}
}
private void list() {
Iterator enu = LICENSES.keySet().iterator();
StringBuffer sb = new StringBuffer();
sb.append("known license keys:");
boolean first = true;
while (enu.hasNext()) {
sb.append((first ? "... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | private boolean gotCopyright;
License(String tag, String license) {
this(tag, license, (String[]) null);
}
License(String tag, String license, String copyright) {
this(tag, license, new String[] { copyright });
}
License(String tag, String license, String copyright, String altCopyright) {
this(tag, l... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | clear();
BufferedReader input = null;
int lineNum = 0;
try {
input = new BufferedReader(new FileReader(file));
String line;
while (!gotValidFile() && (line = input.readLine()) != null) {
lineNum++;
checkLine(line);
}
} catch (IOException e) {
System.err.println("reading lin... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | }
if (!gotLicense && (null != license) && (-1 != line.indexOf(license))) {
gotLicense = true;
}
if (!gotCopyright && (null != copyright)) {
int loc;
for (int j = 0; !gotCopyright && (j < YEARS.length); j++) {
if (-1 != (loc = line.indexOf(YEARS[j]))) {
loc += YEARS[j].length();
Str... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | public final File file;
public final List years;
public final int lastLine;
public final boolean hasLicense;
public HeaderInfo(File file, int lastLine, List years, boolean hasLicense) {
this.lastLine = lastLine;
this.file = file;
this.hasLicense = hasLicense;
List newYears = new ArrayList();
newYear... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | throw new IllegalArgumentException("no years: " + this);
}
if ((20 > lastLine) || (65 < lastLine)) {
throw new IllegalArgumentException("bad last line: " + this);
}
}
}
public String toString() {
return file.getPath() + ":" + lastLine + " " + years;
}
public void writeHeader(PrintWriter writer) {
... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | }
String xyears = first + "-" + xlast;
if (first.equals(last)) {
xyears = first;
}
writer.println(TOP);
if (!lastIs2002) {
writer.println(XEROX_PREFIX + xyears + XEROX_SUFFIX + ". ");
} else if (size == 1) {
writer.println(PARC_ONLY);
} else {
writer.println(XEROX_PREFIX + xyears... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | public static final String PARC = " * 2002 Palo Alto Research Center, Incorporated (PARC).";
public static final String PARC_ONLY = " * Copyright (c) 2002 Palo Alto Research Center, Incorporated (PARC).";
public static final String XEROX_PREFIX = " * Copyright (c) ";
public static final String XEROX_SU... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | throw new Error("unable to rename " + file + " to " + inFile);
}
outWriter = new FileWriter(outFile);
input = new BufferedReader(new FileReader(inFile));
output = new PrintWriter(outWriter, true);
info.writeHeader(output);
String line;
while (null != (line = input.readLine())) {
lineNum++;
... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | }
}
result = inFile.delete();
}
return result;
}
public static HeaderInfo checkFile(final File file) {
ArrayList years = new ArrayList();
int endLine = 0;
BufferedReader input = null;
int lineNum = 0;
try {
input = new BufferedReader(new FileReader(file));
String line;
while (null != (lin... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | build/src/org/aspectj/internal/tools/ant/taskdefs/Checklics.java | try {
input.close();
} catch (IOException e) {
}
}
}
return new HeaderInfo(file, endLine, years, endLine > 0);
}
/**
* Add any years found (as String) to years, and return true at the first end-of-comment
*
* @return true if this line has end-of-comment
*/
private static boolean checkLi... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | /* *******************************************************************
* Copyright (c) 1999-2001 Xerox Corporation,
* 2002 Palo Alto Research Center, Incorporated (PARC).
* All rights reserved.
* This program and the accompanying materials are made available |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | * 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:
* Xerox/PARC initial implementation
* ******************************************************************/
package org.aspectj.ut... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | public static final String EOL;
private static double vmVersion;
static {
StringWriter buf = new StringWriter();
PrintWriter writer = new PrintWriter(buf);
writer.println("");
String eol = "\n";
try {
buf.close();
StringBuffer sb = buf.getBuffer();
if (sb != null) {
eol = buf.toString();
}
... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | if (vm == null) {
new RuntimeException(
"System properties appear damaged, cannot find: java.version/java.runtime.version/java.vm.version")
.printStackTrace(System.err);
vmVersion = 1.5;
} else {
try {
String versionString = vm.substring(0, 3);
Double temp = new Double(Double.parseD... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | public static boolean is16VMOrGreater() {
return 1.6 <= vmVersion;
}
public static boolean is17VMOrGreater() {
return 1.7 <= vmVersion;
}
/**
* Shorthand for "if null, throw IllegalArgumentException"
*
* @throws IllegalArgumentException "null {name}" if o is null
*/
public static final void throwIaxIf... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | } else if (null != c) {
Class<?> actualClass = ra[i].getClass();
if (!c.isAssignableFrom(actualClass)) {
String message = label + " not assignable to " + c.getName();
throw new IllegalArgumentException(message);
}
}
}
}
/**
* Shorthand for "if not null or not assignable, throw IllegalArgu... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | }
}
}
/**
* Shorthand for "if false, throw IllegalArgumentException"
*
* @throws IllegalArgumentException "{message}" if test is false
*/
public static final void throwIaxIfFalse(final boolean test, final String message) {
if (!test) {
throw new IllegalArgumentException(message);
}
}
}
... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | public static boolean isEmpty(Object[] ra) {
return ((null == ra) || (0 == ra.length));
}
public static boolean isEmpty(Collection<?> collection) {
return ((null == collection) || (0 == collection.size()));
}
public static boolean isEmpty(Map<?,?> map) {
return ((null == map) || (0 == map.size()));
}
/*... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | *
* @param classpath the String to split - may be null or empty
* @return String[] of classpath entries
*/
public static String[] splitClasspath(String classpath) {
if (LangUtil.isEmpty(classpath)) {
return new String[0];
}
StringTokenizer st = new StringTokenizer(classpath, File.pathSeparator);
Arra... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | } catch (Throwable t) {
}
}
return defaultValue;
}
/**
* Splits <code>input</code>, removing delimiter and trimming any white space. Returns an empty collection if the input is null.
* If delimiter is null or empty or if the input contains no delimiters, the input itself is returned after trimming whi... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | /**
* Splits strings into a <code>List</code> using a <code>StringTokenizer</code>.
*
* @param text <code>String</code> to split.
*/
public static List<String> strings(String text) {
if (LangUtil.isEmpty(text)) {
return Collections.emptyList();
}
List<String> strings = new ArrayList<String>();
Stri... |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
}
}
break;
}
}
} |
391,123 | Bug 391123 Added support for more cache backing(s) | null | closed fixed | df1823b | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-10-29T19:46:03Z | 2012-10-04T14:13:20Z | util/src/org/aspectj/util/LangUtil.java | }
/**
*/
}
}
}
}
}
/**
* copy non-null two-dimensional String[][]
*
* @see extractOptions(String[], String[][]) |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.