KickJava   Java API By Example, From Geeks To Geeks.

Java > Open Source Codes > org > netbeans > modules > refactoring > java > SafeDeleteRefactoringElement


1 /*
2  * The contents of this file are subject to the terms of the Common Development
3  * and Distribution License (the License). You may not use this file except in
4  * compliance with the License.
5  *
6  * You can obtain a copy of the License at http://www.netbeans.org/cddl.html
7  * or http://www.netbeans.org/cddl.txt.
8  *
9  * When distributing Covered Code, include this CDDL Header Notice in each file
10  * and include the License file at http://www.netbeans.org/cddl.txt.
11  * If applicable, add the following below the CDDL Header, with the fields
12  * enclosed by brackets [] replaced by your own identifying information:
13  * "Portions Copyrighted [year] [name of copyright owner]"
14  *
15  * The Original Software is NetBeans. The Initial Developer of the Original
16  * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
17  * Microsystems, Inc. All Rights Reserved.
18  */
19 package org.netbeans.modules.refactoring.java;
20
21 import com.sun.source.tree.CompilationUnitTree;
22 import java.io.BufferedReader JavaDoc;
23 import java.io.FileNotFoundException JavaDoc;
24 import java.io.IOException JavaDoc;
25 import java.io.InputStreamReader JavaDoc;
26 import java.io.OutputStream JavaDoc;
27 import java.io.PrintWriter JavaDoc;
28 import java.text.MessageFormat JavaDoc;
29 import java.util.HashMap JavaDoc;
30 import java.util.Iterator JavaDoc;
31 import java.util.List JavaDoc;
32 import java.util.Map JavaDoc;
33 import java.util.Set JavaDoc;
34 import javax.lang.model.element.Element;
35 import org.netbeans.api.java.source.ElementHandle;
36 import org.netbeans.modules.refactoring.spi.SimpleRefactoringElementImpl;
37 import org.openide.ErrorManager;
38 import org.openide.filesystems.FileLock;
39 import org.openide.filesystems.FileObject;
40 import org.openide.loaders.DataObject;
41 import org.openide.loaders.DataObjectNotFoundException;
42 import org.openide.text.PositionBounds;
43 import org.openide.util.NbBundle;
44
45 /**
46  * The RefactoringElement used by SafeDeleteRefactoringPlugin
47  * @author Bharath Ravikumar, Jan Becicka
48  */
49 public class SafeDeleteRefactoringElement extends SimpleRefactoringElementImpl {
50     
51     private final String JavaDoc text;
52     
53     private ElementHandle refactoredElement;
54     
55 // private ExternalChange extChange;
56
57     public SafeDeleteRefactoringElement(ElementHandle refactoredElementObj) {
58         this.refactoredElement = refactoredElementObj;
59         if (true) {
60 // extChange = new ResourceDeletionChange((CompilationUnitTree) refactoredElement);
61 // FileObject fileObject = JavaModel.getFileObject((CompilationUnitTree) refactoredElement);
62 // text = NbBundle.getMessage(SafeDeleteRefactoringElement.class, "TXT_SafeDel_Delete", fileObject.getNameExt());
63 text = "test";
64         } else {
65 // if (refactoredElement instanceof NamedElement) {
66 // text = NbBundle.getMessage(SafeDeleteRefactoringElement.class, "TXT_SafeDel_Delete", ((NamedElement) refactoredElement).getName());
67 // } else {
68 String JavaDoc msg = NbBundle.getMessage(SafeDeleteRefactoringElement.class, "TXT_SafeDel_Delete");
69             text = MessageFormat.format(msg, new Object JavaDoc[] {refactoredElement});
70             }
71     }
72     
73     public void performChange() {
74 // if (refactoredElement instanceof CompilationUnitTree) {
75 // //If a resource has been passed, the absence of any underlying child element has
76 // //already been ensured.It is hence safe to directly delete it.
77 // extChange.performExternalChange();
78 // JavaMetamodel.getManager().registerUndoElement(extChange);
79 // return;
80 // } else if (refactoredElement instanceof org.netbeans.jmi.javamodel.LocalVariable) {
81 // Object comp = refactoredElement.refImmediateComposite();
82 // if (comp instanceof LocalVarDeclaration) {
83 // List variables = ((LocalVarDeclaration) comp).getVariables();
84 // if (variables.size() == 1) {
85 // refactoredElement = (Element) comp;
86 // }
87 // }
88 // }
89 // refactoredElement.refDelete();
90 // return;
91 }
92     
93     public String JavaDoc getText() {
94         return text;
95     }
96     
97     public PositionBounds getPosition() {
98 // return JavaMetamodel.getManager().getElementPosition(refactoredElement);
99 return null;
100     }
101     
102     public FileObject getParentFile() {
103         return null;
104 // return JavaMetamodel.getManager().getFileObject(refactoredElement.getResource());
105 }
106     
107     public Object JavaDoc getComposite() {
108         return refactoredElement;
109     }
110     
111     public String JavaDoc getDisplayText() {
112         return getText();
113     }
114     
115 // private static class ResourceDeletionChange implements ExternalChange {
116 //
117 // private DataObject primaryDataObj;
118 //
119 // private FileObject parentFileObj;
120 //
121 // private Resource refactoredResource;
122 //
123 // private Map fileObjMap = new HashMap();
124 //
125 // /**
126 // * This flag indicates whether the change is being executed the first time
127 // * or if the current invocation is a result of a Refactoring-Redo.
128 // * This is needed to store the correct version of the source text for
129 // * an Undo
130 // */
131 // private boolean initialExecution = true;
132 //
133 // private ResourceDeletionChange(Resource refactoredResource) {
134 // this.refactoredResource = refactoredResource;
135 // try {
136 // backupFileObjects(refactoredResource);
137 // } catch (DataObjectNotFoundException ex) {
138 // ErrorManager.getDefault().notify(ex);
139 // }
140 // }
141 //
142 // public void performExternalChange() {
143 // try {
144 // //Indicates whether this is the first invocation of the external change
145 // //For the first invocation, the data would've been backed up in the
146 // //constructor (by which time the containing classes would not have been
147 // //deleted.So, that's the right time to do the backup.)
148 // if(!initialExecution)
149 // backupFileObjects(refactoredResource); //Record current state
150 // else
151 // initialExecution = false;
152 //
153 // //Now do the deletion of data object
154 // primaryDataObj.delete();
155 // refactoredResource.refDelete();
156 // } catch (IOException exception) {
157 // ErrorManager.getDefault().notify(exception);
158 // return;
159 // }
160 // }
161 //
162 // public void undoExternalChange() {
163 // try {
164 // populateFileObjects();
165 // } catch (DataObjectNotFoundException notFndEx) {
166 // ErrorManager.getDefault().notify(notFndEx);
167 // } catch (IOException ioEx) {
168 // ErrorManager.getDefault().notify(ioEx);
169 // }
170 // }
171 //
172 // private void backupFileObjects(final Resource refactoredResource) throws DataObjectNotFoundException {
173 // FileObject javaFileObject = JavaModel.getFileObject((Resource) refactoredResource);
174 // //set the parent folder's file object
175 // parentFileObj = javaFileObject.getParent();
176 // primaryDataObj = DataObject.find(javaFileObject);
177 // Set fileObjSet = primaryDataObj.files();
178 // Iterator fileObjIterator = fileObjSet.iterator();
179 // while (fileObjIterator.hasNext()) {
180 // FileObject fileObj = (FileObject) fileObjIterator.next();
181 // String fileName = fileObj.getNameExt();
182 // try {
183 // String fileContent = readFileContent(fileObj);
184 // fileObjMap.put(fileName, fileContent);
185 // } catch (FileNotFoundException ex) {
186 // ErrorManager.getDefault().notify(ex);
187 // } catch (IOException ex) {
188 // ErrorManager.getDefault().notify(ex);
189 // }
190 // }
191 // }
192 //
193 // private String readFileContent(FileObject fileObject) throws FileNotFoundException, IOException {
194 // Resource resource = JavaModel.getResource(fileObject);
195 // if (resource != null)
196 // return resource.getSourceText();
197 // else {
198 // StringBuffer buffer = new StringBuffer();
199 // BufferedReader bis = new BufferedReader(new InputStreamReader(fileObject.getInputStream()));
200 // String sourceString = null;
201 // while( (sourceString = bis.readLine()) != null)
202 // buffer.append(sourceString );
203 //
204 // bis.close();
205 // return buffer.toString();
206 // }
207 // }
208 //
209 // private void populateFileObjects() throws DataObjectNotFoundException, IOException {
210 // Iterator fileObjIte = fileObjMap.keySet().iterator();
211 // FileObject fObj = null;
212 // while (fileObjIte.hasNext()) {
213 // String fileName = fileObjIte.next().toString();
214 // //Generate a key to retrieve this file later.
215 // fObj = parentFileObj.createData(fileName);
216 // writeToFile(fObj, (String) fileObjMap.get(fileName));
217 //
218 // //Partial fix for issue 74489:No CC on safe-deleted class after undo
219 // //Force the JavaMetamodel to re-parse the newly
220 // //created file and update the JMM. Fix is still partial.
221 // JavaMetamodel.getManager().addModified(fObj);
222 // JavaMetamodel.getDefaultRepository().beginTrans(true);
223 // JavaMetamodel.getDefaultRepository().endTrans(false);
224 // }
225 // primaryDataObj = DataObject.find(fObj);
226 // refactoredResource = JavaMetamodel.getManager().getResource(primaryDataObj.getPrimaryFile());
227 // }
228 //
229 // private void writeToFile(FileObject fileObject, String fileContent) throws IOException {
230 // FileLock fileLock = fileObject.lock();
231 // try {
232 // OutputStream fOS = fileObject.getOutputStream(fileLock);
233 // PrintWriter writer = new PrintWriter(fOS);
234 // writer.print(fileContent);
235 // writer.close();
236 // } finally{
237 // if(fileLock != null)
238 // fileLock.releaseLock();
239 // }
240 // }
241 // }
242 }
243
Popular Tags