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,456 | Bug 389456 NPE in EclipseTypeMunger.mungeNewMethod() | null | resolved fixed | b8ebdc3 | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-09-20T20:38:35Z | 2012-09-12T22:46:40Z | org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java | mungeNewInnerClass(sourceType, onType, (NewMemberClassTypeMunger) munger, isExactTargetType);
} else {
throw new RuntimeException("unimplemented: " + munger.getKind());
}
return true;
}
private boolean mungeNewMethod(SourceTypeBinding sourceType, ResolvedType onType, NewMethodTypeMunger munger,
boolean is... |
389,456 | Bug 389456 NPE in EclipseTypeMunger.mungeNewMethod() | null | resolved fixed | b8ebdc3 | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-09-20T20:38:35Z | 2012-09-12T22:46:40Z | org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java | if (isAbstract) {
binding.modifiers |= ClassFileConstants.AccAbstract;
}
}
if (munger.getSignature().isVarargsMethod()) {
binding.modifiers |= ClassFileConstants.AccVarargs;
}
findOrCreateInterTypeMemberFinder(sourceType).addInterTypeMethod(binding);
return true;
}
private boolean mungeNewInnerC... |
389,456 | Bug 389456 NPE in EclipseTypeMunger.mungeNewMethod() | null | resolved fixed | b8ebdc3 | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-09-20T20:38:35Z | 2012-09-12T22:46:40Z | org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java | findOrCreateInterTypeMemberClassFinder(sourceType).addInterTypeMemberType(innerTypeBinding);
return true;
}
private void mungeNewConstructor(SourceTypeBinding sourceType, NewConstructorTypeMunger munger) {
if (shouldTreatAsPublic()) {
MethodBinding binding = world.makeMethodBinding(munger.getSignature(), munge... |
389,456 | Bug 389456 NPE in EclipseTypeMunger.mungeNewMethod() | null | resolved fixed | b8ebdc3 | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-09-20T20:38:35Z | 2012-09-12T22:46:40Z | org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java | private void mungeNewField(SourceTypeBinding sourceType, NewFieldTypeMunger munger) {
if (shouldTreatAsPublic() && !targetTypeX.isInterface()) {
FieldBinding binding = world.makeFieldBinding(munger);
findOrCreateInterTypeMemberFinder(sourceType).addInterTypeField(binding);
} else {
InterTypeFieldBindin... |
389,456 | Bug 389456 NPE in EclipseTypeMunger.mungeNewMethod() | null | resolved fixed | b8ebdc3 | AspectJ | https://github.com/eclipse/org.aspectj | eclipse/org.aspectj | java | null | null | null | 2012-09-20T20:38:35Z | 2012-09-12T22:46:40Z | org.aspectj.ajdt.core/src/org/aspectj/ajdt/internal/compiler/lookup/EclipseTypeMunger.java | private IntertypeMemberTypeFinder findOrCreateInterTypeMemberClassFinder(SourceTypeBinding sourceType) {
IntertypeMemberTypeFinder finder = (IntertypeMemberTypeFinder) sourceType.typeFinder;
if (finder == null) {
finder = new IntertypeMemberTypeFinder();
sourceType.typeFinder = finder;
finder.targetTypeBin... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | /*******************************************************************************
* Copyright (c) 2005 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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | import java.lang.reflect.Method;
import java.net.MalformedURLException;
import java.net.URL;
import java.security.ProtectionDomain;
import java.util.*;
import org.aspectj.bridge.AbortException;
import org.aspectj.bridge.Constants;
import org.aspectj.util.LangUtil;
import org.aspectj.weaver.Lint;
import org.aspectj.weav... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | private final static String AOP_XML = Constants.AOP_USER_XML + ";" + Constants.AOP_AJC_XML + ";" + Constants.AOP_OSGI_XML;
private boolean initialized;
private List m_dumpTypePattern = new ArrayList();
private boolean m_dumpBefore = false;
private boolean dumpDirPerClassloader = false;
private boolean hasExcludes ... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (trace.isTraceEnabled()) {
trace.exit("<init>");
}
}
/**
* We don't need a reference to the class loader and using it during construction can cause problems with recursion. It also
* makes sense to supply the weaving context during initialization to.
*
* @deprecated
*/
public ClassLoaderWeavingAda... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (shouldDump(name.replace('/', '.'), false)) {
dump(name, bytes, false);
}
} catch (Throwable throwable) {
throwable.printStackTrace();
}
if (activeProtectionDomain != null) {
defineClass(loaderRef.getClassLoader(), name, bytes, activeProtectionDomain);
} else {
defineClass(loaderRef.... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | return;
}
bcelWorld = new LTWWorld(classLoader, weavingContext, getMessageHandler(), null);
weaver = new BcelWeaver(bcelWorld);
success = registerDefinitions(weaver, classLoader, definitions);
if (success) {
weaver.prepareForWeave();
enable();
success = weaveAndDefineConceteAspects();
}
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | * @param definitions
* @return
*/
List<String> getAspectClassNames(List<Definition> definitions) {
List<String> aspects = new LinkedList<String>();
for (Iterator<Definition> it = definitions.iterator(); it.hasNext(); ) {
Definition def = it.next();
List<String> defAspects = def.getAspectClassNames();
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (file != null) {
info("using (-Daj5.def) " + file);
definitions.add(DocumentParser.parse((new File(file)).toURL()));
}
}
String resourcePath = System.getProperty("org.aspectj.weaver.loadtime.configuration", AOP_XML);
if (trace.isTraceEnabled()) {
trace.event("parseDefinitions", this, resou... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (trace.isTraceEnabled()) {
trace.event("parseDefinitions", this, xml);
}
if (!seenBefore.contains(xml)) {
info("using configuration " + weavingContext.getFile(xml));
definitions.add(DocumentParser.parse(xml));
seenBefore.add(xml);
} else {
debug("ignoring duplicat... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | try {
registerOptions(weaver, loader, definitions);
registerAspectExclude(weaver, loader, definitions);
registerAspectInclude(weaver, loader, definitions);
success = registerAspects(weaver, loader, definitions);
registerIncludeExclude(weaver, loader, definitions);
registerDump(weaver, loader, definiti... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | for (Definition definition : definitions) {
allOptions.append(definition.getWeaverOptions()).append(' ');
}
Options.WeaverOption weaverOption = Options.parse(allOptions.toString(), loader, getMessageHandler());
World world = weaver.getWorld();
setMessageHandler(weaverOption.messageHandler);
world.set... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | try {
Properties properties = new Properties();
properties.load(resource);
world.getLint().setFromProperties(properties);
} catch (IOException e) {
failure = e;
}
}
if (failure != null || resource == null) {
warn("Cannot access resource for -Xlintfile:" + weaverOption.lint... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | bcelWorld.setAllLintIgnored();
}
}
}
}
private void registerAspectExclude(final BcelWeaver weaver, final ClassLoader loader, final List<Definition> definitions) {
String fastMatchInfo = null;
for (Definition definition : definitions) {
for (String exclude : definition.getAspectExcludePatterns()) {
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | }
}
protected void lint(String name, String[] infos) {
Lint lint = bcelWorld.getLint();
Kind kind = lint.getLintKind(name);
kind.signal(infos, null, null);
}
@Override
public String getContextId() {
return weavingContext.getId();
}
/**
* Register the aspect, following include / exclude rules
*
* @... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | info("register aspect " + aspectClassName);
String requiredType = definition.getAspectRequires(aspectClassName);
if (requiredType != null) {
((BcelWorld) weaver.getWorld()).addAspectRequires(aspectClassName, requiredType);
}
String definedScope = definition.getScopeForAspect... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (acceptAspect(concreteAspect.name)) {
info("define aspect " + concreteAspect.name);
ConcreteAspectCodeGen gen = new ConcreteAspectCodeGen(concreteAspect, weaver.getWorld());
if (!gen.validate()) {
error("Concrete-aspect '" + concreteAspect.name + "' could not be registered");
success = fal... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (trace.isTraceEnabled()) {
trace.exit("registerAspects", success);
}
return success;
}
private boolean weaveAndDefineConceteAspects() {
if (trace.isTraceEnabled()) {
trace.enter("weaveAndDefineConceteAspects", this, concreteAspects);
}
boolean success = true;
for (ConcreteAspectCodeGen gen : conc... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | * @param weaver
* @param loader
* @param definitions
*/
private void registerIncludeExclude(final BcelWeaver weaver, final ClassLoader loader, final List<Definition> definitions) {
String fastMatchInfo = null;
for (Definition definition : definitions) {
for (Iterator<String> iterator1 = definition.getIncl... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | } else if ((fastMatchInfo = looksLikeExactName(exclude)) != null) {
excludeExactName.add(exclude);
} else if ((fastMatchInfo = looksLikeEndsWith(exclude)) != null) {
excludeEndsWith.add(fastMatchInfo);
} else if (exclude
.equals("org.codehaus.groovy..* && !org.codehaus.groovy.grails.web.servlet.... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | String subPattern = typePattern.substring(4, typePattern.length() - 1);
if (hasStarDot(subPattern, 0)) {
return null;
}
return subPattern.replace('$', '.');
}
/**
* Checks if the pattern looks like "com.foo.Bar" - an exact name
*/
private String looksLikeExactName(String typePattern) {
if (hasSpaceAnn... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | private boolean hasSpaceAnnotationPlus(String string, int pos) {
for (int i = pos, max = string.length(); i < max; i++) {
char ch = string.charAt(i);
if (ch == ' ' || ch == '@' || ch == '+') {
return true;
}
}
return false;
}
/**
* Determine if something in the string is going to affect our abili... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | int length = typePattern.length();
if (typePattern.endsWith("..*") && length > 3) {
if (typePattern.indexOf("..") == length - 3
&& typePattern.indexOf('*') == length - 1) {
return typePattern.substring(0, length - 2).replace('$', '.');
}
}
return null;
}
/**
* Register the dump filter
*
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | }
}
/**
* Determine whether a type should be accepted for weaving, by checking it against any includes/excludes.
*
* @param className the name of the type to possibly accept
* @param bytes the bytecode for the type (in case we need to look inside, eg. annotations)
* @return true if it should be accepted fo... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | fastClassName = fastClassName.replace('$', '.');
if (!excludeEndsWith.isEmpty()) {
for (String lastPiece : excludeEndsWith) {
if (fastClassName.endsWith(lastPiece)) {
return false;
}
}
}
if (!excludeExactName.isEmpty()) {
for (String name : excludeExactName) {
if (fastClassName.equals... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (includeStar) {
return true;
}
if (!includeExactName.isEmpty()) {
didSomeIncludeMatching = true;
for (String exactname : includeExactName) {
if (fastClassName.equals(exactname)) {
return true;
}
}
}
boolean fastAccept = false;
for (int i = 0; i < m_includeStartsWith.siz... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (typePattern.matchesStatically(classInfo)) {
return false;
}
}
if (includeStar) {
return true;
}
if (!includeExactName.isEmpty()) {
didSomeIncludeMatching = true;
for (String exactname : includeExactName) {
if (fastClassName.equals(exactname)) {
return true;
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | }
} finally {
this.bcelWorld.demote();
}
return accept;
}
private boolean acceptAspect(String aspectClassName) {
if (m_aspectExcludeTypePattern.isEmpty() && m_aspectIncludeTypePattern.isEmpty()) {
return true;
}
String fastClassName = aspectClassName.replace('/', '.').replace('.', '$');... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | for (Iterator iterator = m_aspectExcludeTypePattern.iterator(); iterator.hasNext();) {
TypePattern typePattern = (TypePattern) iterator.next();
if (typePattern.matchesStatically(classInfo)) {
return false;
}
}
boolean accept = true;
for (Iterator iterator = m_aspectIncludeTypePattern.iterator... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | ResolvedType classInfo = weaver.getWorld().resolve(UnresolvedType.forName(className), true);
for (Iterator iterator = m_dumpTypePattern.iterator(); iterator.hasNext();) {
TypePattern typePattern = (TypePattern) iterator.next();
if (typePattern.matchesStatically(classInfo)) {
return true;
}
}
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (namespace == null) {
return "";
} else {
return new String(namespace);
}
}
/**
* Check to see if any classes are stored in the generated classes cache. Then flush the cache if it is not empty
*
* @param className TODO
* @return true if a class has been generated and is stored in the cache
*/
... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | private Method defineClassWithProtectionDomainMethod;
private void defineClass(ClassLoader loader, String name, byte[] bytes) {
if (trace.isTraceEnabled()) {
trace.enter("defineClass", this, new Object[] { loader, name, bytes });
}
Object clazz = null;
debug("generating class '" + name + "'");
try {
if... |
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 | loadtime/src/org/aspectj/weaver/loadtime/ClassLoaderWeavingAdaptor.java | if (trace.isTraceEnabled()) {
trace.enter("defineClass", this, new Object[] { loader, name, bytes, protectionDomain });
}
Object clazz = null;
debug("generating class '" + name + "'");
try {
if (defineClassWithProtectionDomainMethod == null) {
defineClassWithProtectionDomainMethod = ClassLoader.cl... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | /* *******************************************************************
* Copyright (c) 2004 IBM Corporation
* 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
* h... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;
import org.aspectj.bridge.AbortException;
import org.aspectj.weaver.bcel.ExtensibleURLClassLoader;
import org.aspectj.weaver.tools.Trace;
import org.aspectj.weaver.tools.TraceFactory;
import org.aspectj.weaver.tools.WeavingAdaptor;
import 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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | trace.exit("<init>");
}
public WeavingURLClassLoader(URL[] classURLs, URL[] aspectURLs, ClassLoader parent) {
super(classURLs, parent);
this.aspectURLs = aspectURLs;
/*
* If either we nor our parent is using an ASPECT_PATH use a new-style adaptor
*/
if (this.aspectURLs.length > 0 || getParent() insta... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | if (f.exists()) {
URL url = f.toURL();
if (url != null)
urlList.add(url);
}
} catch (MalformedURLException e) {
}
}
URL[] urls = new URL[urlList.size()];
urlList.toArray(urls);
return urls;
}
protected void addURL(URL url) {
if (adaptor == null) {
createAdaptor();
}
adaptor.... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | if (adaptor == null && !initializingAdaptor) {
createAdaptor();
}
try {
b = adaptor.weaveClass(name, b, false);
} catch (AbortException ex) {
trace.error("defineClass", ex);
throw ex;
} catch (Throwable th) {
trace.error("defineClass", th);
}
}
Class clazz;
try {
clazz... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | return loader.getClass().getName();
}
};
ClassLoaderWeavingAdaptor clwAdaptor = new ClassLoaderWeavingAdaptor();
initializingAdaptor = true;
clwAdaptor.initialize(this, weavingContext);
initializingAdaptor = false;
adaptor = clwAdaptor;
}
/**
* Override to find classes generated by WeavingAdaptor
*... |
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 | loadtime/src/org/aspectj/weaver/loadtime/WeavingURLClassLoader.java | }
}
}
}
}
}
}
} |
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 | org.aspectj.matcher/src/org/aspectj/weaver/tools/GeneratedClassHandler.java | /* *******************************************************************
* Copyright (c) 2004 IBM Corporation
* 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
* h... |
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 | util/src/org/aspectj/util/LangUtil.java | /* *******************************************************************
* Copyright (c) 1999-2001 Xerox Corporation,
* 2002 Palo Alto Research Center, Incorporated (PARC).
* All rights reserved. |
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 | util/src/org/aspectj/util/LangUtil.java | * This program and the accompanying materials are made available
* under the terms of the Eclipse Public License v1.0
* which accompanies this distribution and is available at
* http:www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Xerox/PARC initial implementation
* ***********************... |
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 | 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();
}
... |
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 | util/src/org/aspectj/util/LangUtil.java | vmVersion = 1.5;
} else {
try {
String versionString = vm.substring(0, 3);
Double temp = new Double(Double.parseDouble(versionString));
vmVersion = temp.floatValue();
} catch (Exception e) {
vmVersion = 1.4;
}
}
} catch (Throwable t) {
new RuntimeException(
"System proper... |
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 | util/src/org/aspectj/util/LangUtil.java | return 1.7 <= vmVersion;
}
/**
* Shorthand for "if null, throw IllegalArgumentException"
*
* @throws IllegalArgumentException "null {name}" if o is null
*/
public static final void throwIaxIfNull(final Object o, final String name) {
if (null == o) {
String message = "null " + (null == name ? "input" : ... |
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 | util/src/org/aspectj/util/LangUtil.java | throw new IllegalArgumentException(message);
}
}
}
}
/**
* Shorthand for "if not null or not assignable, throw IllegalArgumentException"
*
* @throws IllegalArgumentException "null {name}" if o is null
*/
public static final void throwIaxIfNotAssignable(final Object o, final Class<?> c, final 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 | 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);
}
}
}
... |
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 | util/src/org/aspectj/util/LangUtil.java | public static boolean isEmpty(Collection<?> collection) {
return ((null == collection) || (0 == collection.size()));
}
/**
* Splits <code>text</code> at whitespace.
*
* @param text <code>String</code> to split.
*/
public static String[] split(String text) {
return (String[]) strings(text).toArray(new St... |
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 | util/src/org/aspectj/util/LangUtil.java | StringTokenizer st = new StringTokenizer(classpath, File.pathSeparator);
ArrayList<String> result = new ArrayList<String>(st.countTokens());
while (st.hasMoreTokens()) {
String entry = st.nextToken();
if (!LangUtil.isEmpty(entry)) {
result.add(entry);
}
}
return (String[]) result.toArray(new 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 | util/src/org/aspectj/util/LangUtil.java | * If delimiter is null or empty or if the input contains no delimiters, the input itself is returned after trimming white
* space.
*
* @param input <code>String</code> to split.
* @param delim <code>String</code> separators for input.
* @return List of String of elements.
*/
public static List<String> any... |
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 | util/src/org/aspectj/util/LangUtil.java | }
List<String> strings = new ArrayList<String>();
StringTokenizer tok = new StringTokenizer(text);
while (tok.hasMoreTokens()) {
strings.add(tok.nextToken());
}
return strings;
}
public static <T> List<T> safeList(List<T> list) {
return (null == list ? Collections.<T>emptyList() : Collections.unmodif... |
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 | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
break;
}
}
}
}
/** |
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 | util/src/org/aspectj/util/LangUtil.java | */
}
}
}
}
}
/**
* copy non-null two-dimensional String[][]
*
* @see extractOptions(String[], String[][])
*/
public static String[][] copyStrings(String[][] in) {
String[][] out = new String[in.length][];
for (int i = 0; i < out.length; i++) {
out[i] = new String[in[i... |
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 | util/src/org/aspectj/util/LangUtil.java | }
/**
* Extract options and arguments to input option list, returning remainder. The input options will be nullified if not found.
* e.g.,
*
* <pre>
* String[] options = new String[][] { new String[] { "-verbose" }, new String[] { "-classpath", null } };
* String[] args = extractOption... |
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 | util/src/org/aspectj/util/LangUtil.java | found = sought.equals(args[j]);
if (found) {
foundSet.set(i);
int doMore = option.length - 1;
if (0 < doMore) {
final int MAX = j + doMore;
if (MAX >= args.length) {
String s = "expecting " + doMore + " args after ";
throw new IllegalArgumentException(s + args[j]);
}
... |
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 | util/src/org/aspectj/util/LangUtil.java | args = temp;
}
return args;
}
/**
*/
}
}
} |
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 | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
}
}
break; |
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 | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
}
}
}
}
break;
} |
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 | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
}
break;
}
}
}
}
/** |
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 | util/src/org/aspectj/util/LangUtil.java | */
}
}
}
} |
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 | util/src/org/aspectj/util/LangUtil.java | }
}
}
}
}
}
}
/**
*/ |
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 | util/src/org/aspectj/util/LangUtil.java | }
/**
* Convert arrays safely. The number of elements in the result will be 1 smaller for each element that is null or not
* assignable. This will use sink if it has exactly the right size. The result will always have the same component type as sink.
*
* @return an array with the same component type as sink c... |
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 | util/src/org/aspectj/util/LangUtil.java | if (resultSize != sinkLength) {
sink = (Object[]) Array.newInstance(sinkType, result.size());
}
if (0 < resultSize) {
sink = result.toArray(sink);
}
return sink;
}
/**
* @return a String with the unqualified class name of the class (or "null")
*/
public static String unqualifiedClassName(Class<?> c... |
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 | util/src/org/aspectj/util/LangUtil.java | if (LangUtil.isEmpty(in) || LangUtil.isEmpty(sought)) {
return in;
}
StringBuffer result = new StringBuffer();
final int len = sought.length();
int start = 0;
int loc;
while (-1 != (loc = in.indexOf(sought, start))) {
result.append(in.substring(start, loc));
if (!LangUtil.isEmpty(replace)) {
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 | util/src/org/aspectj/util/LangUtil.java | return result;
}
}
i++;
j++;
break;
}
}
} |
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 | util/src/org/aspectj/util/LangUtil.java | }
/**
* @return "({UnqualifiedExceptionClass}) {message}"
*/
public static String renderExceptionShort(Throwable e) {
if (null == e) {
return "(Throwable) null";
}
return "(" + LangUtil.unqualifiedClassName(e) + ") " + e.getMessage();
}
/**
* Renders exception <code>t</code> after unwrapping and elid... |
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 | util/src/org/aspectj/util/LangUtil.java | }
t = unwrapException(t);
StringBuffer stack = stackToString(t, false);
if (elide) {
elideEndingLines(StringChecker.TEST_PACKAGES, stack, 100);
}
return stack.toString();
}
/**
* Trim ending lines from a StringBuffer, clipping to maxLines and further removing any number of trailing lines accepted 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 | util/src/org/aspectj/util/LangUtil.java | if (!checker.acceptString(line)) {
break;
} else {
elided++;
lines.removeLast();
}
}
if ((elided > 0) || (maxLines < 1)) {
final int EOL_LEN = EOL.length();
int totalLength = 0;
while (!lines.isEmpty()) {
totalLength += EOL_LEN + ((String) lines.getFirst()).length();
lines.removeF... |
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 | util/src/org/aspectj/util/LangUtil.java | writer.println(throwable.getMessage());
}
throwable.printStackTrace(writer);
try {
buf.close();
} catch (IOException ioe) {
} ignored
return buf.getBuffer();
}
public static Throwable unwrapException(Throwable t) {
Throwable current = t;
Throwable next = null;
while (current != null) {
... |
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 | util/src/org/aspectj/util/LangUtil.java | if (null == next) {
break;
} else {
current = next;
next = null;
}
}
return current;
}
/**
* Replacement for Arrays.asList(..) which gacks on null and returns a List in which remove is an unsupported operation.
*
* @param array the Object[] to convert (may be null)
* @return the List co... |
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 | util/src/org/aspectj/util/LangUtil.java | static StringChecker TEST_PACKAGES = new StringChecker(new String[] { "org.aspectj.testing",
"org.eclipse.jdt.internal.junit", "junit.framework.",
"org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner" });
String[] infixes;
StringChecker(String[] infixes) {
this.infixes = infixes;
}
pub... |
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 | util/src/org/aspectj/util/LangUtil.java | * @param bootclasspath
* @param classpath
* @param classesDir
* @param outputJar
* @return String combining classpath elements
*/
public static String makeClasspath(
String bootclasspath, String classpath, String classesDir, String outputJar) {
StringBuffer sb = new StringBuffer();
addIfNotEmpty(boot... |
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 | util/src/org/aspectj/util/LangUtil.java | return true;
}
/**
* Create or initialize a process controller to run a process in another VM asynchronously.
*
* @param controller the ProcessController to initialize, if not null
* @param classpath
* @param mainClass
* @param args
* @return initialized ProcessController
*/
public static ProcessCon... |
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 | util/src/org/aspectj/util/LangUtil.java | */
}
}
/**
* Find java executable File path from java.home system property.
*
* @return File associated with the java command, or null if not found.
*/
public static File getJavaExecutable() {
String javaHome = null;
File result = null;
try {
javaHome = System.getPropert... |
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 | util/src/org/aspectj/util/LangUtil.java | if (null != javaHome) {
File binDir = new File(javaHome, "bin");
if (binDir.isDirectory() && binDir.canRead()) {
String[] execs = new String[] { "java", "java.exe" };
for (int i = 0; i < execs.length; i++) {
result = new File(binDir, execs[i]);
if (result.canRead()) {
break;
}
}
... |
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 | util/src/org/aspectj/util/LangUtil.java | *
* @param time the long time in milliseconds to sleep until
* @return true if delay succeeded, false if interrupted 100 times
*/
public static boolean sleepUntil(long time) {
if (time == 0) {
return true;
} else if (time < 0) {
throw new IllegalArgumentException("negative: " + time);
}
long cu... |
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 | util/src/org/aspectj/util/LangUtil.java | * <pre>
* LangUtil.ProcessController controller = new LangUtil.ProcessController() {
* protected void doCompleting(LangUtil.ProcessController.Thrown thrown, int result) {
* signal result
* }
* };
* controller.init(new String[] { "java", "-version" }, "java version");
* ... |
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 | util/src/org/aspectj/util/LangUtil.java | private boolean userStopped;
private Process process;
private FileUtil.Pipe errStream;
private FileUtil.Pipe outStream;
private FileUtil.Pipe inStream;
private ByteArrayOutputStream errSnoop;
private ByteArrayOutputStream outSnoop;
private int result;
private Thrown thrown;
public ProcessController() ... |
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 | util/src/org/aspectj/util/LangUtil.java | outStream = null;
inStream = null;
}
public final void init(String classpath, String mainClass, String[] args) {
init(LangUtil.getJavaExecutable(), classpath, mainClass, args);
}
public final void init(File java, String classpath, String mainClass, String[] args) {
LangUtil.throwIaxIfNull(java, "java")... |
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 | util/src/org/aspectj/util/LangUtil.java | this.envp = (String[]) LangUtil.safeCopy(envp, new String[0]);
if (1 > this.envp.length) {
throw new IllegalArgumentException("empty envp");
}
}
public final void setErrSnoop(ByteArrayOutputStream snoop) {
errSnoop = snoop;
if (null != errStream) {
errStream.setSnoop(errSnoop);
}
}
public... |
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 | util/src/org/aspectj/util/LangUtil.java | started = true;
}
try {
process = Runtime.getRuntime().exec(command);
} catch (IOException e) {
stop(e, Integer.MIN_VALUE);
return null;
}
errStream = new FileUtil.Pipe(process.getErrorStream(), System.err);
if (null != errSnoop) {
errStream.setSnoop(errSnoop);
}
outStream = new ... |
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 | util/src/org/aspectj/util/LangUtil.java | thrown = e;
} finally {
stop(thrown, result);
}
}
};
Thread result = new Thread(processRunner, label);
result.start();
return result;
}
/**
* Destroy any process, stop any pipes. This waits for the pipes to clear (reading until no more input is available), but
* does not wait f... |
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 | util/src/org/aspectj/util/LangUtil.java | public final boolean completed() {
return completed;
}
public final boolean started() {
return started;
}
public final boolean userStopped() {
return userStopped;
}
/**
* Get any Throwable thrown. Note that the process can complete normally (with a valid return value), at the same time the
* ... |
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 | util/src/org/aspectj/util/LangUtil.java | * @see getThrown()
* @see getResult()
* @see stop()
*/
protected void doCompleting(Thrown thrown, int result) {
}
/**
* Handle termination (on-demand, abrupt, or normal) by destroying and/or halting process and pipes.
*
* @param thrown ignored if null
* @param result ignored if Integer.MIN_V... |
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 | util/src/org/aspectj/util/LangUtil.java | }
if (null != errStream) {
errStream.halt(true, true);
errStream = null;
}
if (Integer.MIN_VALUE != result) {
this.result = result;
}
completed = true;
doCompleting(this.thrown, result);
}
/**
* Create snapshot of Throwable's thrown.
*
* @param thrown ignored if null or if th... |
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 | util/src/org/aspectj/util/LangUtil.java | private Thrown(Throwable fromProcess, Throwable fromOutPipe, Throwable fromErrPipe, Throwable fromInPipe) {
this.fromProcess = fromProcess;
this.fromErrPipe = fromErrPipe;
this.fromOutPipe = fromOutPipe;
this.fromInPipe = fromInPipe;
thrown = ((null != fromProcess) || (null != fromInPipe) || (null !... |
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 | /* *******************************************************************
* Copyright (c) 2004 IBM Corporation
* 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
* h... |
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 | import org.aspectj.bridge.Message;
import org.aspectj.bridge.MessageHandler;
import org.aspectj.bridge.MessageUtil;
import org.aspectj.bridge.MessageWriter;
import org.aspectj.bridge.Version;
import org.aspectj.bridge.WeaveMessage;
import org.aspectj.util.FileUtil;
import org.aspectj.util.LangUtil;
import org.aspectj.w... |
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 | /**
* System property used to turn on verbose weaving messages
*/
public static final String WEAVING_ADAPTOR_VERBOSE = "aj.weaving.verbose";
public static final String SHOW_WEAVE_INFO_PROPERTY = "org.aspectj.weaver.showWeaveInfo";
public static final String TRACE_MESSAGES_PROPERTY = "org.aspectj.tracing.messages... |
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 WeavingAdaptor() {
}
/**
* Construct a WeavingAdaptor with a reference to a weaving class loader. The adaptor will automatically search the class loader
* hierarchy to resolve classes. The adaptor will also search the hierarchy for WeavingClassLoader instances to determine the
* set of aspects to be u... |
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 | for (; loader != null; loader = loader.getParent()) {
if (loader instanceof URLClassLoader) {
URL[] urls = ((URLClassLoader) loader).getURLs();
list.addAll(0, FileUtil.makeClasspath(urls));
} else {
warn("cannot determine classpath");
}
}
list.addAll(0, makeClasspath(System.getProperty("sun.boo... |
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 | * Initialize the WeavingAdapter
* @param loader ClassLoader used by this adapter; which can be null
* @param classPath classpath of this adapter
* @param aspectPath list of aspect paths
*/
private void init(ClassLoader loader, List<String> classPath, List<String> aspectPath) {
abortOnError = true;
createMe... |
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 initializeCache(ClassLoader loader, List<String> aspects, GeneratedClassHandler existingClassHandler, IMessageHandler myMessageHandler) {
if (WeavedClassCache.isEnabled()) {
cache = WeavedClassCache.createCache(loader, aspects, existingClassHandler, myMessageHandler);
if (cache != null) {
... |
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 (mh != messageHolder) {
messageHolder.setDelegate(mh);
}
messageHolder.flushMessages();
}
protected void disable() {
if (trace.isTraceEnabled()) {
trace.enter("disable", this);
}
enabled = false;
messageHolder.flushMessages();
if (trace.isTraceEnabled()) {
trace.exit("disable");
}
}
... |
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 | try {
weaver.addLibraryJarFile(libFile);
} catch (IOException ex) {
warn("bad library: '" + libFile + "'");
}
}
/**
* Weave a class using aspects previously supplied to the adaptor.
*
* @param name the name of the class
* @param bytes the class bytes
* @return the woven bytes
* @exception IOExc... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.