net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/corext/util/JdtFlags.java

   1 /*******************************************************************************
   2  * Copyright (c) 2000, 2004 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.corext.util;
  12
  13 import java.lang.reflect.Modifier;
  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.IType;
  19 import net.sourceforge.phpdt.core.JavaModelException;
  20 //incastrix
  21 //import net.sourceforge.phpdt.internal.corext.Assert;
  22 import org.eclipse.core.runtime.Assert;
  23
  24 public class JdtFlags {
  25         private JdtFlags() {
  26         }
  27
  28         public static final String VISIBILITY_STRING_PRIVATE = "private"; //$NON-NLS-1$
  29
  30         public static final String VISIBILITY_STRING_PACKAGE = ""; //$NON-NLS-1$
  31
  32         public static final String VISIBILITY_STRING_PROTECTED = "protected"; //$NON-NLS-1$
  33
  34         public static final String VISIBILITY_STRING_PUBLIC = "public"; //$NON-NLS-1$
  35
  36         public static final int VISIBILITY_CODE_INVALID = -1;
  37
  38 //      public static boolean isAbstract(IMember member) throws JavaModelException {
  39 //              if (isInterfaceMethod(member))
  40 //                      return true;
  41 //              return Flags.isAbstract(member.getFlags());
  42 //      }
  43
  44         // public static boolean isAbstract(IMethodBinding member) {
  45         // if (isInterfaceMember(member))
  46         // return true;
  47         // return Modifier.isAbstract(member.getModifiers());
  48         // }
  49
  50 //      public static boolean isDeprecated(IMember member)
  51 //                      throws JavaModelException {
  52 //              return Flags.isDeprecated(member.getFlags());
  53 //      }
  54
  55 //      public static boolean isFinal(IMember member) throws JavaModelException {
  56 //              if (isInterfaceField(member))
  57 //                      return true;
  58 //              if (isAnonymousType(member))
  59 //                      return true;
  60 //              return Flags.isFinal(member.getFlags());
  61 //      }
  62
  63         // public static boolean isNative(IMember member) throws JavaModelException{
  64         // return Flags.isNative(member.getFlags());
  65         // }
  66
  67 //      public static boolean isPackageVisible(IMember member)
  68 //                      throws JavaModelException {
  69 //              return (!isPrivate(member) && !isProtected(member) && !isPublic(member));
  70 //      }
  71
  72         // public static boolean isPackageVisible(BodyDeclaration bodyDeclaration) {
  73         // return (! isPrivate(bodyDeclaration) && ! isProtected(bodyDeclaration) &&
  74         // ! isPublic(bodyDeclaration));
  75         // }
  76         //
  77         // public static boolean isPackageVisible(IBinding binding) {
  78         // return (! isPrivate(binding) && ! isProtected(binding) && !
  79         // isPublic(binding));
  80         // }
  81
  82         public static boolean isPrivate(IMember member) throws JavaModelException {
  83                 return Flags.isPrivate(member.getFlags());
  84         }
  85
  86         // public static boolean isPrivate(BodyDeclaration bodyDeclaration) {
  87         // return Modifier.isPrivate(bodyDeclaration.getModifiers());
  88         // }
  89         //
  90         // public static boolean isPrivate(IBinding binding) {
  91         // return Modifier.isPrivate(binding.getModifiers());
  92         // }
  93
  94         public static boolean isProtected(IMember member) throws JavaModelException {
  95                 return Flags.isProtected(member.getFlags());
  96         }
  97
  98         // public static boolean isProtected(BodyDeclaration bodyDeclaration) {
  99         // return Modifier.isProtected(bodyDeclaration.getModifiers());
 100         // }
 101         //
 102         // public static boolean isProtected(IBinding binding) {
 103         // return Modifier.isProtected(binding.getModifiers());
 104         // }
 105
 106         public static boolean isPublic(IMember member) throws JavaModelException {
 107                 if (isInterfaceMember(member))
 108                         return true;
 109                 return Flags.isPublic(member.getFlags());
 110         }
 111
 112         // public static boolean isPublic(IBinding binding) {
 113         // if (isInterfaceMember(binding))
 114         // return true;
 115         // return Modifier.isPublic(binding.getModifiers());
 116         // }
 117         //
 118         //
 119         // public static boolean isPublic(BodyDeclaration bodyDeclaration) {
 120         // if (isInterfaceMember(bodyDeclaration))
 121         // return true;
 122         // return Modifier.isPublic(bodyDeclaration.getModifiers());
 123         // }
 124
 125 //      public static boolean isStatic(IMember member) throws JavaModelException {
 126 //              if (isNestedInterface(member))
 127 //                      return true;
 128 //              if (member.getElementType() != IJavaElement.METHOD
 129 //                              && isInterfaceMember(member))
 130 //                      return true;
 131 //              return Flags.isStatic(member.getFlags());
 132 //      }
 133
 134         // public static boolean isStatic(IMethodBinding methodBinding){
 135         // return Modifier.isStatic(methodBinding.getModifiers());
 136         // }
 137         //
 138         // public static boolean isStatic(IVariableBinding variableBinding){
 139         // if (isInterfaceMember(variableBinding))
 140         // return true;
 141         // return Modifier.isStatic(variableBinding.getModifiers());
 142         // }
 143
 144         // public static boolean isStrictfp(IMember member) throws
 145         // JavaModelException{
 146         // return Flags.isStrictfp(member.getFlags());
 147         // }
 148         //
 149         // public static boolean isSynchronized(IMember member) throws
 150         // JavaModelException{
 151         // return Flags.isSynchronized(member.getFlags());
 152         // }
 153         //
 154         // public static boolean isSynthetic(IMember member) throws
 155         // JavaModelException{
 156         // return Flags.isSynthetic(member.getFlags());
 157         // }
 158         //
 159         // public static boolean isTransient(IMember member) throws
 160         // JavaModelException{
 161         // return Flags.isTransient(member.getFlags());
 162         // }
 163
 164         // public static boolean isVolatile(IMember member) throws
 165         // JavaModelException{
 166         // return Flags.isVolatile(member.getFlags());
 167         // }
 168
 169 //      private static boolean isInterfaceMethod(IMember member)
 170 //                      throws JavaModelException {
 171 //              return member.getElementType() == IJavaElement.METHOD
 172 //                              && isInterfaceMember(member);
 173 //      }
 174 //
 175 //      private static boolean isInterfaceField(IMember member)
 176 //                      throws JavaModelException {
 177 //              return member.getElementType() == IJavaElement.FIELD
 178 //                              && isInterfaceMember(member);
 179 //      }
 180
 181         private static boolean isInterfaceMember(IMember member)
 182                         throws JavaModelException {
 183                 return member.getDeclaringType() != null
 184                                 && member.getDeclaringType().isInterface();
 185         }
 186
 187         // private static boolean isInterfaceMember(IBinding binding) {
 188         // ITypeBinding declaringType= null;
 189         // if (binding instanceof IVariableBinding) {
 190         // declaringType= ((IVariableBinding) binding).getDeclaringClass();
 191         // } else if (binding instanceof IMethodBinding) {
 192         // declaringType= ((IMethodBinding) binding).getDeclaringClass();
 193         // } else if (binding instanceof ITypeBinding) {
 194         // declaringType= ((ITypeBinding) binding).getDeclaringClass();
 195         // }
 196         // return declaringType != null && declaringType.isInterface();
 197         // }
 198
 199         // private static boolean isInterfaceMember(BodyDeclaration bodyDeclaration)
 200         // {
 201         // return (bodyDeclaration.getParent() instanceof TypeDeclaration) &&
 202         // ((TypeDeclaration)bodyDeclaration.getParent()).isInterface();
 203         // }
 204
 205 //      private static boolean isNestedInterface(IMember member)
 206 //                      throws JavaModelException {
 207 //              return member.getElementType() == IJavaElement.TYPE
 208 //                              && member.getDeclaringType() != null
 209 //                              && ((IType) member).isInterface();
 210 //      }
 211 //
 212 //      private static boolean isAnonymousType(IMember member)
 213 //                      throws JavaModelException {
 214 //              return member.getElementType() == IJavaElement.TYPE
 215 //                              && ((IType) member).isAnonymous();
 216 //      }
 217
 218         public static int getVisibilityCode(IMember member)
 219                         throws JavaModelException {
 220                 if (isPublic(member))
 221                         return Modifier.PUBLIC;
 222                 else if (isProtected(member))
 223                         return Modifier.PROTECTED;
 224                 // else if (isPackageVisible(member))
 225                 // return Modifier.NONE;
 226                 else if (isPrivate(member))
 227                         return Modifier.PRIVATE;
 228                 // Assert.isTrue(false);
 229                 // return VISIBILITY_CODE_INVALID;
 230                 return Modifier.PUBLIC;
 231         }
 232
 233         // public static int getVisibilityCode(BodyDeclaration bodyDeclaration) {
 234         // if (isPublic(bodyDeclaration))
 235         // return Modifier.PUBLIC;
 236         // else if (isProtected(bodyDeclaration))
 237         // return Modifier.PROTECTED;
 238         // else if (isPackageVisible(bodyDeclaration))
 239         // return Modifier.NONE;
 240         // else if (isPrivate(bodyDeclaration))
 241         // return Modifier.PRIVATE;
 242         // Assert.isTrue(false);
 243         // return VISIBILITY_CODE_INVALID;
 244         // }
 245
 246         // public static int getVisibilityCode(IBinding binding) {
 247         // if (isPublic(binding))
 248         // return Modifier.PUBLIC;
 249         // else if (isProtected(binding))
 250         // return Modifier.PROTECTED;
 251         // else if (isPackageVisible(binding))
 252         // return Modifier.NONE;
 253         // else if (isPrivate(binding))
 254         // return Modifier.PRIVATE;
 255         // Assert.isTrue(false);
 256         // return VISIBILITY_CODE_INVALID;
 257         // }
 258
 259 //      public static String getVisibilityString(int visibilityCode) {
 260 //              if (Modifier.isPublic(visibilityCode))
 261 //                      return VISIBILITY_STRING_PUBLIC;
 262 //              if (Modifier.isProtected(visibilityCode))
 263 //                      return VISIBILITY_STRING_PROTECTED;
 264 //              if (Modifier.isPrivate(visibilityCode))
 265 //                      return VISIBILITY_STRING_PRIVATE;
 266 //              return VISIBILITY_STRING_PACKAGE;
 267 //      }
 268
 269         public static void assertVisibility(int visibility) {
 270                 Assert.isTrue(visibility == Modifier.PUBLIC
 271                                 || visibility == Modifier.PROTECTED ||
 272                                 // visibility == Modifier.NONE ||
 273                                 visibility == Modifier.PRIVATE);
 274         }
 275
 276 //      public static boolean isHigherVisibility(int newVisibility,
 277 //                      int oldVisibility) {
 278 //              assertVisibility(oldVisibility);
 279 //              assertVisibility(newVisibility);
 280 //              switch (oldVisibility) {
 281 //              case Modifier.PRIVATE:
 282 //                      return // newVisibility == Modifier.NONE ||
 283 //                      newVisibility == Modifier.PUBLIC
 284 //                                      || newVisibility == Modifier.PROTECTED;
 285 //                      // case Modifier.NONE :
 286 //                      // return newVisibility == Modifier.PUBLIC
 287 //                      // || newVisibility == Modifier.PROTECTED;
 288 //
 289 //              case Modifier.PROTECTED:
 290 //                      return newVisibility == Modifier.PUBLIC;
 291 //
 292 //              case Modifier.PUBLIC:
 293 //                      return false;
 294 //              default:
 295 //                      // Assert.isTrue(false);
 296 //                      return false;
 297 //              }
 298 //      }
 299
 300 //      public static int getLowerVisibility(int visibility1, int visibility2) {
 301 //              if (isHigherVisibility(visibility1, visibility2))
 302 //                      return visibility2;
 303 //              else
 304 //                      return visibility1;
 305 //      }
 306
 307 //      public static int clearAccessModifiers(int flags) {
 308 //              return clearFlag(Modifier.PROTECTED | Modifier.PUBLIC
 309 //                              | Modifier.PRIVATE, flags);
 310 //      }
 311
 312 //      public static int clearFlag(int flag, int flags) {
 313 //              return flags & ~flag;
 314 //      }
 315 }