@Override
public void resolveEntryPoints(@NotNull final RefManager manager) {
if (!myResolved) {
myResolved = true;
cleanup();
validateEntryPoints();
ApplicationManager.getApplication()
.runReadAction(
() -> {
for (SmartRefElementPointer entryPoint : myPersistentEntryPoints.values()) {
if (entryPoint.resolve(manager)) {
RefEntity refElement = entryPoint.getRefElement();
((RefElementImpl) refElement).setEntry(true);
((RefElementImpl) refElement).setPermanentEntry(entryPoint.isPersistent());
}
}
for (ClassPattern pattern : myPatterns) {
final RefEntity refClass =
manager.getReference(RefJavaManager.CLASS, pattern.pattern);
if (refClass != null) {
for (RefMethod constructor : ((RefClass) refClass).getConstructors()) {
((RefMethodImpl) constructor).setEntry(true);
((RefMethodImpl) constructor).setPermanentEntry(true);
}
}
}
});
}
}
@Override
public void addEntryPoint(@NotNull RefElement newEntryPoint, boolean isPersistent) {
if (!newEntryPoint.isValid()) return;
if (isPersistent) {
if (newEntryPoint instanceof RefMethod && ((RefMethod) newEntryPoint).isConstructor()
|| newEntryPoint instanceof RefClass) {
final ClassPattern classPattern = new ClassPattern();
classPattern.pattern = new SmartRefElementPointerImpl(newEntryPoint, true).getFQName();
getPatterns().add(classPattern);
final EntryPointsManager entryPointsManager =
getInstance(newEntryPoint.getElement().getProject());
if (this != entryPointsManager) {
entryPointsManager.addEntryPoint(newEntryPoint, true);
}
return;
}
}
if (newEntryPoint instanceof RefClass) {
RefClass refClass = (RefClass) newEntryPoint;
if (refClass.isAnonymous()) {
// Anonymous class cannot be an entry point.
return;
}
List<RefMethod> refConstructors = refClass.getConstructors();
if (refConstructors.size() == 1) {
addEntryPoint(refConstructors.get(0), isPersistent);
} else if (refConstructors.size() > 1) {
// Many constructors here. Need to ask user which ones are used
for (RefMethod refConstructor : refConstructors) {
addEntryPoint(refConstructor, isPersistent);
}
}
}
if (!isPersistent) {
myTemporaryEntryPoints.add(newEntryPoint);
((RefElementImpl) newEntryPoint).setEntry(true);
} else {
if (myPersistentEntryPoints.get(newEntryPoint.getExternalName()) == null) {
final SmartRefElementPointerImpl entry =
new SmartRefElementPointerImpl(newEntryPoint, true);
myPersistentEntryPoints.put(entry.getFQName(), entry);
((RefElementImpl) newEntryPoint).setEntry(true);
((RefElementImpl) newEntryPoint).setPermanentEntry(true);
if (entry.isPersistent()) { // do save entry points
final EntryPointsManager entryPointsManager =
getInstance(newEntryPoint.getElement().getProject());
if (this != entryPointsManager) {
entryPointsManager.addEntryPoint(newEntryPoint, true);
}
}
}
}
}
public void removeEntryPoint(RefElement anEntryPoint) {
if (anEntryPoint instanceof RefClass) {
RefClass refClass = (RefClass) anEntryPoint;
if (!refClass.isInterface()) {
anEntryPoint = refClass.getDefaultConstructor();
}
}
if (anEntryPoint == null) return;
myTemporaryEntryPoints.remove(anEntryPoint);
Set<Map.Entry<String, SmartRefElementPointer>> set = myPersistentEntryPoints.entrySet();
String key = null;
for (Map.Entry<String, SmartRefElementPointer> entry : set) {
SmartRefElementPointer value = entry.getValue();
if (value.getRefElement() == anEntryPoint) {
key = entry.getKey();
break;
}
}
if (key != null) {
myPersistentEntryPoints.remove(key);
((RefElementImpl) anEntryPoint).setEntry(false);
}
if (anEntryPoint.isPermanentEntry() && anEntryPoint.isValid()) {
final Project project = anEntryPoint.getElement().getProject();
final EntryPointsManagerImpl entryPointsManager = getInstance(project);
if (this != entryPointsManager) {
entryPointsManager.removeEntryPoint(anEntryPoint);
}
}
}
private void purgeTemporaryEntryPoints() {
for (RefElement entryPoint : myTemporaryEntryPoints) {
((RefElementImpl) entryPoint).setEntry(false);
}
myTemporaryEntryPoints.clear();
}
@Override
public void removeRefElement(
@NotNull RefElement refElement, @NotNull List<RefElement> deletedRefs) {
List<RefEntity> children = refElement.getChildren();
if (children != null) {
RefElement[] refElements = children.toArray(new RefElement[children.size()]);
for (RefElement refChild : refElements) {
removeRefElement(refChild, deletedRefs);
}
}
((RefManagerImpl) refElement.getRefManager()).removeReference(refElement);
((RefElementImpl) refElement).referenceRemoved();
if (!deletedRefs.contains(refElement)) deletedRefs.add(refElement);
}
@Override
public void removeEntryPoint(@NotNull RefElement anEntryPoint) {
myTemporaryEntryPoints.remove(anEntryPoint);
Set<Map.Entry<String, SmartRefElementPointer>> set = myPersistentEntryPoints.entrySet();
String key = null;
for (Map.Entry<String, SmartRefElementPointer> entry : set) {
SmartRefElementPointer value = entry.getValue();
if (value.getRefElement() == anEntryPoint) {
key = entry.getKey();
break;
}
}
if (key != null) {
myPersistentEntryPoints.remove(key);
}
((RefElementImpl) anEntryPoint).setEntry(false);
if (anEntryPoint.isPermanentEntry() && anEntryPoint.isValid()) {
final Project project = anEntryPoint.getElement().getProject();
final EntryPointsManager entryPointsManager = getInstance(project);
if (this != entryPointsManager) {
entryPointsManager.removeEntryPoint(anEntryPoint);
}
}
if (anEntryPoint instanceof RefMethod && ((RefMethod) anEntryPoint).isConstructor()
|| anEntryPoint instanceof RefClass) {
final RefClass aClass =
anEntryPoint instanceof RefClass
? (RefClass) anEntryPoint
: ((RefMethod) anEntryPoint).getOwnerClass();
final String qualifiedName = aClass.getQualifiedName();
for (Iterator<ClassPattern> iterator = getPatterns().iterator(); iterator.hasNext(); ) {
if (Comparing.equal(iterator.next().pattern, qualifiedName)) {
// todo if inheritance or pattern?
iterator.remove();
}
}
}
}