001    /* This file was generated with JastAdd2 (http://jastadd.org) version 2.1.13-12-g880e696 */
002    package org.extendj.ast;
003    
004    import java.util.HashSet;
005    import java.io.File;
006    import java.util.Set;
007    import java.util.Collections;
008    import java.util.Collection;
009    import java.util.ArrayList;
010    import beaver.*;
011    import java.util.*;
012    import java.io.ByteArrayOutputStream;
013    import java.io.PrintStream;
014    import java.lang.reflect.InvocationTargetException;
015    import java.lang.reflect.Method;
016    import org.jastadd.util.*;
017    import java.util.zip.*;
018    import java.io.*;
019    import org.jastadd.util.PrettyPrintable;
020    import org.jastadd.util.PrettyPrinter;
021    import java.io.FileNotFoundException;
022    import java.io.BufferedInputStream;
023    import java.io.DataInputStream;
024    /**
025     * 7.5 Import Declarations
026     * @ast node
027     * @declaredat /home/jesper/git/extendj/java5/grammar/StaticImports.ast:4
028     * @production StaticImportDecl : {@link ImportDecl};
029    
030     */
031    public abstract class StaticImportDecl extends ImportDecl implements Cloneable {
032      /**
033       * @declaredat ASTNode:1
034       */
035      public StaticImportDecl() {
036        super();
037      }
038      /**
039       * Initializes the child array to the correct size.
040       * Initializes List and Opt nta children.
041       * @apilevel internal
042       * @ast method
043       * @declaredat ASTNode:10
044       */
045      public void init$Children() {
046        children = new ASTNode[1];
047      }
048      /**
049       * @declaredat ASTNode:13
050       */
051      public StaticImportDecl(Access p0) {
052        setChild(p0, 0);
053      }
054      /**
055       * @apilevel low-level
056       * @declaredat ASTNode:19
057       */
058      protected int numChildren() {
059        return 1;
060      }
061      /**
062       * @apilevel internal
063       * @declaredat ASTNode:25
064       */
065      public boolean mayHaveRewrite() {
066        return false;
067      }
068      /**
069       * @apilevel internal
070       * @declaredat ASTNode:31
071       */
072      public void flushAttrCache() {
073        super.flushAttrCache();
074        importedTypes_String_reset();
075        importedFields_String_reset();
076        importedMethods_String_reset();
077      }
078      /**
079       * @apilevel internal
080       * @declaredat ASTNode:40
081       */
082      public void flushCollectionCache() {
083        super.flushCollectionCache();
084      }
085      /**
086       * @apilevel internal
087       * @declaredat ASTNode:46
088       */
089      public void flushRewriteCache() {
090        super.flushRewriteCache();
091      }
092      /**
093       * @apilevel internal
094       * @declaredat ASTNode:52
095       */
096      public StaticImportDecl clone() throws CloneNotSupportedException {
097        StaticImportDecl node = (StaticImportDecl) super.clone();
098        return node;
099      }
100      /**
101       * Create a deep copy of the AST subtree at this node.
102       * The copy is dangling, i.e. has no parent.
103       * @return dangling copy of the subtree at this node
104       * @apilevel low-level
105       * @deprecated Please use treeCopy or treeCopyNoTransform instead
106       * @declaredat ASTNode:63
107       */
108      @Deprecated
109      public abstract StaticImportDecl fullCopy();
110      /**
111       * Create a deep copy of the AST subtree at this node.
112       * The copy is dangling, i.e. has no parent.
113       * @return dangling copy of the subtree at this node
114       * @apilevel low-level
115       * @declaredat ASTNode:71
116       */
117      public abstract StaticImportDecl treeCopyNoTransform();
118      /**
119       * Create a deep copy of the AST subtree at this node.
120       * The subtree of this node is traversed to trigger rewrites before copy.
121       * The copy is dangling, i.e. has no parent.
122       * @return dangling copy of the subtree at this node
123       * @apilevel low-level
124       * @declaredat ASTNode:79
125       */
126      public abstract StaticImportDecl treeCopy();
127      /**
128       * Replaces the Access child.
129       * @param node The new node to replace the Access child.
130       * @apilevel high-level
131       */
132      public void setAccess(Access node) {
133        setChild(node, 0);
134      }
135      /**
136       * Retrieves the Access child.
137       * @return The current node used as the Access child.
138       * @apilevel high-level
139       */
140      @ASTNodeAnnotation.Child(name="Access")
141      public Access getAccess() {
142        return (Access) getChild(0);
143      }
144      /**
145       * Retrieves the Access child.
146       * <p><em>This method does not invoke AST transformations.</em></p>
147       * @return The current node used as the Access child.
148       * @apilevel low-level
149       */
150      public Access getAccessNoTransform() {
151        return (Access) getChildNoTransform(0);
152      }
153      /**
154       * @attribute syn
155       * @aspect StaticImports
156       * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:95
157       */
158      @ASTNodeAnnotation.Attribute
159      public abstract TypeDecl type();
160      /**
161       * @apilevel internal
162       */
163      protected java.util.Map importedTypes_String_values;
164      /**
165       * @apilevel internal
166       */
167      private void importedTypes_String_reset() {
168        importedTypes_String_values = null;
169      }
170      /**
171       * @attribute syn
172       * @aspect TypeScopePropagation
173       * @declaredat /home/jesper/git/extendj/java4/frontend/LookupType.jrag:420
174       */
175      @ASTNodeAnnotation.Attribute
176      public SimpleSet importedTypes(String name) {
177        Object _parameters = name;
178        if (importedTypes_String_values == null) importedTypes_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
179        ASTNode$State state = state();
180        if (importedTypes_String_values.containsKey(_parameters)) {
181          return (SimpleSet) importedTypes_String_values.get(_parameters);
182        }
183        boolean intermediate = state.INTERMEDIATE_VALUE;
184        state.INTERMEDIATE_VALUE = false;
185        int num = state.boundariesCrossed;
186        boolean isFinal = this.is$Final();
187        SimpleSet importedTypes_String_value = importedTypes_compute(name);
188        if (isFinal && num == state().boundariesCrossed) {
189          importedTypes_String_values.put(_parameters, importedTypes_String_value);
190        } else {
191        }
192        state.INTERMEDIATE_VALUE |= intermediate;
193    
194        return importedTypes_String_value;
195      }
196      /**
197       * @apilevel internal
198       */
199      private SimpleSet importedTypes_compute(String name) {
200          SimpleSet set = SimpleSet.emptySet;
201          for (Iterator iter = type().memberTypes(name).iterator(); iter.hasNext(); ) {
202            TypeDecl decl = (TypeDecl) iter.next();
203            if (decl.isStatic() && decl.accessibleFromPackage(packageName())) {
204              set = set.add(decl);
205            }
206          }
207          return set;
208        }
209      /**
210       * @apilevel internal
211       */
212      protected java.util.Map importedFields_String_values;
213      /**
214       * @apilevel internal
215       */
216      private void importedFields_String_reset() {
217        importedFields_String_values = null;
218      }
219      /**
220       * @attribute syn
221       * @aspect StaticImports
222       * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:55
223       */
224      @ASTNodeAnnotation.Attribute
225      public SimpleSet importedFields(String name) {
226        Object _parameters = name;
227        if (importedFields_String_values == null) importedFields_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
228        ASTNode$State state = state();
229        if (importedFields_String_values.containsKey(_parameters)) {
230          return (SimpleSet) importedFields_String_values.get(_parameters);
231        }
232        boolean intermediate = state.INTERMEDIATE_VALUE;
233        state.INTERMEDIATE_VALUE = false;
234        int num = state.boundariesCrossed;
235        boolean isFinal = this.is$Final();
236        SimpleSet importedFields_String_value = importedFields_compute(name);
237        if (isFinal && num == state().boundariesCrossed) {
238          importedFields_String_values.put(_parameters, importedFields_String_value);
239        } else {
240        }
241        state.INTERMEDIATE_VALUE |= intermediate;
242    
243        return importedFields_String_value;
244      }
245      /**
246       * @apilevel internal
247       */
248      private SimpleSet importedFields_compute(String name) {
249          SimpleSet set = SimpleSet.emptySet;
250          for (Iterator iter = type().memberFields(name).iterator(); iter.hasNext(); ) {
251            FieldDeclaration decl = (FieldDeclaration) iter.next();
252            if (decl.isStatic() &&
253               (decl.isPublic() || (!decl.isPrivate() && decl.hostType().topLevelType().packageName().equals(packageName()))))
254              set = set.add(decl);
255          }
256          return set;
257        }
258      /**
259       * @apilevel internal
260       */
261      protected java.util.Map importedMethods_String_values;
262      /**
263       * @apilevel internal
264       */
265      private void importedMethods_String_reset() {
266        importedMethods_String_values = null;
267      }
268      /**
269       * @attribute syn
270       * @aspect StaticImports
271       * @declaredat /home/jesper/git/extendj/java5/frontend/StaticImports.jrag:75
272       */
273      @ASTNodeAnnotation.Attribute
274      public Collection importedMethods(String name) {
275        Object _parameters = name;
276        if (importedMethods_String_values == null) importedMethods_String_values = new org.jastadd.util.RobustMap(new java.util.HashMap());
277        ASTNode$State state = state();
278        if (importedMethods_String_values.containsKey(_parameters)) {
279          return (Collection) importedMethods_String_values.get(_parameters);
280        }
281        boolean intermediate = state.INTERMEDIATE_VALUE;
282        state.INTERMEDIATE_VALUE = false;
283        int num = state.boundariesCrossed;
284        boolean isFinal = this.is$Final();
285        Collection importedMethods_String_value = importedMethods_compute(name);
286        if (isFinal && num == state().boundariesCrossed) {
287          importedMethods_String_values.put(_parameters, importedMethods_String_value);
288        } else {
289        }
290        state.INTERMEDIATE_VALUE |= intermediate;
291    
292        return importedMethods_String_value;
293      }
294      /**
295       * @apilevel internal
296       */
297      private Collection importedMethods_compute(String name) {
298          Collection set = new HashSet();
299          for (Iterator iter = type().memberMethods(name).iterator(); iter.hasNext(); ) {
300            MethodDecl decl = (MethodDecl) iter.next();
301            if (decl.isStatic() &&
302               (decl.isPublic() || (!decl.isPrivate() && decl.hostType().topLevelType().packageName().equals(packageName()))))
303              set.add(decl);
304          }
305          return set;
306        }
307      /**
308       * @apilevel internal
309       */
310      public ASTNode rewriteTo() {
311        return super.rewriteTo();
312      }
313    }