001: /*
002: * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
003: *
004: * Copyright 1997-2007 Sun Microsystems, Inc. All rights reserved.
005: *
006: * The contents of this file are subject to the terms of either the GNU
007: * General Public License Version 2 only ("GPL") or the Common
008: * Development and Distribution License("CDDL") (collectively, the
009: * "License"). You may not use this file except in compliance with the
010: * License. You can obtain a copy of the License at
011: * http://www.netbeans.org/cddl-gplv2.html
012: * or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the
013: * specific language governing permissions and limitations under the
014: * License. When distributing the software, include this License Header
015: * Notice in each file and include the License file at
016: * nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this
017: * particular file as subject to the "Classpath" exception as provided
018: * by Sun in the GPL Version 2 section of the License file that
019: * accompanied this code. If applicable, add the following below the
020: * License Header, with the fields enclosed by brackets [] replaced by
021: * your own identifying information:
022: * "Portions Copyrighted [year] [name of copyright owner]"
023: *
024: * Contributor(s):
025: *
026: * The Original Software is NetBeans. The Initial Developer of the Original
027: * Software is Sun Microsystems, Inc. Portions Copyright 1997-2006 Sun
028: * Microsystems, Inc. All Rights Reserved.
029: *
030: * If you wish your version of this file to be governed by only the CDDL
031: * or only the GPL Version 2, indicate your decision by adding
032: * "[Contributor] elects to include this software in this distribution
033: * under the [CDDL or GPL Version 2] license." If you do not indicate a
034: * single choice of license, a recipient has the option to distribute
035: * your version of this file under either the CDDL, the GPL Version 2 or
036: * to extend the choice of license to its licensees as provided above.
037: * However, if you add GPL Version 2 code and therefore, elected the GPL
038: * Version 2 license, then the option applies only if the new code is
039: * made subject to such option by the copyright holder.
040: */
041:
042: package org.netbeans.spi.project.support;
043:
044: import java.io.File;
045: import java.io.IOException;
046: import java.util.ArrayList;
047: import java.util.List;
048: import org.netbeans.api.project.Project;
049: import org.netbeans.spi.project.CopyOperationImplementation;
050: import org.netbeans.spi.project.DataFilesProviderImplementation;
051: import org.netbeans.spi.project.DeleteOperationImplementation;
052: import org.netbeans.spi.project.MoveOperationImplementation;
053: import org.openide.filesystems.FileObject;
054:
055: /**
056: * Allows gathering information for various project operations.
057: *
058: * @author Jan Lahoda
059: * @since 1.7
060: */
061: public final class ProjectOperations {
062:
063: private ProjectOperations() {
064: }
065:
066: /**Return list of files that are considered metadata files and folders for the given project.
067: * Returns meaningful values only if some of the <code>is*Supported</code> methods
068: * return <code>true</code>.
069: *
070: * @param prj project to test
071: * @return list of metadata files/folders
072: */
073: public static List<FileObject> getMetadataFiles(Project prj) {
074: List<FileObject> result = new ArrayList<FileObject>();
075:
076: for (DataFilesProviderImplementation i : prj.getLookup()
077: .lookupAll(DataFilesProviderImplementation.class)) {
078: result.addAll(i.getMetadataFiles());
079: assert !result.contains(null) : "Nulls in " + result
080: + " from " + i;
081: }
082:
083: return result;
084: }
085:
086: /**Return list of files that are considered source files and folders for the given project.
087: * Returns meaningful values only if some of the <code>is*Supported</code> methods
088: * return <code>true</code>.
089: *
090: * @param prj project to test
091: * @return list of data files/folders
092: */
093: public static List<FileObject> getDataFiles(Project prj) {
094: List<FileObject> result = new ArrayList<FileObject>();
095:
096: for (DataFilesProviderImplementation i : prj.getLookup()
097: .lookupAll(DataFilesProviderImplementation.class)) {
098: result.addAll(i.getDataFiles());
099: assert !result.contains(null) : "Nulls in " + result
100: + " from " + i;
101: }
102:
103: return result;
104: }
105:
106: /**Test whether the delete operation is supported on the given project.
107: *
108: * @param prj project to test
109: * @return <code>true</code> if the project supports delete operation,
110: * <code>false</code> otherwise
111: */
112: public static boolean isDeleteOperationSupported(Project prj) {
113: return prj.getLookup().lookup(
114: DeleteOperationImplementation.class) != null;
115: }
116:
117: /**Notification that the project is about to be deleted.
118: * Should be called immediately before the project is deleted.
119: *
120: * The project is supposed to do all required cleanup to allow the project to be deleted.
121: *
122: * @param prj project to notify
123: * @throws IOException is some error occurs
124: */
125: public static void notifyDeleting(Project prj) throws IOException {
126: for (DeleteOperationImplementation i : prj.getLookup()
127: .lookupAll(DeleteOperationImplementation.class)) {
128: i.notifyDeleting();
129: }
130: }
131:
132: /**Notification that the project has been deleted.
133: * Should be called immediately after the project is deleted.
134: *
135: * @param prj project to notify
136: * @throws IOException is some error occurs
137: */
138: public static void notifyDeleted(Project prj) throws IOException {
139: for (DeleteOperationImplementation i : prj.getLookup()
140: .lookupAll(DeleteOperationImplementation.class)) {
141: i.notifyDeleted();
142: }
143: }
144:
145: /**Test whether the copy operation is supported on the given project.
146: *
147: * @param prj project to test
148: * @return <code>true</code> if the project supports the copy operation,
149: * <code>false</code> otherwise
150: */
151: public static boolean isCopyOperationSupported(Project prj) {
152: return prj.getLookup()
153: .lookup(CopyOperationImplementation.class) != null;
154: }
155:
156: /**Notification that the project is about to be copyied.
157: * Should be called immediatelly before the project is copied.
158: *
159: * The project is supposed to do all required cleanup to allow the project to be copied.
160: *
161: * @param prj project to notify
162: * @throws IOException is some error occurs
163: */
164: public static void notifyCopying(Project prj) throws IOException {
165: for (CopyOperationImplementation i : prj.getLookup().lookupAll(
166: CopyOperationImplementation.class)) {
167: i.notifyCopying();
168: }
169: }
170:
171: /**Notification that the project has been copied.
172: * Should be called immediatelly after the project is copied.
173: *
174: * The project is supposed to do all necessary fixes to the project's structure to
175: * form a valid project.
176: *
177: * Both original and newly created project (copy) are notified, in this order.
178: *
179: * @param original original project
180: * @param nue new project (copy)
181: * @param originalPath the project folder of the original project (for consistency with notifyMoved)
182: * @param name new name of the project
183: * @throws IOException is some error occurs
184: */
185: public static void notifyCopied(Project original, Project nue,
186: File originalPath, String name) throws IOException {
187: for (CopyOperationImplementation i : original.getLookup()
188: .lookupAll(CopyOperationImplementation.class)) {
189: i.notifyCopied(null, originalPath, name);
190: }
191: for (CopyOperationImplementation i : nue.getLookup().lookupAll(
192: CopyOperationImplementation.class)) {
193: i.notifyCopied(original, originalPath, name);
194: }
195: }
196:
197: /**Notification that the project is about to be moved.
198: * Should be called immediately before the project is moved.
199: *
200: * The project is supposed to do all required cleanup to allow the project to be moved.
201: *
202: * @param prj project to notify
203: * @throws IOException is some error occurs
204: */
205: public static void notifyMoving(Project prj) throws IOException {
206: for (MoveOperationImplementation i : prj.getLookup().lookupAll(
207: MoveOperationImplementation.class)) {
208: i.notifyMoving();
209: }
210: }
211:
212: /**Notification that the project has been moved.
213: * Should be called immediatelly after the project is moved.
214: *
215: * The project is supposed to do all necessary fixes to the project's structure to
216: * form a valid project.
217: *
218: * Both original and moved project are notified, in this order.
219: *
220: * @param original original project
221: * @param nue moved project
222: * @param originalPath the project folder of the original project
223: * @param name new name of the project
224: * @throws IOException is some error occurs
225: */
226: public static void notifyMoved(Project original, Project nue,
227: File originalPath, String name) throws IOException {
228: for (MoveOperationImplementation i : original.getLookup()
229: .lookupAll(MoveOperationImplementation.class)) {
230: i.notifyMoved(null, originalPath, name);
231: }
232: for (MoveOperationImplementation i : nue.getLookup().lookupAll(
233: MoveOperationImplementation.class)) {
234: i.notifyMoved(original, originalPath, name);
235: }
236: }
237:
238: /**
239: * Tests whether the move or rename operations are supported on the given project.
240: *
241: * @param prj project to test
242: * @return <code>true</code> if the project supports the move operation,
243: * <code>false</code> otherwise
244: */
245: public static boolean isMoveOperationSupported(Project prj) {
246: return prj.getLookup()
247: .lookup(MoveOperationImplementation.class) != null;
248: }
249:
250: }
|