@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
DocumentFoldingInfo info = (DocumentFoldingInfo) o;
if (myFile != null ? !myFile.equals(info.myFile) : info.myFile != null) {
return false;
}
if (!myProject.equals(info.myProject)
|| !myPsiElements.equals(info.myPsiElements)
|| !mySerializedElements.equals(info.mySerializedElements)) {
return false;
}
if (myRangeMarkers.size() != info.myRangeMarkers.size()) return false;
for (int i = 0; i < myRangeMarkers.size(); i++) {
RangeMarker marker = myRangeMarkers.get(i);
RangeMarker other = info.myRangeMarkers.get(i);
if (marker == other || !marker.isValid() || !other.isValid()) {
continue;
}
if (!TextRange.areSegmentsEqual(marker, other)) return false;
FoldingInfo fi = marker.getUserData(FOLDING_INFO_KEY);
FoldingInfo ofi = other.getUserData(FOLDING_INFO_KEY);
if (!Comparing.equal(fi, ofi)) return false;
}
return true;
}
public XmlAttribute setAttribute(String name, String namespace, String value)
throws IncorrectOperationException {
if (!Comparing.equal(namespace, "")) {
final String prefix = getPrefixByNamespace(namespace);
if (prefix != null && prefix.length() > 0) name = prefix + ":" + name;
}
return setAttribute(name, value);
}
private static boolean attributeListsEqual(List<Attribute> l1, List<Attribute> l2) {
if (l1 == null) return l2 == null;
if (l2 == null) return false;
if (l1.size() != l2.size()) return false;
Iterator<Attribute> i1 = l1.iterator();
for (Attribute aL2 : l2) {
Attribute attr1 = i1.next();
if (!Comparing.equal(attr1.getName(), aL2.getName())
|| !Comparing.equal(attr1.getValue(), aL2.getValue())) {
return false;
}
}
return true;
}
@Nullable
public XmlAttribute getAttribute(String qname) {
if (qname == null) return null;
final XmlAttribute[] attributes = getAttributes();
final boolean caseSensitive = isCaseSensitive();
for (final XmlAttribute attribute : attributes) {
final LeafElement attrNameElement =
(LeafElement) XmlChildRole.ATTRIBUTE_NAME_FINDER.findChild(attribute.getNode());
if (attrNameElement != null
&& (caseSensitive && Comparing.equal(attrNameElement.getChars(), qname)
|| !caseSensitive && Comparing.equal(attrNameElement.getChars(), qname, false))) {
return attribute;
}
}
return null;
}
@Override
public void visitReferenceExpression(final PsiReferenceExpression reference) {
if (myLineRange.intersects(reference.getTextRange())) {
final PsiElement psiElement = reference.resolve();
if (psiElement instanceof PsiVariable) {
final PsiVariable var = (PsiVariable) psiElement;
if (var instanceof PsiField) {
if (myCollectExpressions
&& !DebuggerUtils.hasSideEffectsOrReferencesMissingVars(
reference, myVisibleLocals)) {
/*
if (var instanceof PsiEnumConstant && reference.getQualifier() == null) {
final PsiClass enumClass = ((PsiEnumConstant)var).getContainingClass();
if (enumClass != null) {
final PsiExpression expression = JavaPsiFacade.getInstance(var.getProject()).getParserFacade().createExpressionFromText(enumClass.getName() + "." + var.getName(), var);
final PsiReference ref = expression.getReference();
if (ref != null) {
ref.bindToElement(var);
myExpressions.add(new TextWithImportsImpl(expression));
}
}
}
else {
myExpressions.add(new TextWithImportsImpl(reference));
}
*/
final PsiModifierList modifierList = var.getModifierList();
boolean isConstant =
(var instanceof PsiEnumConstant)
|| (modifierList != null
&& modifierList.hasModifierProperty(PsiModifier.STATIC)
&& modifierList.hasModifierProperty(PsiModifier.FINAL));
if (!isConstant) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
} else {
if (myVisibleLocals.contains(var.getName())) {
myVars.add(var.getName());
} else {
// fix for variables used in inner classes
if (!Comparing.equal(
PsiTreeUtil.getParentOfType(reference, PsiClass.class),
PsiTreeUtil.getParentOfType(var, PsiClass.class))) {
myExpressions.add(new TextWithImportsImpl(reference));
}
}
}
}
}
super.visitReferenceExpression(reference);
}
public static boolean inTheSameMethod(
@NotNull SourcePosition pos1, @NotNull SourcePosition pos2) {
ApplicationManager.getApplication().assertReadAccessAllowed();
PsiElement elem1 = pos1.getElementAt();
PsiElement elem2 = pos2.getElementAt();
if (elem1 == null) return elem2 == null;
if (elem2 != null) {
PsiElement expectedMethod = getContainingMethod(elem1);
PsiElement currentMethod = getContainingMethod(elem2);
return Comparing.equal(expectedMethod, currentMethod);
}
return false;
}
private static int getSeqNumber(@NotNull PsiClass aClass) {
// sequence number of this class among its parent' child classes named the same
PsiElement parent = aClass.getParent();
if (parent == null) return -1;
int seqNo = 0;
for (PsiElement child : parent.getChildren()) {
if (child == aClass) return seqNo;
if (child instanceof PsiClass
&& Comparing.strEqual(aClass.getName(), ((PsiClass) child).getName())) {
seqNo++;
}
}
return -1;
}
public static boolean elementsEqual(Element e1, Element e2) {
if (e1 == null) {
return e2 == null;
}
if (!Comparing.equal(e1.getName(), e2.getName())) {
return false;
}
if (!elementListsEqual(e1.getChildren(), e2.getChildren())) {
return false;
}
if (!attributeListsEqual(e1.getAttributes(), e2.getAttributes())) {
return false;
}
return true;
}
private void closeEditor() {
boolean unsplit = false;
if (mySplittedWindow != null && !mySplittedWindow.isDisposed()) {
final EditorWithProviderComposite[] editors = mySplittedWindow.getEditors();
if (editors.length == 1 && Comparing.equal(editors[0].getFile(), myNewVirtualFile)) {
unsplit = true;
}
}
FileEditorManager.getInstance(myProject).closeFile(myNewVirtualFile);
if (unsplit) {
for (EditorWindow editorWindow : mySplittedWindow.findSiblings()) {
editorWindow.unsplit(true);
}
}
}
private static boolean compareParamTypes(
@NotNull PsiManager manager, @NotNull PsiType type1, @NotNull PsiType type2) {
if (type1 instanceof PsiArrayType) {
return type2 instanceof PsiArrayType
&& compareParamTypes(
manager,
((PsiArrayType) type1).getComponentType(),
((PsiArrayType) type2).getComponentType());
}
if (!(type1 instanceof PsiClassType) || !(type2 instanceof PsiClassType)) {
return type1.equals(type2);
}
PsiClass class1 = ((PsiClassType) type1).resolve();
PsiClass class2 = ((PsiClassType) type2).resolve();
if (class1 instanceof PsiTypeParameter && class2 instanceof PsiTypeParameter) {
return Comparing.equal(class1.getName(), class2.getName())
&& ((PsiTypeParameter) class1).getIndex() == ((PsiTypeParameter) class2).getIndex();
}
return manager.areElementsEquivalent(class1, class2);
}
private boolean isJDKChanged(final Sdk newJDK) {
if (mySdk == null && newJDK == null) return false;
return mySdk == null
|| newJDK == null
|| !Comparing.equal(mySdk.getVersionString(), newJDK.getVersionString());
}
public static boolean inTheMethod(@NotNull SourcePosition pos, @NotNull PsiElement method) {
PsiElement elem = pos.getElementAt();
if (elem == null) return false;
return Comparing.equal(getContainingMethod(elem), method);
}
public final void setSubId(@Nullable String subId) {
if (Comparing.strEqual(mySubId, subId)) return;
saveExpandedPaths();
mySubId = subId;
}
public int hashCode() {
return Comparing.hashcode(TEST_OBJECT)
^ Comparing.hashcode(getMainClassName())
^ Comparing.hashcode(getPackageName())
^ Comparing.hashcode(getMethodName())
^ Comparing.hashcode(getWorkingDirectory())
^ Comparing.hashcode(VM_PARAMETERS)
^ Comparing.hashcode(PARAMETERS)
^ Comparing.hashcode(myPattern)
^ Comparing.hashcode(FORK_MODE)
^ Comparing.hashcode(DIR_NAME)
^ Comparing.hashcode(CATEGORY_NAME);
}
public boolean equals(final Object object) {
if (!(object instanceof Data)) return false;
final Data second = (Data) object;
return Comparing.equal(TEST_OBJECT, second.TEST_OBJECT)
&& Comparing.equal(getMainClassName(), second.getMainClassName())
&& Comparing.equal(getPackageName(), second.getPackageName())
&& Comparing.equal(getMethodName(), second.getMethodName())
&& Comparing.equal(getWorkingDirectory(), second.getWorkingDirectory())
&& Comparing.equal(VM_PARAMETERS, second.VM_PARAMETERS)
&& Comparing.equal(PARAMETERS, second.PARAMETERS)
&& Comparing.equal(myPattern, second.myPattern)
&& Comparing.equal(FORK_MODE, second.FORK_MODE)
&& Comparing.equal(DIR_NAME, second.DIR_NAME)
&& Comparing.equal(CATEGORY_NAME, second.CATEGORY_NAME);
}
public String getPackage() {
final Data data = getPersistentData();
return !Comparing.strEqual(data.TEST_OBJECT, TEST_PACKAGE) ? null : data.getPackageName();
}