net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/CopyElementsOperation.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2003 IBM Corporation and others.
   3  * All rights reserved. This program and the accompanying materials
   4  * are made available under the terms of the Common Public License v1.0
   5  * which accompanies this distribution, and is available at
   6  * http://www.eclipse.org/legal/cpl-v10.html
   7  *
   8  * Contributors:
   9  *     IBM Corporation - initial API and implementation
  10  *******************************************************************************/
  11 package net.sourceforge.phpdt.internal.core;
  12
  13 import java.util.HashMap;
  14 import java.util.Map;
  15
  16 import net.sourceforge.phpdt.core.ICompilationUnit;
  17 import net.sourceforge.phpdt.core.IJavaElement;
  18 import net.sourceforge.phpdt.core.IJavaModelStatus;
  19 import net.sourceforge.phpdt.core.IJavaModelStatusConstants;
  20 import net.sourceforge.phpdt.core.IMember;
  21 import net.sourceforge.phpdt.core.IParent;
  22 import net.sourceforge.phpdt.core.JavaModelException;
  23 import net.sourceforge.phpdt.core.jdom.DOMFactory;
  24 import net.sourceforge.phpdt.core.jdom.IDOMCompilationUnit;
  25 import net.sourceforge.phpdt.core.jdom.IDOMNode;
  26
  27 /**
  28  * This operation copies/moves a collection of elements from their current
  29  * container to a new container, optionally renaming the
  30  * elements.
  31  * <p>Notes:<ul>
  32  *    <li>If there is already an element with the same name in
  33  *    the new container, the operation either overwrites or aborts,
  34  *    depending on the collision policy setting. The default setting is
  35  *        abort.
  36  *
  37  *    <li>When constructors are copied to a type, the constructors
  38  *    are automatically renamed to the name of the destination
  39  *    type.
  40  *
  41  *        <li>When main types are renamed (move within the same parent),
  42  *              the compilation unit and constructors are automatically renamed
  43  *
  44  *    <li>The collection of elements being copied must all share the
  45  *    same type of container (for example, must all be type members).
  46  *
  47  *    <li>The elements are inserted in the new container in the order given.
  48  *
  49  *    <li>The elements can be positioned in the new container - see #setInsertBefore.
  50  *    By default, the elements are inserted based on the default positions as specified in
  51  *      the creation operation for that element type.
  52  *
  53  *    <li>This operation can be used to copy and rename elements within
  54  *    the same container.
  55  *
  56  *    <li>This operation only copies elements contained within compilation units.
  57  * </ul>
  58  *
  59  */
  60 public class CopyElementsOperation extends MultiOperation {
  61
  62
  63         private Map fSources = new HashMap();
  64 /**
  65  * When executed, this operation will copy the given elements to the
  66  * given containers.  The elements and destination containers must be in
  67  * the correct order. If there is > 1 destination, the number of destinations
  68  * must be the same as the number of elements being copied/moved/renamed.
  69  */
  70 public CopyElementsOperation(IJavaElement[] elementsToCopy, IJavaElement[] destContainers, boolean force) {
  71         super(elementsToCopy, destContainers, force);
  72 }
  73 /**
  74  * When executed, this operation will copy the given elements to the
  75  * given container.
  76  */
  77 public CopyElementsOperation(IJavaElement[] elementsToCopy, IJavaElement destContainer, boolean force) {
  78         this(elementsToCopy, new IJavaElement[]{destContainer}, force);
  79 }
  80 /**
  81  * Returns the <code>String</code> to use as the main task name
  82  * for progress monitoring.
  83  */
  84 protected String getMainTaskName() {
  85         return Util.bind("operation.copyElementProgress"); //$NON-NLS-1$
  86 }
  87 /**
  88  * Returns the nested operation to use for processing this element
  89  */
  90 protected JavaModelOperation getNestedOperation(IJavaElement element) {
  91         return null;
  92 //      try {
  93 //              IJavaElement dest = getDestinationParent(element);
  94 //              switch (element.getElementType()) {
  95 //                      case IJavaElement.PACKAGE_DECLARATION :
  96 //                              return new CreatePackageDeclarationOperation(element.getElementName(), (ICompilationUnit) dest);
  97 //                      case IJavaElement.IMPORT_DECLARATION :
  98 //                              return new CreateImportOperation(element.getElementName(), (ICompilationUnit) dest);
  99 //                      case IJavaElement.TYPE :
 100 //                              if (isRenamingMainType(element, dest)) {
 101 //                                      return new RenameResourceElementsOperation(new IJavaElement[] {dest}, new IJavaElement[] {dest.getParent()}, new String[]{getNewNameFor(element) + ".php"}, fForce); //$NON-NLS-1$
 102 //                              } else {
 103 //                                      return new CreateTypeOperation(dest, getSourceFor(element) + Util.LINE_SEPARATOR, fForce);
 104 //                              }
 105 //                      case IJavaElement.METHOD :
 106 //                              return new CreateMethodOperation((IType) dest, getSourceFor(element) + Util.LINE_SEPARATOR, fForce);
 107 //                      case IJavaElement.FIELD :
 108 //                              return new CreateFieldOperation((IType) dest, getSourceFor(element) + Util.LINE_SEPARATOR, fForce);
 109 //                      case IJavaElement.INITIALIZER :
 110 //                              return new CreateInitializerOperation((IType) dest, getSourceFor(element) + Util.LINE_SEPARATOR);
 111 //                      default :
 112 //                              return null;
 113 //              }
 114 //      } catch (JavaModelException npe) {
 115 //              return null;
 116 //      }
 117 }
 118 /**
 119  * Returns the cached source for this element or compute it if not already cached.
 120  */
 121 private String getSourceFor(IJavaElement element) throws JavaModelException {
 122         String source = (String) fSources.get(element);
 123         if (source == null && element instanceof IMember) {
 124                 IMember member = (IMember)element;
 125                 ICompilationUnit cu = member.getCompilationUnit();
 126                 String cuSource = cu.getSource();
 127                 IDOMCompilationUnit domCU = new DOMFactory().createCompilationUnit(cuSource, cu.getElementName());
 128                 IDOMNode node = ((JavaElement)element).findNode(domCU);
 129                 source = new String(node.getCharacters());
 130                 fSources.put(element, source);
 131         }
 132         return source;
 133 }
 134 /**
 135  * Returns <code>true</code> if this element is the main type of its compilation unit.
 136  */
 137 protected boolean isRenamingMainType(IJavaElement element, IJavaElement dest) {
 138         if ((isRename() || getNewNameFor(element) != null)
 139                 && dest.getElementType() == IJavaElement.COMPILATION_UNIT) {
 140                 String typeName = dest.getElementName();
 141                 typeName = typeName.substring(0, typeName.length() - 5);
 142                 return element.getElementName().equals(typeName) && element.getParent().equals(dest);
 143         }
 144         return false;
 145 }
 146 /**
 147  * Copy/move the element from the source to destination, renaming
 148  * the elements as specified, honoring the collision policy.
 149  *
 150  * @exception JavaModelException if the operation is unable to
 151  * be completed
 152  */
 153 protected void processElement(IJavaElement element) throws JavaModelException {
 154         JavaModelOperation op = getNestedOperation(element);
 155         boolean createElementInCUOperation =op instanceof CreateElementInCUOperation;
 156         if (op == null) {
 157                 return;
 158         }
 159         if (createElementInCUOperation) {
 160                 IJavaElement sibling = (IJavaElement) fInsertBeforeElements.get(element);
 161                 if (sibling != null) {
 162                         ((CreateElementInCUOperation) op).setRelativePosition(sibling, CreateElementInCUOperation.INSERT_BEFORE);
 163                 } else
 164                         if (isRename()) {
 165                                 IJavaElement anchor = resolveRenameAnchor(element);
 166                                 if (anchor != null) {
 167                                         ((CreateElementInCUOperation) op).setRelativePosition(anchor, CreateElementInCUOperation.INSERT_AFTER); // insert after so that the anchor is found before when deleted below
 168                                 }
 169                         }
 170                 String newName = getNewNameFor(element);
 171                 if (newName != null) {
 172                         ((CreateElementInCUOperation) op).setAlteredName(newName);
 173                 }
 174         }
 175         executeNestedOperation(op, 1);
 176
 177         JavaElement destination = (JavaElement) getDestinationParent(element);
 178         ICompilationUnit unit= destination.getCompilationUnit();
 179         if (!unit.isWorkingCopy()) {
 180                 unit.close();
 181         }
 182
 183         if (createElementInCUOperation && isMove() && !isRenamingMainType(element, destination)) {
 184                 DeleteElementsOperation deleteOp = new DeleteElementsOperation(new IJavaElement[] { element }, fForce);
 185                 executeNestedOperation(deleteOp, 1);
 186         }
 187 }
 188 /**
 189  * Returns the anchor used for positioning in the destination for
 190  * the element being renamed. For renaming, if no anchor has
 191  * explicitly been provided, the element is anchored in the same position.
 192  */
 193 private IJavaElement resolveRenameAnchor(IJavaElement element) throws JavaModelException {
 194         IParent parent = (IParent) element.getParent();
 195         IJavaElement[] children = parent.getChildren();
 196         for (int i = 0; i < children.length; i++) {
 197                 IJavaElement child = children[i];
 198                 if (child.equals(element)) {
 199                         return child;
 200                 }
 201         }
 202         return null;
 203 }
 204 /**
 205  * Possible failures:
 206  * <ul>
 207  *  <li>NO_ELEMENTS_TO_PROCESS - no elements supplied to the operation
 208  *      <li>INDEX_OUT_OF_BOUNDS - the number of renamings supplied to the operation
 209  *              does not match the number of elements that were supplied.
 210  * </ul>
 211  */
 212 protected IJavaModelStatus verify() {
 213         IJavaModelStatus status = super.verify();
 214         if (!status.isOK()) {
 215                 return status;
 216         }
 217         if (fRenamingsList != null && fRenamingsList.length != fElementsToProcess.length) {
 218                 return new JavaModelStatus(IJavaModelStatusConstants.INDEX_OUT_OF_BOUNDS);
 219         }
 220         return JavaModelStatus.VERIFIED_OK;
 221 }
 222 /**
 223  * @see MultiOperation
 224  *
 225  * Possible failure codes:
 226  * <ul>
 227  *
 228  *      <li>ELEMENT_DOES_NOT_EXIST - <code>element</code> or its specified destination is
 229  *              is <code>null</code> or does not exist. If a <code>null</code> element is
 230  *              supplied, no element is provided in the status, otherwise, the non-existant element
 231  *              is supplied in the status.
 232  *      <li>INVALID_ELEMENT_TYPES - <code>element</code> is not contained within a compilation unit.
 233  *              This operation only operates on elements contained within compilation units.
 234  *  <li>READ_ONLY - <code>element</code> is read only.
 235  *      <li>INVALID_DESTINATION - The destination parent specified for <code>element</code>
 236  *              is of an incompatible type. The destination for a package declaration or import declaration must
 237  *              be a compilation unit; the destination for a type must be a type or compilation
 238  *              unit; the destinaion for any type member (other than a type) must be a type. When
 239  *              this error occurs, the element provided in the operation status is the <code>element</code>.
 240  *      <li>INVALID_NAME - the new name for <code>element</code> does not have valid syntax.
 241  *      In this case the element and name are provided in the status.
 242
 243  * </ul>
 244  */
 245 protected void verify(IJavaElement element) throws JavaModelException {
 246         if (element == null || !element.exists())
 247                 error(IJavaModelStatusConstants.ELEMENT_DOES_NOT_EXIST, element);
 248
 249         if (element.getElementType() < IJavaElement.TYPE)
 250                 error(IJavaModelStatusConstants.INVALID_ELEMENT_TYPES, element);
 251
 252         if (element.isReadOnly())
 253                 error(IJavaModelStatusConstants.READ_ONLY, element);
 254
 255         IJavaElement dest = getDestinationParent(element);
 256         verifyDestination(element, dest);
 257         verifySibling(element, dest);
 258         if (fRenamingsList != null) {
 259                 verifyRenaming(element);
 260         }
 261 }
 262 }