net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/PackageFragment.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.ArrayList;
  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.IJavaProject;
  19 import net.sourceforge.phpdt.core.IPackageFragment;
  20 import net.sourceforge.phpdt.core.IPackageFragmentRoot;
  21 import net.sourceforge.phpdt.core.JavaModelException;
  22
  23 import org.eclipse.core.resources.IContainer;
  24 import org.eclipse.core.resources.IResource;
  25 import org.eclipse.core.runtime.CoreException;
  26 import org.eclipse.core.runtime.IPath;
  27 import org.eclipse.core.runtime.IProgressMonitor;
  28 import org.eclipse.core.runtime.Path;
  29
  30
  31 /**
  32  * @see IPackageFragment
  33  */
  34 public class PackageFragment extends Openable implements IPackageFragment {
  35                 /**
  36          * Constant empty list of compilation units
  37          */
  38         protected static ICompilationUnit[] fgEmptyCompilationUnitList= new ICompilationUnit[] {};
  39 /**
  40  * Constructs a handle for a package fragment
  41  *
  42  * @see IPackageFragment
  43  */
  44 protected PackageFragment(IPackageFragmentRoot root, String name) {
  45         super(PACKAGE_FRAGMENT, root, name);
  46 }
  47 /**
  48  * Compute the children of this package fragment.
  49  *
  50  * <p>Package fragments which are folders recognize files based on the
  51  * type of the fragment
  52  * <p>Package fragments which are in a jar only recognize .class files (
  53  * @see JarPackageFragment).
  54  */
  55 protected boolean computeChildren(OpenableElementInfo info, IResource resource) throws JavaModelException {
  56         ArrayList vChildren = new ArrayList();
  57 //      int kind = getKind();
  58         String extType;
  59 //      if (kind == IPackageFragmentRoot.K_SOURCE) {
  60                 extType = "php"; //$NON-NLS-1$
  61 //      } else {
  62 //              extType = "class"; //$NON-NLS-1$
  63 //      }
  64         try {
  65                 char[][] exclusionPatterns = ((PackageFragmentRoot)getPackageFragmentRoot()).fullExclusionPatternChars();
  66                 IResource[] members = ((IContainer) resource).members();
  67                 for (int i = 0, max = members.length; i < max; i++) {
  68                         IResource child = members[i];
  69                         if (child.getType() != IResource.FOLDER
  70                                         && !Util.isExcluded(child, exclusionPatterns)) {
  71                                 String extension = child.getProjectRelativePath().getFileExtension();
  72                                 if (extension != null) {
  73                                         if (extension.equalsIgnoreCase(extType)) {
  74                                                 IJavaElement childElement;
  75 //                                              if (kind == IPackageFragmentRoot.K_SOURCE && Util.isValidCompilationUnitName(child.getName())) {
  76 //                                                      childElement = getCompilationUnit(child.getName());
  77 //                                                      vChildren.add(childElement);
  78 //                                              } else if (Util.isValidClassFileName(child.getName())) {
  79 //                                                      childElement = getClassFile(child.getName());
  80 //                                                      vChildren.add(childElement);
  81 //                                              }
  82                                         }
  83                                 }
  84                         }
  85                 }
  86         } catch (CoreException e) {
  87                 throw new JavaModelException(e);
  88         }
  89         IJavaElement[] children = new IJavaElement[vChildren.size()];
  90         vChildren.toArray(children);
  91         info.setChildren(children);
  92         return true;
  93 }
  94 /**
  95  * Returns true if this fragment contains at least one java resource.
  96  * Returns false otherwise.
  97  */
  98 //public boolean containsJavaResources() throws JavaModelException {
  99 //      return ((PackageFragmentInfo) getElementInfo()).containsJavaResources();
 100 //}
 101 /**
 102  * @see ISourceManipulation
 103  */
 104 //public void copy(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
 105 //      if (container == null) {
 106 //              throw new IllegalArgumentException(Util.bind("operation.nullContainer")); //$NON-NLS-1$
 107 //      }
 108 //      IJavaElement[] elements= new IJavaElement[] {this};
 109 //      IJavaElement[] containers= new IJavaElement[] {container};
 110 //      IJavaElement[] siblings= null;
 111 //      if (sibling != null) {
 112 //              siblings= new IJavaElement[] {sibling};
 113 //      }
 114 //      String[] renamings= null;
 115 //      if (rename != null) {
 116 //              renamings= new String[] {rename};
 117 //      }
 118 //      getJavaModel().copy(elements, containers, siblings, renamings, force, monitor);
 119 //}
 120 /**
 121  * @see IPackageFragment
 122  */
 123 public ICompilationUnit createCompilationUnit(String name, String contents, boolean force, IProgressMonitor monitor) throws JavaModelException {
 124 //      CreateCompilationUnitOperation op= new CreateCompilationUnitOperation(this, name, contents, force);
 125 //      runOperation(op, monitor);
 126 //      return getCompilationUnit(name);
 127     return null;
 128 }
 129 /**
 130  * @see JavaElement
 131  */
 132 protected OpenableElementInfo createElementInfo() {
 133         return new PackageFragmentInfo();
 134 }
 135 /**
 136  * @see ISourceManipulation
 137  */
 138 //public void delete(boolean force, IProgressMonitor monitor) throws JavaModelException {
 139 //      IJavaElement[] elements = new IJavaElement[] {this};
 140 //      getJavaModel().delete(elements, force, monitor);
 141 //}
 142 /**
 143  * @see Openable
 144  */
 145 protected boolean generateInfos(OpenableElementInfo info, IProgressMonitor pm, Map newElements, IResource underlyingResource) throws JavaModelException {
 146
 147         return computeChildren(info, underlyingResource);
 148 }
 149 ///**
 150 // * @see IPackageFragment#getClassFile(String)
 151 // */
 152 //public IClassFile getClassFile(String name) {
 153 //      return new ClassFile(this, name);
 154 //}
 155 /**
 156  * Returns a the collection of class files in this - a folder package fragment which has a root
 157  * that has its kind set to <code>IPackageFragmentRoot.K_Source</code> does not
 158  * recognize class files.
 159  *
 160  * @see IPackageFragment#getClassFiles()
 161  */
 162 //public IClassFile[] getClassFiles() throws JavaModelException {
 163 //      if (getKind() == IPackageFragmentRoot.K_SOURCE) {
 164 //              return fgEmptyClassFileList;
 165 //      }
 166 //
 167 //      ArrayList list = getChildrenOfType(CLASS_FILE);
 168 //      IClassFile[] array= new IClassFile[list.size()];
 169 //      list.toArray(array);
 170 //      return array;
 171 //}
 172 /**
 173  * @see IPackageFragment#getCompilationUnit(String)
 174  */
 175 public ICompilationUnit getCompilationUnit(String name) {
 176         return new CompilationUnit(this, name);
 177 }
 178 /**
 179  * @see IPackageFragment#getCompilationUnits()
 180  */
 181 public ICompilationUnit[] getCompilationUnits() throws JavaModelException {
 182         if (getKind() == IPackageFragmentRoot.K_BINARY) {
 183                 return fgEmptyCompilationUnitList;
 184         }
 185
 186         ArrayList list = getChildrenOfType(COMPILATION_UNIT);
 187         ICompilationUnit[] array= new ICompilationUnit[list.size()];
 188         list.toArray(array);
 189         return array;
 190 }
 191 /**
 192  * @see JavaElement#getHandleMementoDelimiter()
 193  */
 194 protected char getHandleMementoDelimiter() {
 195         return JavaElement.JEM_PACKAGEFRAGMENT;
 196 }
 197 /**
 198  * @see IPackageFragment#getKind()
 199  */
 200 public int getKind() throws JavaModelException {
 201         return ((IPackageFragmentRoot)getParent()).getKind();
 202 }
 203 /**
 204  * Returns an array of non-java resources contained in the receiver.
 205  */
 206 //public Object[] getNonJavaResources() throws JavaModelException {
 207 //      if (this.isDefaultPackage()) {
 208 //              // We don't want to show non java resources of the default package (see PR #1G58NB8)
 209 //              return JavaElementInfo.NO_NON_JAVA_RESOURCES;
 210 //      } else {
 211 //              return ((PackageFragmentInfo) getElementInfo()).getNonJavaResources(getResource(), (PackageFragmentRoot)getPackageFragmentRoot());
 212 //      }
 213 //}
 214 /**
 215  * @see IJavaElement#getPath()
 216  */
 217 public IPath getPath() {
 218         PackageFragmentRoot root = this.getPackageFragmentRoot();
 219         if (root.isArchive()) {
 220                 return root.getPath();
 221         } else {
 222                 return root.getPath().append(this.getElementName().replace('.', '/'));
 223         }
 224 }
 225 /**
 226  * @see IJavaElement#getResource()
 227  */
 228 public IResource getResource() {
 229         PackageFragmentRoot root = this.getPackageFragmentRoot();
 230         if (root.isArchive()) {
 231                 return root.getResource();
 232         } else {
 233                 String elementName = this.getElementName();
 234                 if (elementName.length() == 0) {
 235                         return root.getResource();
 236                 } else {
 237                         return ((IContainer)root.getResource()).getFolder(new Path(this.getElementName().replace('.', '/')));
 238                 }
 239         }
 240 }
 241 /**
 242  * @see IJavaElement#getUnderlyingResource()
 243  */
 244 public IResource getUnderlyingResource() throws JavaModelException {
 245         IResource rootResource = fParent.getUnderlyingResource();
 246         if (rootResource == null) {
 247                 //jar package fragment root that has no associated resource
 248                 return null;
 249         }
 250         // the underlying resource may be a folder or a project (in the case that the project folder
 251         // is atually the package fragment root)
 252 //      if (rootResource.getType() == IResource.FOLDER || rootResource.getType() == IResource.PROJECT) {
 253 //              IContainer folder = (IContainer) rootResource;
 254 //              String[] segs = Signature.getSimpleNames(fName);
 255 //              for (int i = 0; i < segs.length; ++i) {
 256 //                      IResource child = folder.findMember(segs[i]);
 257 //                      if (child == null || child.getType() != IResource.FOLDER) {
 258 //                              throw newNotPresentException();
 259 //                      }
 260 //                      folder = (IFolder) child;
 261 //              }
 262 //              return folder;
 263 //      } else {
 264                 return rootResource;
 265 //      }
 266 }
 267 /**
 268  * @see IPackageFragment#hasSubpackages()
 269  */
 270 //public boolean hasSubpackages() throws JavaModelException {
 271 //      IJavaElement[] packages= ((IPackageFragmentRoot)getParent()).getChildren();
 272 //      String name = getElementName();
 273 //      int nameLength = name.length();
 274 //      String packageName = isDefaultPackage() ? name : name+"."; //$NON-NLS-1$
 275 //      for (int i= 0; i < packages.length; i++) {
 276 //              String otherName = packages[i].getElementName();
 277 //              if (otherName.length() > nameLength && otherName.startsWith(packageName)) {
 278 //                      return true;
 279 //              }
 280 //      }
 281 //      return false;
 282 //}
 283 /**
 284  * @see IPackageFragment#isDefaultPackage()
 285  */
 286 public boolean isDefaultPackage() {
 287         return this.getElementName().length() == 0;
 288 }
 289 /**
 290  * @see ISourceManipulation#move(IJavaElement, IJavaElement, String, boolean, IProgressMonitor)
 291  */
 292 //public void move(IJavaElement container, IJavaElement sibling, String rename, boolean force, IProgressMonitor monitor) throws JavaModelException {
 293 //      if (container == null) {
 294 //              throw new IllegalArgumentException(Util.bind("operation.nullContainer")); //$NON-NLS-1$
 295 //      }
 296 //      IJavaElement[] elements= new IJavaElement[] {this};
 297 //      IJavaElement[] containers= new IJavaElement[] {container};
 298 //      IJavaElement[] siblings= null;
 299 //      if (sibling != null) {
 300 //              siblings= new IJavaElement[] {sibling};
 301 //      }
 302 //      String[] renamings= null;
 303 //      if (rename != null) {
 304 //              renamings= new String[] {rename};
 305 //      }
 306 //      getJavaModel().move(elements, containers, siblings, renamings, force, monitor);
 307 //}
 308 //protected void openWhenClosed(IProgressMonitor pm) throws JavaModelException {
 309 //      if (!this.resourceExists()) throw newNotPresentException();
 310 //      super.openWhenClosed(pm);
 311 //}
 312 /**
 313  * Recomputes the children of this element, based on the current state
 314  * of the workbench.
 315  */
 316 //public void refreshChildren() {
 317 //      try {
 318 //              OpenableElementInfo info= (OpenableElementInfo)getElementInfo();
 319 //              computeChildren(info, getResource());
 320 //      } catch (JavaModelException e) {
 321 //              // do nothing.
 322 //      }
 323 //}
 324 /**
 325  * @see ISourceManipulation#rename(String, boolean, IProgressMonitor)
 326  */
 327 //public void rename(String name, boolean force, IProgressMonitor monitor) throws JavaModelException {
 328 //      if (name == null) {
 329 //              throw new IllegalArgumentException(Util.bind("element.nullName")); //$NON-NLS-1$
 330 //      }
 331 //      IJavaElement[] elements= new IJavaElement[] {this};
 332 //      IJavaElement[] dests= new IJavaElement[] {this.getParent()};
 333 //      String[] renamings= new String[] {name};
 334 //      getJavaModel().rename(elements, dests, renamings, force, monitor);
 335 //}
 336 /*
 337  * @see JavaElement#rootedAt(IJavaProject)
 338  */
 339 public IJavaElement rootedAt(IJavaProject project) {
 340         return
 341                 new PackageFragment(
 342                         (IPackageFragmentRoot)((JavaElement)fParent).rootedAt(project),
 343                         fName);
 344 }
 345 /**
 346  * Debugging purposes
 347  */
 348 protected void toStringChildren(int tab, StringBuffer buffer, Object info) {
 349         if (tab == 0) {
 350                 super.toStringChildren(tab, buffer, info);
 351         }
 352 }
 353 /**
 354  * Debugging purposes
 355  */
 356 protected void toStringInfo(int tab, StringBuffer buffer, Object info) {
 357         buffer.append(this.tabString(tab));
 358         if (getElementName().length() == 0) {
 359                 buffer.append("[default]"); //$NON-NLS-1$
 360         } else {
 361                 buffer.append(getElementName());
 362         }
 363         if (info == null) {
 364                 buffer.append(" (not open)"); //$NON-NLS-1$
 365         } else {
 366                 if (tab > 0) {
 367                         buffer.append(" (...)"); //$NON-NLS-1$
 368                 }
 369         }
 370 }
 371 }