net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/Member.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
  15 import net.sourceforge.phpdt.core.Flags;
  16 import net.sourceforge.phpdt.core.IJavaElement;
  17 import net.sourceforge.phpdt.core.IMember;
  18 import net.sourceforge.phpdt.core.IMethod;
  19 import net.sourceforge.phpdt.core.ISourceRange;
  20 import net.sourceforge.phpdt.core.IType;
  21 import net.sourceforge.phpdt.core.JavaModelException;
  22 import net.sourceforge.phpdt.core.Signature;
  23 import net.sourceforge.phpdt.core.jdom.IDOMNode;
  24
  25 /**
  26  * @see IMember
  27  */
  28
  29 public abstract class Member extends SourceRefElement implements IMember {
  30         protected Member(JavaElement parent, String name) {
  31                 super(parent, name);
  32         }
  33
  34         protected boolean areSimilarMethods(String name1, String[] params1,
  35                         String name2, String[] params2, String[] simpleNames1) {
  36
  37                 if (name1.equals(name2)) {
  38                         int params1Length = params1.length;
  39                         if (params1Length == params2.length) {
  40                                 for (int i = 0; i < params1Length; i++) {
  41                                         String simpleName1 = simpleNames1 == null ? Signature
  42                                                         .getSimpleName(Signature.toString(params1[i]))
  43                                                         : simpleNames1[i];
  44                                         String simpleName2 = Signature.getSimpleName(Signature
  45                                                         .toString(params2[i]));
  46                                         if (!simpleName1.equals(simpleName2)) {
  47                                                 return false;
  48                                         }
  49                                 }
  50                                 return true;
  51                         }
  52                 }
  53                 return false;
  54         }
  55
  56         /**
  57          * Converts a field constant from the compiler's representation to the Java
  58          * Model constant representation (Number or String).
  59          */
  60         // protected static Object convertConstant(Constant constant) {
  61         // if (constant == null)
  62         // return null;
  63         // if (constant == Constant.NotAConstant) {
  64         // return null;
  65         // }
  66         // switch (constant.typeID()) {
  67         // case TypeIds.T_boolean :
  68         // return constant.booleanValue() ? Boolean.TRUE : Boolean.FALSE;
  69         // case TypeIds.T_byte :
  70         // return new Byte(constant.byteValue());
  71         // case TypeIds.T_char :
  72         // return new Character(constant.charValue());
  73         // case TypeIds.T_double :
  74         // return new Double(constant.doubleValue());
  75         // case TypeIds.T_float :
  76         // return new Float(constant.floatValue());
  77         // case TypeIds.T_int :
  78         // return new Integer(constant.intValue());
  79         // case TypeIds.T_long :
  80         // return new Long(constant.longValue());
  81         // case TypeIds.T_short :
  82         // return new Short(constant.shortValue());
  83         // case TypeIds.T_String :
  84         // return constant.stringValue();
  85         // default :
  86         // return null;
  87         // }
  88         // }
  89         /**
  90          * @see JavaElement#equalsDOMNode
  91          */
  92         protected boolean equalsDOMNode(IDOMNode node) throws JavaModelException {
  93                 return getElementName().equals(node.getName());
  94         }
  95
  96         /*
  97          * Helper method for SourceType.findMethods and BinaryType.findMethods
  98          */
  99         protected IMethod[] findMethods(IMethod method, IMethod[] methods) {
 100                 String elementName = method.getElementName();
 101                 String[] parameters = method.getParameterTypes();
 102                 int paramLength = parameters.length;
 103                 String[] simpleNames = new String[paramLength];
 104                 for (int i = 0; i < paramLength; i++) {
 105                         simpleNames[i] = Signature.getSimpleName(Signature
 106                                         .toString(parameters[i]));
 107                 }
 108                 ArrayList list = new ArrayList();
 109                 next: for (int i = 0, length = methods.length; i < length; i++) {
 110                         IMethod existingMethod = methods[i];
 111                         if (this.areSimilarMethods(elementName, parameters, existingMethod
 112                                         .getElementName(), existingMethod.getParameterTypes(),
 113                                         simpleNames)) {
 114                                 list.add(existingMethod);
 115                         }
 116                 }
 117                 int size = list.size();
 118                 if (size == 0) {
 119                         return null;
 120                 } else {
 121                         IMethod[] result = new IMethod[size];
 122                         list.toArray(result);
 123                         return result;
 124                 }
 125         }
 126
 127         /**
 128          * @see IMember
 129          */
 130         // public IClassFile getClassFile() {
 131         // return ((JavaElement)getParent()).getClassFile();
 132         // }
 133         /**
 134          * @see IMember
 135          */
 136         public IType getDeclaringType() {
 137                 JavaElement parentElement = (JavaElement) getParent();
 138                 if (parentElement.getElementType() == TYPE) {
 139                         return (IType) parentElement;
 140                 }
 141                 return null;
 142         }
 143
 144         /**
 145          * @see IMember
 146          */
 147         public int getFlags() throws JavaModelException {
 148                 MemberElementInfo info = (MemberElementInfo) getElementInfo();
 149                 return info.getModifiers();
 150         }
 151
 152         /**
 153          * @see JavaElement#getHandleMemento()
 154          */
 155         protected char getHandleMementoDelimiter() {
 156                 return JavaElement.JEM_TYPE;
 157         }
 158
 159         /*
 160          * Returns the outermost context defining a local element. Per construction,
 161          * it can only be a method/field/initializarer member; thus, returns null if
 162          * this member is already a top-level type or member type. e.g for
 163          * X.java/X/Y/foo()/Z/bar()/T, it will return X.java/X/Y/foo()
 164          */
 165         public Member getOuterMostLocalContext() {
 166                 IJavaElement current = this;
 167                 Member lastLocalContext = null;
 168                 parentLoop: while (true) {
 169                         switch (current.getElementType()) {
 170                         case CLASS_FILE:
 171                         case COMPILATION_UNIT:
 172                                 break parentLoop; // done recursing
 173                         case TYPE:
 174                                 // cannot be a local context
 175                                 break;
 176                         case INITIALIZER:
 177                         case FIELD:
 178                         case METHOD:
 179                                 // these elements can define local members
 180                                 lastLocalContext = (Member) current;
 181                                 break;
 182                         }
 183                         current = current.getParent();
 184                 }
 185                 return lastLocalContext;
 186         }
 187
 188         /**
 189          * @see IMember
 190          */
 191         public ISourceRange getNameRange() throws JavaModelException {
 192                 MemberElementInfo info = (MemberElementInfo) getElementInfo();
 193                 return new SourceRange(info.getNameSourceStart(), info
 194                                 .getNameSourceEnd()
 195                                 - info.getNameSourceStart() + 1);
 196         }
 197
 198         /**
 199          * @see IMember
 200          */
 201         public IType getType(String typeName, int count) {
 202                 if (isBinary()) {
 203                         throw new IllegalArgumentException(
 204                                         "Not a source member " + toStringWithAncestors()); //$NON-NLS-1$
 205                 } else {
 206                         SourceType type = new SourceType(this, typeName);
 207                         type.occurrenceCount = count;
 208                         return type;
 209                 }
 210         }
 211
 212         /**
 213          * @see IMember
 214          */
 215         public boolean isBinary() {
 216                 return false;
 217         }
 218
 219         protected boolean isMainMethod(IMethod method) throws JavaModelException {
 220                 if ("main".equals(method.getElementName()) && Signature.SIG_VOID.equals(method.getReturnType())) { //$NON-NLS-1$
 221                         int flags = method.getFlags();
 222                         if (Flags.isStatic(flags) && Flags.isPublic(flags)) {
 223                                 String[] paramTypes = method.getParameterTypes();
 224                                 if (paramTypes.length == 1) {
 225                                         String name = Signature.toString(paramTypes[0]);
 226                                         return "String[]".equals(Signature.getSimpleName(name)); //$NON-NLS-1$
 227                                 }
 228                         }
 229                 }
 230                 return false;
 231         }
 232
 233         /**
 234          * @see IJavaElement
 235          */
 236         public boolean isReadOnly() {
 237                 return false; // getClassFile() != null;
 238         }
 239
 240         /**
 241          */
 242         public String readableName() {
 243
 244                 IJavaElement declaringType = getDeclaringType();
 245                 if (declaringType != null) {
 246                         String declaringName = ((JavaElement) getDeclaringType())
 247                                         .readableName();
 248                         StringBuffer buffer = new StringBuffer(declaringName);
 249                         buffer.append('.');
 250                         buffer.append(this.getElementName());
 251                         return buffer.toString();
 252                 } else {
 253                         return super.readableName();
 254                 }
 255         }
 256
 257         /**
 258          * Updates the name range for this element.
 259          */
 260         protected void updateNameRange(int nameStart, int nameEnd) {
 261                 try {
 262                         MemberElementInfo info = (MemberElementInfo) getElementInfo();
 263                         info.setNameSourceStart(nameStart);
 264                         info.setNameSourceEnd(nameEnd);
 265                 } catch (JavaModelException npe) {
 266                         return;
 267                 }
 268         }
 269 }