001: /*******************************************************************************
002: * Copyright (c) 2000, 2006 IBM Corporation and others.
003: * All rights reserved. This program and the accompanying materials
004: * are made available under the terms of the Eclipse Public License v1.0
005: * which accompanies this distribution, and is available at
006: * http://www.eclipse.org/legal/epl-v10.html
007: *
008: * Contributors:
009: * IBM Corporation - initial API and implementation
010: *******************************************************************************/package org.eclipse.jdt.internal.corext.dom;
011:
012: import java.util.Iterator;
013: import java.util.List;
014:
015: import org.eclipse.text.edits.TextEditGroup;
016:
017: import org.eclipse.jdt.core.dom.AST;
018: import org.eclipse.jdt.core.dom.ASTNode;
019: import org.eclipse.jdt.core.dom.Annotation;
020: import org.eclipse.jdt.core.dom.AnnotationTypeDeclaration;
021: import org.eclipse.jdt.core.dom.AnnotationTypeMemberDeclaration;
022: import org.eclipse.jdt.core.dom.EnumConstantDeclaration;
023: import org.eclipse.jdt.core.dom.EnumDeclaration;
024: import org.eclipse.jdt.core.dom.FieldDeclaration;
025: import org.eclipse.jdt.core.dom.IExtendedModifier;
026: import org.eclipse.jdt.core.dom.MethodDeclaration;
027: import org.eclipse.jdt.core.dom.Modifier;
028: import org.eclipse.jdt.core.dom.SingleVariableDeclaration;
029: import org.eclipse.jdt.core.dom.TypeDeclaration;
030: import org.eclipse.jdt.core.dom.VariableDeclarationExpression;
031: import org.eclipse.jdt.core.dom.VariableDeclarationStatement;
032: import org.eclipse.jdt.core.dom.rewrite.ASTRewrite;
033: import org.eclipse.jdt.core.dom.rewrite.ListRewrite;
034:
035: /**
036: *
037: */
038: public class ModifierRewrite {
039:
040: public static final int VISIBILITY_MODIFIERS = Modifier.PUBLIC
041: | Modifier.PRIVATE | Modifier.PROTECTED;
042:
043: private ListRewrite fModifierRewrite;
044: private AST fAst;
045:
046: public static ModifierRewrite create(ASTRewrite rewrite,
047: ASTNode declNode) {
048: return new ModifierRewrite(rewrite, declNode);
049: }
050:
051: private ModifierRewrite(ASTRewrite rewrite, ASTNode declNode) {
052: fModifierRewrite = evaluateListRewrite(rewrite, declNode);
053: fAst = declNode.getAST();
054: }
055:
056: private ListRewrite evaluateListRewrite(ASTRewrite rewrite,
057: ASTNode declNode) {
058: switch (declNode.getNodeType()) {
059: case ASTNode.METHOD_DECLARATION:
060: return rewrite.getListRewrite(declNode,
061: MethodDeclaration.MODIFIERS2_PROPERTY);
062: case ASTNode.FIELD_DECLARATION:
063: return rewrite.getListRewrite(declNode,
064: FieldDeclaration.MODIFIERS2_PROPERTY);
065: case ASTNode.VARIABLE_DECLARATION_EXPRESSION:
066: return rewrite.getListRewrite(declNode,
067: VariableDeclarationExpression.MODIFIERS2_PROPERTY);
068: case ASTNode.VARIABLE_DECLARATION_STATEMENT:
069: return rewrite.getListRewrite(declNode,
070: VariableDeclarationStatement.MODIFIERS2_PROPERTY);
071: case ASTNode.SINGLE_VARIABLE_DECLARATION:
072: return rewrite.getListRewrite(declNode,
073: SingleVariableDeclaration.MODIFIERS2_PROPERTY);
074: case ASTNode.TYPE_DECLARATION:
075: return rewrite.getListRewrite(declNode,
076: TypeDeclaration.MODIFIERS2_PROPERTY);
077: case ASTNode.ENUM_DECLARATION:
078: return rewrite.getListRewrite(declNode,
079: EnumDeclaration.MODIFIERS2_PROPERTY);
080: case ASTNode.ANNOTATION_TYPE_DECLARATION:
081: return rewrite.getListRewrite(declNode,
082: AnnotationTypeDeclaration.MODIFIERS2_PROPERTY);
083: case ASTNode.ENUM_CONSTANT_DECLARATION:
084: return rewrite.getListRewrite(declNode,
085: EnumConstantDeclaration.MODIFIERS2_PROPERTY);
086: case ASTNode.ANNOTATION_TYPE_MEMBER_DECLARATION:
087: return rewrite
088: .getListRewrite(
089: declNode,
090: AnnotationTypeMemberDeclaration.MODIFIERS2_PROPERTY);
091: default:
092: throw new IllegalArgumentException(
093: "node has no modifiers: " + declNode.getClass().getName()); //$NON-NLS-1$
094: }
095: }
096:
097: public ListRewrite getModifierRewrite() {
098: return fModifierRewrite;
099: }
100:
101: public void setModifiers(int modfiers, TextEditGroup editGroup) {
102: internalSetModifiers(modfiers, -1, editGroup);
103: }
104:
105: public void setModifiers(int included, int excluded,
106: TextEditGroup editGroup) {
107: internalSetModifiers(included, included | excluded, editGroup);
108: }
109:
110: public void setVisibility(int visibilityFlags,
111: TextEditGroup editGroup) {
112: internalSetModifiers(visibilityFlags, VISIBILITY_MODIFIERS,
113: editGroup);
114: }
115:
116: public void copyAllModifiers(ASTNode otherDecl,
117: TextEditGroup editGroup) {
118: ListRewrite modifierList = evaluateListRewrite(fModifierRewrite
119: .getASTRewrite(), otherDecl);
120: List originalList = modifierList.getOriginalList();
121: if (originalList.isEmpty()) {
122: return;
123: }
124:
125: ASTNode copy = modifierList.createCopyTarget(
126: (ASTNode) originalList.get(0), (ASTNode) originalList
127: .get(originalList.size() - 1));
128: if (copy != null) {
129: fModifierRewrite.insertLast(copy, editGroup);
130: }
131: }
132:
133: public void copyAllAnnotations(ASTNode otherDecl,
134: TextEditGroup editGroup) {
135: ListRewrite modifierList = evaluateListRewrite(fModifierRewrite
136: .getASTRewrite(), otherDecl);
137: List originalList = modifierList.getOriginalList();
138:
139: for (Iterator iterator = originalList.iterator(); iterator
140: .hasNext();) {
141: IExtendedModifier modifier = (IExtendedModifier) iterator
142: .next();
143: if (modifier.isAnnotation()) {
144: fModifierRewrite.insertLast(fModifierRewrite
145: .getASTRewrite().createCopyTarget(
146: (Annotation) modifier), editGroup);
147: }
148: }
149: }
150:
151: private void internalSetModifiers(int modfiers,
152: int consideredFlags, TextEditGroup editGroup) {
153: // remove modifiers
154: int newModifiers = modfiers & consideredFlags;
155:
156: List originalList = fModifierRewrite.getOriginalList();
157: for (int i = 0; i < originalList.size(); i++) {
158: ASTNode curr = (ASTNode) originalList.get(i);
159: if (curr instanceof Modifier) {
160: int flag = ((Modifier) curr).getKeyword().toFlagValue();
161: if ((consideredFlags & flag) != 0) {
162: if ((newModifiers & flag) == 0) {
163: fModifierRewrite.remove(curr, editGroup);
164: }
165: newModifiers &= ~flag;
166: }
167: }
168: }
169:
170: // find last annotation
171: IExtendedModifier lastAnnotation = null;
172: List extendedList = fModifierRewrite.getRewrittenList();
173: for (int i = 0; i < extendedList.size(); i++) {
174: IExtendedModifier curr = (IExtendedModifier) extendedList
175: .get(i);
176: if (curr.isAnnotation())
177: lastAnnotation = curr;
178: }
179:
180: // add modifiers
181: List newNodes = ASTNodeFactory.newModifiers(fAst, newModifiers);
182: for (int i = 0; i < newNodes.size(); i++) {
183: Modifier curr = (Modifier) newNodes.get(i);
184: if ((curr.getKeyword().toFlagValue() & VISIBILITY_MODIFIERS) != 0) {
185: if (lastAnnotation != null)
186: fModifierRewrite.insertAfter(curr,
187: (ASTNode) lastAnnotation, editGroup);
188: else
189: fModifierRewrite.insertFirst(curr, editGroup);
190: } else {
191: fModifierRewrite.insertLast(curr, editGroup);
192: }
193: }
194: }
195: }
|