public void determineSettersAndMethodCalls(
RearrangerSettings settings, List<ClassContentsEntry> contents) {
if (isGetter()) {
if (settings.isKeepGettersSettersTogether()) {
determineSetter(
contents, settings); // link getters/setters via correspondingGetterSetter entries
}
}
if (!isNoExtractedMethods()
&& settings.getExtractedMethodsSettings().isMoveExtractedMethods()) {
determineMethodCalls(contents, settings);
}
}
public void determineGetterSetterAndExtractedMethodStatus(RearrangerSettings settings) {
LOG.debug("building method call & getter-setter graph for " + getName());
/**
* check all rules to find first that this method matches. If that rule specifies that matching
* methods are excluded from extracted method treatment, then skip this step. If this method is
* a getter (according to that rule's definition) then determine its setter (according to that
* rule's definition) at this point also.
*/
setNoExtractedMethods(false);
/**
* The following code determines whether the method is a getter/setter based on default
* definition. This is necessary in case there are no rules, but "Keep Getters/Setters Together"
* is set. If the method matches an individual rule with its own getter/setter definition, the
* values of getter and setter will be changed to match that rule's definition.
*/
setGetter(MethodUtil.isGetter((PsiMethod) myEnd, settings.getDefaultGSDefinition()));
setSetter(MethodUtil.isSetter((PsiMethod) myEnd, settings.getDefaultGSDefinition()));
for (Rule rule : settings.getItemOrderAttributeList()) {
if (rule instanceof IRestrictMethodExtraction) {
if (rule.isMatch(this)) {
if (((IRestrictMethodExtraction) rule).isNoExtractedMethods()) {
LOG.debug("excluding " + myEnd.toString() + " from extracted method consideration");
setNoExtractedMethods(true);
}
setGetter(false);
if (rule instanceof IHasGetterSetterDefinition) {
if (MethodUtil.isGetter(
(PsiMethod) getEnd(),
((IHasGetterSetterDefinition) rule).getGetterSetterDefinition())) {
if (settings.isKeepGettersSettersTogether()) {
setGetter(true);
}
}
setSetter(
MethodUtil.isSetter(
(PsiMethod) getEnd(),
((IHasGetterSetterDefinition) rule).getGetterSetterDefinition()));
}
break;
}
}
}
}
/**
* Called when getters and setters are to be kept together in pairs. Searches the list of entries
* for any getter/setter methods that matches this getter method. Normally there is only one
* setter per getter, but one could have a "getXXX", "isXXX" and "setXXX" trio which need to be
* related. In this case, the first getter encountered finds the other getter and setter and the
* three will be emitted in that order.
*
* @param possibleMethods entry list, possibly containing the corresponding setter for this
* getter.
* @param settings
*/
public void determineSetter(
final List<ClassContentsEntry> possibleMethods, RearrangerSettings settings) {
if (!isGetter()) // wasted assertion, already checked before calling
{
return;
}
final PsiMethod thisMethod = (PsiMethod) myEnd;
String thisProperty = MethodUtil.getPropertyName(thisMethod);
if (isGetter() && !myKeptWithProperty) {
if (settings.isKeepGettersSettersWithProperty()) {
hookGetterToProperty(possibleMethods);
}
}
for (ClassContentsEntry o : possibleMethods) {
if (o instanceof RelatableEntry) {
MethodEntry me = (MethodEntry) o;
// don't use a setter twice (could be two methods which both look like getters; assign the
// setter
// to only one of them.) Also, associate all getter/setter methods for the same property
// with the
// first one encountered.
if ((me.isSetter() || me.isGetter())
&& me.myCorrespondingGetterSetters.size() == 0
&& me != this) {
PsiMethod m = (PsiMethod) me.myEnd;
String otherProperty = MethodUtil.getPropertyName(m);
if (thisProperty.equals(otherProperty)) {
LOG.debug(
"method " + thisMethod.toString() + " is getter; its setter is " + m.toString());
// place getters ahead of setters
if (me.isGetter()) {
myCorrespondingGetterSetters.add(0, me);
// clear the getter flag and set the setter flag; this causes the method to be emitted
// under the first getter encountered.
me.setGetter(false);
me.setSetter(true);
} else {
myCorrespondingGetterSetters.add(me);
}
me.myCorrespondingGetterSetters.add(this);
}
}
}
}
}
public JLabel getPopupEntryText(RearrangerSettings settings) {
StringBuffer name = new StringBuffer(80);
PsiMethod m = (PsiMethod) myEnd;
if (m.getReturnTypeElement() != null && !settings.isShowTypeAfterMethod()) {
name.append(m.getReturnTypeElement().getText());
name.append(' ');
}
name.append(m.getName());
PsiParameterList plist = m.getParameterList();
if (settings.isShowParameterNames() || settings.isShowParameterTypes()) {
if (plist != null) {
name.append("(");
for (int i = 0; i < plist.getParameters().length; i++) {
if (i > 0) {
name.append(", ");
}
if (settings.isShowParameterTypes()) {
String modifiers = plist.getParameters()[i].getModifierList().getText();
if (modifiers.length() > 0) {
name.append(modifiers);
name.append(' ');
}
name.append(plist.getParameters()[i].getTypeElement().getText());
if (settings.isShowParameterNames()) {
name.append(' ');
}
}
if (settings.isShowParameterNames()) {
name.append(plist.getParameters()[i].getName());
}
}
name.append(")");
}
}
if (m.getReturnTypeElement() != null && settings.isShowTypeAfterMethod()) {
name.append(": ");
name.append(m.getReturnTypeElement().getText());
}
return new JLabel(name.toString());
}
/**
* If setting indicates, move all overloaded methods (of the same name) adjacent with the first
* encountered. Sort in the configured order (original order, or by number of parameters).
*/
public static void handleOverloadedMethods(
List<ClassContentsEntry> contents, RearrangerSettings settings) {
if (!settings.isKeepOverloadedMethodsTogether()) return;
/**
* first, detect overloaded methods and move them to the first method's list of overloaded
* methods. Make two passes, first for extracted methods, then for non-extracted methods. This
* will organize any overloaded methods for extracted methods with them (as opposed to whichever
* was seen first.)
*/
cullOverloadedMethods(contents, true);
LOG.debug("entered handleOverloadedMethods(): move overloaded methods together");
cullOverloadedMethods(contents, false);
List<ClassContentsEntry> copy = new ArrayList<ClassContentsEntry>(contents);
for (ClassContentsEntry rangeEntry : copy) {
if (rangeEntry instanceof RelatableEntry) {
MethodEntry current = (MethodEntry) rangeEntry;
if (current.myOverloadedMethods.size() > 0) {
List<MethodEntry> newList =
new ArrayList<MethodEntry>(current.myOverloadedMethods.size() + 1);
newList.add(current);
/**
* we are looking at the head of a list of overloaded methods. We need to sort the list if
* necessary and, if the head of the list has changed, replace it in the contents array.
*/
switch (settings.getOverloadedOrder()) {
case RearrangerSettings.OVERLOADED_ORDER_RETAIN_ORIGINAL:
// list is already in original order, except perhaps that the top-most extracted
// method
// comes first (if there is one).
newList.addAll(current.myOverloadedMethods);
break;
case RearrangerSettings.OVERLOADED_ORDER_ASCENDING_PARAMETERS:
case RearrangerSettings.OVERLOADED_ORDER_DESCENDING_PARAMETERS:
for (MethodEntry entry : current.myOverloadedMethods) {
boolean inserted = false;
for (int index = 0; index < newList.size(); index++) {
MethodEntry me = newList.get(index);
if (settings.getOverloadedOrder()
== RearrangerSettings.OVERLOADED_ORDER_ASCENDING_PARAMETERS
? me.getnParameters() > entry.getnParameters()
: me.getnParameters() < entry.getnParameters()) {
newList.add(index, entry);
inserted = true;
break;
}
}
if (!inserted) {
newList.add(entry);
}
}
break;
}
current.myOverloadedMethods.clear();
/**
* if the head of the arraylist is not the same as "current", then the sort operation
* moved another method to the head of the list. Replace that in the contents array. Then
* assign a new ordered list.
*/
int index = contents.indexOf(current);
if (newList.get(0) != current) {
contents.set(index, ((MethodEntry) newList.get(0)));
}
/** insert the remaining overloaded methods after the current entry. */
newList.remove(0);
for (int j = 0; j < newList.size(); j++) {
contents.add(index + j + 1, ((MethodEntry) newList.get(j)));
}
}
}
}
}