net.sourceforge.phpeclipse/src/net/sourceforge/phpdt/internal/core/JavaElementRequestor.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.IField;
  16 import net.sourceforge.phpdt.core.IMethod;
  17 import net.sourceforge.phpdt.core.IPackageFragment;
  18 import net.sourceforge.phpdt.core.IType;
  19
  20 /**
  21  * @see IJavaElementRequestor
  22  */
  23
  24 public class JavaElementRequestor implements IJavaElementRequestor {
  25         /**
  26          * True if this requestor no longer wants to receive results from its
  27          * <code>IRequestorNameLookup</code>.
  28          */
  29         protected boolean fCanceled = false;
  30
  31         /**
  32          * A collection of the resulting fields, or <code>null</code> if no field
  33          * results have been received.
  34          */
  35         protected ArrayList fFields = null;
  36
  37         /**
  38          * A collection of the resulting initializers, or <code>null</code> if no
  39          * initializer results have been received.
  40          */
  41         protected ArrayList fInitializers = null;
  42
  43         /**
  44          * A collection of the resulting member types, or <code>null</code> if no
  45          * member type results have been received.
  46          */
  47         protected ArrayList fMemberTypes = null;
  48
  49         /**
  50          * A collection of the resulting methods, or <code>null</code> if no
  51          * method results have been received.
  52          */
  53         protected ArrayList fMethods = null;
  54
  55         /**
  56          * A collection of the resulting package fragments, or <code>null</code>
  57          * if no package fragment results have been received.
  58          */
  59         protected ArrayList fPackageFragments = null;
  60
  61         /**
  62          * A collection of the resulting types, or <code>null</code> if no type
  63          * results have been received.
  64          */
  65         protected ArrayList fTypes = null;
  66
  67         /**
  68          * Empty arrays used for efficiency
  69          */
  70         protected static IField[] fgEmptyFieldArray = new IField[0];
  71
  72         // protected static IInitializer[] fgEmptyInitializerArray= new
  73         // IInitializer[0];
  74         protected static IType[] fgEmptyTypeArray = new IType[0];
  75
  76         protected static IPackageFragment[] fgEmptyPackageFragmentArray = new IPackageFragment[0];
  77
  78         protected static IMethod[] fgEmptyMethodArray = new IMethod[0];
  79
  80         /**
  81          * @see IJavaElementRequestor
  82          */
  83         public void acceptField(IField field) {
  84                 if (fFields == null) {
  85                         fFields = new ArrayList();
  86                 }
  87                 fFields.add(field);
  88         }
  89
  90         /**
  91          * @see IJavaElementRequestor
  92          */
  93         // public void acceptInitializer(IInitializer initializer) {
  94         // if (fInitializers == null) {
  95         // fInitializers= new ArrayList();
  96         // }
  97         // fInitializers.add(initializer);
  98         // }
  99         /**
 100          * @see IJavaElementRequestor
 101          */
 102         public void acceptMemberType(IType type) {
 103                 if (fMemberTypes == null) {
 104                         fMemberTypes = new ArrayList();
 105                 }
 106                 fMemberTypes.add(type);
 107         }
 108
 109         /**
 110          * @see IJavaElementRequestor
 111          */
 112         public void acceptMethod(IMethod method) {
 113                 if (fMethods == null) {
 114                         fMethods = new ArrayList();
 115                 }
 116                 fMethods.add(method);
 117         }
 118
 119         /**
 120          * @see IJavaElementRequestor
 121          */
 122         public void acceptPackageFragment(IPackageFragment packageFragment) {
 123                 if (fPackageFragments == null) {
 124                         fPackageFragments = new ArrayList();
 125                 }
 126                 fPackageFragments.add(packageFragment);
 127         }
 128
 129         /**
 130          * @see IJavaElementRequestor
 131          */
 132         public void acceptType(IType type) {
 133                 if (fTypes == null) {
 134                         fTypes = new ArrayList();
 135                 }
 136                 fTypes.add(type);
 137         }
 138
 139         /**
 140          * @see IJavaElementRequestor
 141          */
 142         public IField[] getFields() {
 143                 if (fFields == null) {
 144                         return fgEmptyFieldArray;
 145                 }
 146                 int size = fFields.size();
 147                 IField[] results = new IField[size];
 148                 fFields.toArray(results);
 149                 return results;
 150         }
 151
 152         /**
 153          * @see IJavaElementRequestor
 154          */
 155         // public IInitializer[] getInitializers() {
 156         // if (fInitializers == null) {
 157         // return fgEmptyInitializerArray;
 158         // }
 159         // int size = fInitializers.size();
 160         // IInitializer[] results = new IInitializer[size];
 161         // fInitializers.toArray(results);
 162         // return results;
 163         // }
 164         /**
 165          * @see IJavaElementRequestor
 166          */
 167         public IType[] getMemberTypes() {
 168                 if (fMemberTypes == null) {
 169                         return fgEmptyTypeArray;
 170                 }
 171                 int size = fMemberTypes.size();
 172                 IType[] results = new IType[size];
 173                 fMemberTypes.toArray(results);
 174                 return results;
 175         }
 176
 177         /**
 178          * @see IJavaElementRequestor
 179          */
 180         public IMethod[] getMethods() {
 181                 if (fMethods == null) {
 182                         return fgEmptyMethodArray;
 183                 }
 184                 int size = fMethods.size();
 185                 IMethod[] results = new IMethod[size];
 186                 fMethods.toArray(results);
 187                 return results;
 188         }
 189
 190         /**
 191          * @see IJavaElementRequestor
 192          */
 193         public IPackageFragment[] getPackageFragments() {
 194                 if (fPackageFragments == null) {
 195                         return fgEmptyPackageFragmentArray;
 196                 }
 197                 int size = fPackageFragments.size();
 198                 IPackageFragment[] results = new IPackageFragment[size];
 199                 fPackageFragments.toArray(results);
 200                 return results;
 201         }
 202
 203         /**
 204          * @see IJavaElementRequestor
 205          */
 206         public IType[] getTypes() {
 207                 if (fTypes == null) {
 208                         return fgEmptyTypeArray;
 209                 }
 210                 int size = fTypes.size();
 211                 IType[] results = new IType[size];
 212                 fTypes.toArray(results);
 213                 return results;
 214         }
 215
 216         /**
 217          * @see IJavaElementRequestor
 218          */
 219         public boolean isCanceled() {
 220                 return fCanceled;
 221         }
 222
 223         /**
 224          * Reset the state of this requestor.
 225          */
 226         public void reset() {
 227                 fCanceled = false;
 228                 fFields = null;
 229                 fInitializers = null;
 230                 fMemberTypes = null;
 231                 fMethods = null;
 232                 fPackageFragments = null;
 233                 fTypes = null;
 234         }
 235
 236         /**
 237          * Sets the #isCanceled state of this requestor to true or false.
 238          */
 239         public void setCanceled(boolean b) {
 240                 fCanceled = b;
 241         }
 242 }