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
  27          * results from its <code>IRequestorNameLookup</code>.
  28          */
  29         protected boolean fCanceled= false;
  30
  31         /**
  32          * A collection of the resulting fields, or <code>null</code>
  33          * if no field results have been received.
  34          */
  35         protected ArrayList fFields= null;
  36
  37         /**
  38          * A collection of the resulting initializers, or <code>null</code>
  39          * if no 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>
  45          * if no 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>
  51          * if no 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>
  63          * if no type 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 //      protected static IInitializer[] fgEmptyInitializerArray= new IInitializer[0];
  72         protected static IType[] fgEmptyTypeArray= new IType[0];
  73         protected static IPackageFragment[] fgEmptyPackageFragmentArray= new IPackageFragment[0];
  74         protected static IMethod[] fgEmptyMethodArray= new IMethod[0];
  75 /**
  76  * @see IJavaElementRequestor
  77  */
  78 public void acceptField(IField field) {
  79         if (fFields == null) {
  80                 fFields= new ArrayList();
  81         }
  82         fFields.add(field);
  83 }
  84 /**
  85  * @see IJavaElementRequestor
  86  */
  87 //public void acceptInitializer(IInitializer initializer) {
  88 //      if (fInitializers == null) {
  89 //              fInitializers= new ArrayList();
  90 //      }
  91 //      fInitializers.add(initializer);
  92 //}
  93 /**
  94  * @see IJavaElementRequestor
  95  */
  96 public void acceptMemberType(IType type) {
  97         if (fMemberTypes == null) {
  98                 fMemberTypes= new ArrayList();
  99         }
 100         fMemberTypes.add(type);
 101 }
 102 /**
 103  * @see IJavaElementRequestor
 104  */
 105 public void acceptMethod(IMethod method) {
 106         if (fMethods == null) {
 107                 fMethods = new ArrayList();
 108         }
 109         fMethods.add(method);
 110 }
 111 /**
 112  * @see IJavaElementRequestor
 113  */
 114 public void acceptPackageFragment(IPackageFragment packageFragment) {
 115         if (fPackageFragments== null) {
 116                 fPackageFragments= new ArrayList();
 117         }
 118         fPackageFragments.add(packageFragment);
 119 }
 120 /**
 121  * @see IJavaElementRequestor
 122  */
 123 public void acceptType(IType type) {
 124         if (fTypes == null) {
 125                 fTypes= new ArrayList();
 126         }
 127         fTypes.add(type);
 128 }
 129 /**
 130  * @see IJavaElementRequestor
 131  */
 132 public IField[] getFields() {
 133         if (fFields == null) {
 134                 return fgEmptyFieldArray;
 135         }
 136         int size = fFields.size();
 137         IField[] results = new IField[size];
 138         fFields.toArray(results);
 139         return results;
 140 }
 141 /**
 142  * @see IJavaElementRequestor
 143  */
 144 //public IInitializer[] getInitializers() {
 145 //      if (fInitializers == null) {
 146 //              return fgEmptyInitializerArray;
 147 //      }
 148 //      int size = fInitializers.size();
 149 //      IInitializer[] results = new IInitializer[size];
 150 //      fInitializers.toArray(results);
 151 //      return results;
 152 //}
 153 /**
 154  * @see IJavaElementRequestor
 155  */
 156 public IType[] getMemberTypes() {
 157         if (fMemberTypes == null) {
 158                 return fgEmptyTypeArray;
 159         }
 160         int size = fMemberTypes.size();
 161         IType[] results = new IType[size];
 162         fMemberTypes.toArray(results);
 163         return results;
 164 }
 165 /**
 166  * @see IJavaElementRequestor
 167  */
 168 public IMethod[] getMethods() {
 169         if (fMethods == null) {
 170                 return fgEmptyMethodArray;
 171         }
 172         int size = fMethods.size();
 173         IMethod[] results = new IMethod[size];
 174         fMethods.toArray(results);
 175         return results;
 176 }
 177 /**
 178  * @see IJavaElementRequestor
 179  */
 180 public IPackageFragment[] getPackageFragments() {
 181         if (fPackageFragments== null) {
 182                 return fgEmptyPackageFragmentArray;
 183         }
 184         int size = fPackageFragments.size();
 185         IPackageFragment[] results = new IPackageFragment[size];
 186         fPackageFragments.toArray(results);
 187         return results;
 188 }
 189 /**
 190  * @see IJavaElementRequestor
 191  */
 192 public IType[] getTypes() {
 193         if (fTypes== null) {
 194                 return fgEmptyTypeArray;
 195         }
 196         int size = fTypes.size();
 197         IType[] results = new IType[size];
 198         fTypes.toArray(results);
 199         return results;
 200 }
 201 /**
 202  * @see IJavaElementRequestor
 203  */
 204 public boolean isCanceled() {
 205         return fCanceled;
 206 }
 207 /**
 208  * Reset the state of this requestor.
 209  */
 210 public void reset() {
 211         fCanceled = false;
 212         fFields = null;
 213         fInitializers = null;
 214         fMemberTypes = null;
 215         fMethods = null;
 216         fPackageFragments = null;
 217         fTypes = null;
 218 }
 219 /**
 220  * Sets the #isCanceled state of this requestor to true or false.
 221  */
 222 public void setCanceled(boolean b) {
 223         fCanceled= b;
 224 }
 225 }