Package com.intellij.refactoring.invertBoolean

Class InvertBooleanDelegate

java.lang.Object

com.intellij.refactoring.invertBoolean.InvertBooleanDelegate

Direct Known Subclasses:

JavaInvertBooleanDelegate, PyInvertBooleanDelegate

public abstract class InvertBooleanDelegate
extends java.lang.Object

Field Summary

Fields

Modifier and Type	Field and Description
static ExtensionPointName<InvertBooleanDelegate>	EP_NAME

Constructor Summary

Constructors

Constructor and Description
InvertBooleanDelegate()

Method Summary

Modifier and Type	Method and Description
abstract PsiElement	adjustElement(PsiElement element, Project project, Editor editor) Adjust element to invert, e.g.
boolean	collectElementsToInvert(PsiElement namedElement, PsiElement expression, java.util.Collection<PsiElement> elementsToInvert)
protected static void	collectForeignElementsToInvert(PsiElement namedElement, PsiElement expression, Language language, java.util.Collection<PsiElement> elementsToInvert) Should be called from collectRefElements(PsiElement, RenameProcessor, String, Collection) to process found usages in foreign languages
abstract void	collectRefElements(PsiElement element, RenameProcessor renameProcessor, java.lang.String newName, java.util.Collection<PsiElement> elementsToInvert) Eventually collect additional elements to rename, e.g.
void	findConflicts(UsageInfo[] usageInfos, MultiMap<PsiElement,java.lang.String> conflicts) Detect usages which can't be inverted
static InvertBooleanDelegate	findInvertBooleanDelegate(PsiElement element)
abstract PsiElement	getElementToInvert(PsiElement namedElement, PsiElement expression) Invoked from collectForeignElementsToInvert(PsiElement, PsiElement, Language, Collection) should be used to reject usages for elements from foreign language to be refactored
abstract void	invertElementInitializer(PsiElement var) Initialize variable with negated default initializer when default was initially omitted, or invert variable initializer
abstract boolean	isAvailableOnElement(PsiElement element)
abstract boolean	isVisibleOnElement(PsiElement element) Quick check if element is potentially acceptable by delegate
abstract void	replaceWithNegatedExpression(PsiElement expression) Replace expression with created negation

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

EP_NAME

public static final ExtensionPointName<InvertBooleanDelegate> EP_NAME

Constructor Detail

InvertBooleanDelegate

public InvertBooleanDelegate()

Method Detail

findInvertBooleanDelegate

public static InvertBooleanDelegate findInvertBooleanDelegate(PsiElement element)

isVisibleOnElement

public abstract boolean isVisibleOnElement(PsiElement element)

Quick check if element is potentially acceptable by delegate

Returns:

true if element is possible to invert, e.g. variable or method

isAvailableOnElement

public abstract boolean isAvailableOnElement(PsiElement element)

Returns:

true if element is of boolean type

adjustElement

public abstract PsiElement adjustElement(PsiElement element,
                                         Project project,
                                         Editor editor)

Adjust element to invert, e.g. suggest to refactor super method instead of current

Returns:

null if user canceled the operation

collectRefElements

public abstract void collectRefElements(PsiElement element,
                                        RenameProcessor renameProcessor,
                                        java.lang.String newName,
                                        java.util.Collection<PsiElement> elementsToInvert)

Eventually collect additional elements to rename, e.g. override methods and find expressions which need to be inverted, e.g. return method statements inside the method itself, etc

Parameters:

renameProcessor - null if element is not named or name was not changed

getElementToInvert

public abstract PsiElement getElementToInvert(PsiElement namedElement,
                                              PsiElement expression)

Invoked from collectForeignElementsToInvert(PsiElement, PsiElement, Language, Collection) should be used to reject usages for elements from foreign language to be refactored

Returns:

null, if reference should not be reverted

collectElementsToInvert

public boolean collectElementsToInvert(PsiElement namedElement,
                                       PsiElement expression,
                                       java.util.Collection<PsiElement> elementsToInvert)

Returns:

true, if element was found in current language

collectForeignElementsToInvert

protected static void collectForeignElementsToInvert(PsiElement namedElement,
                                                     PsiElement expression,
                                                     Language language,
                                                     java.util.Collection<PsiElement> elementsToInvert)

Should be called from collectRefElements(PsiElement, RenameProcessor, String, Collection) to process found usages in foreign languages

replaceWithNegatedExpression

public abstract void replaceWithNegatedExpression(PsiElement expression)

Replace expression with created negation

Parameters:

expression - to be inverted, found in collectRefElements(PsiElement, RenameProcessor, String, Collection)

invertElementInitializer

public abstract void invertElementInitializer(PsiElement var)

Initialize variable with negated default initializer when default was initially omitted, or invert variable initializer

findConflicts

public void findConflicts(UsageInfo[] usageInfos,
                          MultiMap<PsiElement,java.lang.String> conflicts)

Detect usages which can't be inverted