/**
   * Filter a list of VolumeDescriptors by type(s).
   *
   * @param descriptors -- Original list.
   * @param inclusive -- Types to be included (or null if not used).
   * @param exclusive -- Types to be excluded (or null if not used).
   * @return List<VolumeDescriptor>
   */
  public static List<VolumeDescriptor> filterByType(
      List<VolumeDescriptor> descriptors, Type[] inclusive, Type[] exclusive) {
    List<VolumeDescriptor> result = new ArrayList<VolumeDescriptor>();
    if (descriptors == null) {
      return result;
    }

    HashSet<Type> included = new HashSet<Type>();
    if (inclusive != null) {
      included.addAll(Arrays.asList(inclusive));
    }
    HashSet<Type> excluded = new HashSet<Type>();
    if (exclusive != null) {
      excluded.addAll(Arrays.asList(exclusive));
    }
    for (VolumeDescriptor desc : descriptors) {
      if (excluded.contains(desc.getType())) {
        continue;
      }
      if (included.isEmpty() || included.contains(desc.getType())) {
        result.add(desc);
      }
    }
    return result;
  }
Ejemplo n.º 2
0
  private List<WasInfluencedBy> createInfluence(
      QualifiedName context, QualifiedName qualifiedName) {
    HashSet<QualifiedName> all_influencers = new HashSet<QualifiedName>();
    List<QualifiedName> influencers =
        getObjects(context, qualifiedName, onto.QualifiedName_PROVO_influencer);
    List<QualifiedName> agents = getObjects(context, qualifiedName, onto.QualifiedName_PROVO_agent);
    List<QualifiedName> entities =
        getObjects(context, qualifiedName, onto.QualifiedName_PROVO_entity);
    List<QualifiedName> activities =
        getObjects(context, qualifiedName, onto.QualifiedName_PROVO_activity);
    all_influencers.addAll(influencers);
    all_influencers.addAll(agents);
    all_influencers.addAll(entities);
    all_influencers.addAll(activities);
    List<QualifiedName> influencees =
        getSubjects(context, onto.QualifiedName_PROVO_qualifiedInfluence, qualifiedName);

    List<Attribute> attributes =
        collectAttributes(context, qualifiedName, Types.ProvType.INFLUENCE);

    qualifiedName = getQualqualifiedName(qualifiedName);

    List<WasInfluencedBy> wibs = new ArrayList<WasInfluencedBy>();
    List<List<?>> perms = permute(influencees, new ArrayList<QualifiedName>(all_influencers));
    for (List<?> perm : perms) {
      WasInfluencedBy wib =
          pFactory.newWasInfluencedBy(
              qualifiedName, (QualifiedName) perm.get(0), (QualifiedName) perm.get(1), attributes);
      store(context, wib);
      wibs.add(wib);
    }
    return wibs;
  }
Ejemplo n.º 3
0
  public static void updateSensors(MMMinecart minecart, MMMinecart input) {

    HashSet<Block> blockList = minecart.getAdjacentBlocks(1);
    blockList.addAll(minecart.getBlocksBeneath(3));
    HashSet<Block> oldBlockList = minecart.getPreviousLocationAdjacentBlocks(1);
    oldBlockList.addAll(minecart.getPreviousLocationBlocksBeneath(3));
    oldBlockList.removeAll(blockList);

    // Activate new sensors
    for (Block block : blockList) {
      Sensor s = SensorManager.getSensor(block);
      if (s != null) {
        try {
          s.input(input);
        } catch (Exception e) {
          SensorManager.delSensor(s.getLocation());
        }
      }
    }

    // deactivate old sensors
    for (Block block : oldBlockList) {
      Sensor s = SensorManager.getSensor(block);
      if (s != null) {
        try {
          s.input(null);
        } catch (Exception e) {
          SensorManager.delSensor(s.getLocation());
        }
      }
    }
  }
 @Override
 public void execute() {
   clearLocalCache();
   session = VeggieDinner.getSession();
   if (session == null || session.getUser() == null) return;
   me = VeggieDinner.getUser(session.getUser());
   if (me == null) {
     VeggieDinner.requestNewUser(session.getUser(), populateLocalCache);
     return;
   }
   boolean hasAll = true;
   myGroupDTOs.addAll(VeggieDinner.getGroups(me.getGroups()).values());
   myEventDTOs.addAll(VeggieDinner.getEvents(me.getSchedule()).values());
   myEventDTOs.addAll(VeggieDinner.getEvents(getEventsFromGroups(myGroupDTOs)).values());
   myCohosts.addAll(VeggieDinner.getUsers(getHostsFromGroups(myGroupDTOs)).values());
   if (!myGroupDTOs.containsAll(me.getGroups())) {
     VeggieDinner.requestNewGroup(me.getGroups(), populateLocalCache);
     return;
   }
   if (!myEventDTOs.containsAll(me.getSchedule())
       || !myEventDTOs.containsAll(getEventsFromGroups(myGroupDTOs))) {
     HashSet<Key<EventDTO>> events = getEventsFromGroups(myGroupDTOs);
     events.addAll(me.getSchedule());
     VeggieDinner.requestNewEvent(events, populateLocalCache);
     return;
   }
   if (!myCohosts.containsAll(getHostsFromGroups(myGroupDTOs))) {
     VeggieDinner.requestNewUser(getHostsFromGroups(myGroupDTOs), populateLocalCache);
     return;
   }
   DeferredCommand.addCommand(updateMyStuff);
 }
Ejemplo n.º 5
0
 @Override
 public synchronized ClassHierarchy merge(final ClassHierarchy ch) {
   if (this == ch) {
     return this;
   }
   if (!(ch instanceof ClassHierarchyImpl)) {
     throw new UnsupportedOperationException(
         "Can't merge java and non-java class hierarchies yet!");
   }
   if (this.jars.size() == 0) {
     return ch;
   }
   final ClassHierarchyImpl chi = (ClassHierarchyImpl) ch;
   final HashSet<URL> otherJars = new HashSet<>();
   otherJars.addAll(chi.jars);
   final HashSet<URL> myJars = new HashSet<>();
   myJars.addAll(this.jars);
   if (myJars.containsAll(otherJars)) {
     return this;
   } else if (otherJars.containsAll(myJars)) {
     return ch;
   } else {
     myJars.addAll(otherJars);
     return new ClassHierarchyImpl(myJars.toArray(new URL[0]));
   }
 }
Ejemplo n.º 6
0
  /**
   * Uses recurson to get the depth of the input synset (in 'getSynsetDepth()') from a <root> A
   * synset may have multiple parents, thus we returneach possible depth and 'home hierarchy' <root>
   * Thus, we may have the same <root> at different depths in the WordNet hierarchy
   */
  private void treecreeper(
      int depth,
      HashSet<ISynsetID> synsets,
      TreeMap<Integer, HashSet<ISynsetID>> depths,
      ArrayList<Integer> roots) {
    depth++;
    ISynset synset = null;
    HashSet<ISynsetID> hypernyms = new HashSet<ISynsetID>(); // next 'level'(inverse of 'depth')
    for (ISynsetID s : synsets) {
      synset = dict.getSynset(s);
      hypernyms.addAll(synset.getRelatedSynsets(Pointer.HYPERNYM)); // get the <hypernyms>
      hypernyms.addAll(
          synset.getRelatedSynsets(Pointer.HYPERNYM_INSTANCE)); // get the <hypernyms> (instances)
    }

    if (!hypernyms.isEmpty()) {
      for (ISynsetID h : hypernyms) {
        int offset = h.getOffset();
        if (roots.contains(offset)) {
          if (depths.containsKey(depth)) {
            HashSet<ISynsetID> deep = depths.get(depth);
            deep.add(h);
            depths.put(depth, deep);
          } else {
            HashSet<ISynsetID> deep = new HashSet<ISynsetID>();
            deep.add(h);
            depths.put(depth, deep);
          }
        }
      }
      treecreeper(depth, hypernyms, depths, roots);
    }
    return;
  }
Ejemplo n.º 7
0
  public SemanticHeadFinder(TreebankLanguagePack tlp, boolean cop) {
    super(tlp);
    ruleChanges();
    // make a distinction between auxiliaries and copular verbs to
    // get the NP has semantic head in sentences like "Bill is an honest man".
    verbalAuxiliaries = new HashSet<String>();
    verbalAuxiliaries.addAll(
        Arrays.asList(
            new String[] {
              "will", "wo", "shall", "may", "might", "should", "would", "can", "could", "ca",
              "must", "has", "have", "had", "having", "be", "being", "been", "get", "gets",
              "getting", "got", "gotten", "do", "does", "did", "to", "'ve", "'d", "'ll"
            }));

    // copular verbs having an NP complement
    copulars = new HashSet<String>();
    if (cop) {
      copulars.addAll(
          Arrays.asList(
              new String[] {
                "be",
                "being",
                "Being",
                "am",
                "are",
                "is",
                "was",
                "were",
                "'m",
                "'re",
                "'s",
                "s",
                "seem",
                "seems",
                "seemed",
                "appear",
                "appears",
                "appeared",
                "stay",
                "stays",
                "stayed",
                "remain",
                "remains",
                "remained",
                "resemble",
                "resembles",
                "resembled",
                "become",
                "becomes",
                "became"
              }));
    } // a few times the apostrophe is missing on "'s"

    verbalTags = new HashSet<String>();
    // include Charniak tags so can do BLLIP right
    verbalTags.addAll(
        Arrays.asList(
            new String[] {"TO", "MD", "VB", "VBD", "VBP", "VBZ", "VBG", "VBN", "AUX", "AUXG"}));
  }
Ejemplo n.º 8
0
  public Collection<Property> getProperties(JClassType type) {
    HashSet<Property> properties = new HashSet<Property>();

    properties.addAll(MethodProperty.findProperties(type));
    properties.addAll(FieldProperty.findProperties(type));

    return properties;
  }
Ejemplo n.º 9
0
 public HashSet<String> getUnstemmedFilterSet() {
   if (unstemmedfilterset == null) {
     unstemmedfilterset = new HashSet<String>();
     unstemmedfilterset.addAll(StopWordsSmart.getUnstemmedFilterSet());
     unstemmedfilterset.addAll(StopWordsLetter.getUnstemmedFilterSet());
   }
   return unstemmedfilterset;
 }
Ejemplo n.º 10
0
 /** returns all GeoElement objects in the both coordinate subtrees */
 public HashSet getVariables() {
   HashSet temp, varset = x.getVariables();
   if (varset == null) varset = new HashSet();
   temp = y.getVariables();
   if (temp != null) varset.addAll(temp);
   temp = z.getVariables();
   if (temp != null) varset.addAll(temp);
   return varset;
 }
Ejemplo n.º 11
0
 public Set<K> keySet() {
   if (parent == null) {
     return inner.keySet();
   }
   HashSet<K> tmp = new HashSet<K>();
   tmp.addAll(parent.keySet());
   tmp.addAll(inner.keySet());
   return tmp;
 }
Ejemplo n.º 12
0
 @Override
 public Enumeration<URL> findResources(String name) throws IOException {
   final HashSet<URL> urls = new HashSet<>();
   for (PomClassLoader cl : parents) {
     urls.addAll(Collections.list(cl.findResources(name)));
   }
   urls.addAll(Collections.list(super.findResources(name)));
   return Collections.enumeration(urls);
 }
Ejemplo n.º 13
0
 /** Get an alphabetically sorted list of field names. */
 public List<String> getFieldNames() {
   HashSet<String> names = new HashSet<String>();
   names.addAll(storedFields.keySet());
   names.addAll(reconstructedFields.keySet());
   ArrayList<String> res = new ArrayList<String>(names.size());
   res.addAll(names);
   Collections.sort(res);
   return res;
 }
Ejemplo n.º 14
0
 @Override
 public HashSet<IdentifierExpression> getFreeVariables() {
   HashSet<IdentifierExpression> ret = new HashSet<IdentifierExpression>();
   for (int i = 0; i < this.indices.length; i++) {
     ret.addAll(this.indices[i].getFreeVariables());
   }
   ret.addAll(this.array.getFreeVariables());
   return ret;
 }
 /**
  * delegate for ServletContext.declareRole method
  *
  * @param roleNames role names to add
  */
 protected void addRoles(String... roleNames) {
   // Get a reference to the SecurityHandler, which must be ConstraintAware
   if (_securityHandler != null && _securityHandler instanceof ConstraintAware) {
     HashSet<String> union = new HashSet<String>();
     Set<String> existing = ((ConstraintAware) _securityHandler).getRoles();
     if (existing != null) union.addAll(existing);
     union.addAll(Arrays.asList(roleNames));
     ((ConstraintSecurityHandler) _securityHandler).setRoles(union);
   }
 }
Ejemplo n.º 16
0
  private boolean directedCompute() {

    SortedSet<Integer> degrees = new TreeSet<Integer>();
    for (IElement iE : g.getNodes()) {
      DirectedNode n = (DirectedNode) iE;
      int degree = n.getOutDegree();

      degrees.add(degree);
      if (nodesSortedByDegree.containsKey(degree)) {
        this.nodesSortedByDegree.get(degree).add(n);
      } else {
        LinkedList<Node> temp = new LinkedList<>();
        temp.add(n);
        this.nodesSortedByDegree.put(degree, temp);
      }
    }

    HashSet<Node> currentRichClub = new HashSet<Node>();
    int currentRichClubSize = 0;
    int size = degrees.size();
    for (int i = 0; i < size; i++) {
      int currentDegree = degrees.last();
      degrees.remove(currentDegree);
      LinkedList<Node> current = this.nodesSortedByDegree.get(currentDegree);
      currentRichClubSize += current.size();
      this.nodesSortedByDegree.remove(currentDegree);

      if (currentRichClubSize >= this.richClubSize) {
        int seperateAT = current.size() - (currentRichClubSize - this.richClubSize);
        LinkedList<Node> temp = new LinkedList<>();
        temp.addAll(current.subList(0, seperateAT));
        this.richClub.put(currentDegree, temp);
        currentRichClub.addAll(temp);
        LinkedList<Node> temp2 = new LinkedList<>();
        temp2.addAll(current.subList(seperateAT, current.size()));
        if (!temp2.isEmpty()) this.nodesSortedByDegree.put(currentDegree, (LinkedList<Node>) temp2);
        break;
      } else {
        richClub.put(currentDegree, current);
        currentRichClub.addAll(current);
      }
    }

    for (Node n : currentRichClub) {
      DirectedNode ne = (DirectedNode) n;
      for (IElement iE : ne.getOutgoingEdges()) {
        DirectedEdge e = (DirectedEdge) iE;
        if (currentRichClub.contains(e.getDst())) {
          edgesBetweenRichClub++;
        }
      }
    }
    return true;
  }
Ejemplo n.º 17
0
  /**
   * This function takes a class uri and returns the object properties who have this class in their
   * domain. If second parameter set to True, it also returns the object properties inherited from
   * parents of the given class.
   *
   * @param domainUri
   * @param inheritance
   * @return
   */
  public HashSet<String> getObjectPropertiesOfClass(String domainUri, boolean inheritance) {

    HashSet<String> direct = ontCache.getDirectOutObjectProperties().get(domainUri);
    if (!inheritance) return direct;

    HashSet<String> all = new HashSet<String>();
    HashSet<String> indirect = ontCache.getIndirectOutObjectProperties().get(domainUri);
    if (direct != null) all.addAll(direct);
    if (indirect != null) all.addAll(indirect);
    return all;
  }
Ejemplo n.º 18
0
 public Map getObjectToCopyMap() {
   HashSet objects = new HashSet(baseToBackupVariabilityElementMap.keySet());
   objects.addAll(baseToVariabilityElementMap.keySet());
   objects.addAll(keySet());
   Map map = new HashMap();
   for (Iterator iter = objects.iterator(); iter.hasNext(); ) {
     Object object = iter.next();
     map.put(object, getCopy((EObject) object));
   }
   return map;
 }
Ejemplo n.º 19
0
  public void conjoinAllNeighbors() {
    if (!this.isCeiling()) {
      this.conjoinedelevators.clear();
      HashSet var1 = new HashSet();
      this.conjoinedelevators.addAll(this.getNeighbors());
      var1.addAll(this.conjoinedelevators);
      var1.remove(this);
      Iterator var2;

      while (!var1.isEmpty()) {
        var2 = var1.iterator();
        HashSet var3 = new HashSet();

        while (var2.hasNext()) {
          EntityElevator var4 = (EntityElevator) var2.next();
          var3.addAll(var4.getNeighbors());
        }

        var1.clear();
        var3.removeAll(this.conjoinedelevators);
        this.conjoinedelevators.addAll(var3);
        var1.addAll(var3);
      }

      var2 = this.conjoinedelevators.iterator();

      while (var2.hasNext()) {
        EntityElevator var5 = (EntityElevator) var2.next();

        if (!var5.center && !this.isClient) {
          var5.center = false;
          var5.centerElevator = this;

          if (var5.ceiling != null) {
            var5.ceiling.centerElevator = this;
            var5.ceiling.conjoinedHasBeenSet = true;
            var5.ceiling.center = false;
          }
        } else {
          var5.setConjoined(this.conjoinedelevators);
          var5.centerElevator = var5;

          if (var5.ceiling != null) {
            var5.ceiling.centerElevator = var5;
            var5.ceiling.conjoinedHasBeenSet = true;
          }

          var5.center = true;
        }
      }

      this.conjoinedHasBeenSet = true;
    }
  }
Ejemplo n.º 20
0
  /**
   * Makes index snapshot hashsets
   *
   * @return result
   */
  public synchronized boolean makeIndexSnapshot() {
    if (!indexSnapshotDone && !DumbService.isDumb(myProject)) {
      KNOWN_SUBS.addAll(PerlSubUtil.getDeclaredSubsNames(myProject));
      KNOWN_SUBS.addAll(PerlSubUtil.getDefinedSubsNames(myProject));
      KNOWN_SUBS.addAll(PerlGlobUtil.getDefinedGlobsNames(myProject));

      KNOWN_PACKAGES.addAll(PerlPackageUtil.getDefinedPackageNames(myProject));
      indexSnapshotDone = true;
    }
    return indexSnapshotDone;
  }
Ejemplo n.º 21
0
  public List<String> parse(Tweet t) {

    match = new HashSet<String>();
    List<String> nerresult = ner.parse(t);
    List<String> stbdresult = stbd.parse(t);
    List<String> toporesult = tp.parse(t);
    match.addAll(nerresult);
    match.addAll(stbdresult);
    //		match.addAll(toporesult);

    return ParserUtils.ResultReduce(new ArrayList<String>(match));
  }
Ejemplo n.º 22
0
 private static void assertPropertyEquals(SNode expectedNode, SNode actualNode) {
   HashSet<String> propertes = new HashSet<String>();
   propertes.addAll(IterableUtil.asCollection(expectedNode.getPropertyNames()));
   propertes.addAll(IterableUtil.asCollection(actualNode.getPropertyNames()));
   for (String key : propertes) {
     String expectedProperty =
         jetbrains.mps.util.SNodeOperations.getProperties(expectedNode).get(key);
     String actualProperty = jetbrains.mps.util.SNodeOperations.getProperties(actualNode).get(key);
     assertEquals(
         getErrorString("property", expectedNode, actualNode), expectedProperty, actualProperty);
   }
 }
Ejemplo n.º 23
0
    public boolean addAll(Set oset) {
      if (oset.empty) return true;
      empty = false;

      if (delegating) {
        if (oset.delegating) return delegate.addAll(oset.delegate);
        else return delegate.add(oset.oneState);
      } else {
        beginDelegation();
        if (oset.delegating) return delegate.addAll(oset.delegate);
        else return delegate.add(oset.oneState);
      }
    }
Ejemplo n.º 24
0
 public static <T> HashSet<T> newHashSet(Iterable<T> iterable) {
   HashSet<T> newHashSet = new HashSet<T>();
   if (iterable instanceof Set<?>) {
     newHashSet.addAll((Set<T>) iterable);
   } else if (iterable instanceof List<?>) {
     newHashSet.addAll((List<T>) iterable);
   } else {
     for (T element : iterable) {
       newHashSet.add(element);
     }
   }
   return newHashSet;
 }
Ejemplo n.º 25
0
  /**
   * This method takes a property URI and returns ranges of that property. If @param recursive is
   * true, it also returns the children of the domains.
   *
   * @param propertyUri
   * @param recursive
   * @return
   */
  public HashSet<String> getRangesOfProperty(String propertyUri, boolean recursive) {

    HashSet<String> results = new HashSet<String>();
    HashSet<String> direct = null;
    HashSet<String> indirect = null;

    direct = ontCache.getPropertyDirectRanges().get(propertyUri);
    if (direct != null) results.addAll(direct);
    if (recursive) indirect = ontCache.getPropertyIndirectRanges().get(propertyUri);
    if (indirect != null) results.addAll(indirect);

    return results;
  }
Ejemplo n.º 26
0
 public Cluster(JoinGraph.Node u) {
   // Constructor for cluster(u)
   this.node = u;
   // add to the cluster all CPTs of the given node
   for (CPF cpf : u.functions) cpts.add(cpf.getDomainProduct()[0]);
   // add all incoming messages of n
   for (JoinGraph.Node nb : u.getNeighbors()) {
     JoinGraph.Arc arc = u.arcs.get(nb);
     HashSet<MessageFunction> m = arc.getInMessage(u);
     if (!m.isEmpty()) functions.addAll(m);
     HashSet<BeliefNode> bn = arc.getCPTInMessage(u);
     if (!bn.isEmpty()) cpts.addAll(bn);
   }
 }
Ejemplo n.º 27
0
  public static ArrayList<String> getLexicalTransformations(String original) {
    HashSet<String> outs = new HashSet<String>();

    if (original.isEmpty()) return new ArrayList<String>(outs);

    HashSet<String> news = new HashSet<String>();

    String canonical = Common.canonicalizeString(original);

    outs.add(canonical);

    // now other things

    String parenthesisLess = Common.removeParenthesis(canonical);

    String halfSpaceLess = canonical.replace('\u200C', ' ');

    String spaceLess = canonical.replace(' ', '\u200C');

    String puncLess = Common.removePunctuations(canonical);

    outs.addAll(news);
    news.clear();

    for (String probe : outs) {
      probe = probe.replaceAll("\\bعلیهالسلام\\b", "");
      probe = probe.replaceAll("\\bعلیها السلام\\b", "");
      probe = probe.replaceAll("\\bعلیه السلام\\b", "");
      probe = probe.replaceAll("\\bعلیه‌السلام\\b", "");
      probe = probe.replaceAll("\\(\\s*ع\\s*\\)", "");
      probe = probe.replaceAll("\\(\\s*س\\s*\\)", "");
      probe = probe.replaceAll("\\(\\s*ص\\s*\\)", "");
      probe = probe.replaceAll("\\bصلی الله علیه وآله\\b", "");
      probe = probe.replaceAll("\\bصلی الله علیه و آله\\b", "");
      probe = probe.replaceAll("\\bصلی الله علیه و آله و سلم\\b", "");
      probe = probe.replaceAll("\\bصلی الله علیه وآله و سلم\\b", "");
      probe = probe.replaceAll("\\bصلی الله علیه وآله وسلم\\b", "");
      probe = probe.replace("()", "");
      probe = probe.replace("(  )", ""); // tokenized version

      news.addAll(probeLexicalTransformation(probe, outs));
    }

    outs.addAll(news);
    news.clear();

    outs.remove(original);

    return new ArrayList<String>(outs);
  }
Ejemplo n.º 28
0
  // Declared in AnonymousClasses.jrag at line 52
  private AnonymousDecl rewriteRule0() {
    {
      setModifiers(new Modifiers(new List().add(new Modifier("final"))));

      ConstructorDecl constructor = new ConstructorDecl();
      addBodyDecl(constructor);

      constructor.setModifiers((Modifiers) constructorDecl().getModifiers().fullCopy());
      String name = "Anonymous" + nextAnonymousIndex();
      setID(name);
      constructor.setID(name);

      List parameterList = new List();
      for (int i = 0; i < constructorDecl().getNumParameter(); i++) {
        parameterList.add(
            new ParameterDeclaration(
                constructorDecl().getParameter(i).type().createBoundAccess(),
                constructorDecl().getParameter(i).name()));
      }
      constructor.setParameterList(parameterList);

      List argList = new List();
      for (int i = 0; i < constructor.getNumParameter(); i++)
        argList.add(new VarAccess(constructor.getParameter(i).name()));
      constructor.setConstructorInvocation(
          new ExprStmt(new SuperConstructorAccess("super", argList)));
      constructor.setBlock(new Block());

      HashSet set = new HashSet();
      for (int i = 0; i < getNumBodyDecl(); i++) {
        if (getBodyDecl(i) instanceof InstanceInitializer) {
          InstanceInitializer init = (InstanceInitializer) getBodyDecl(i);
          set.addAll(init.exceptions());
        } else if (getBodyDecl(i) instanceof FieldDeclaration) {
          FieldDeclaration f = (FieldDeclaration) getBodyDecl(i);
          if (f.isInstanceVariable()) {
            set.addAll(f.exceptions());
          }
        }
      }
      List exceptionList = new List();
      for (Iterator iter = set.iterator(); iter.hasNext(); ) {
        TypeDecl exceptionType = (TypeDecl) iter.next();
        if (exceptionType.isNull()) exceptionType = typeNullPointerException();
        exceptionList.add(exceptionType.createQualifiedAccess());
      }
      constructor.setExceptionList(exceptionList);
      return this;
    }
  }
 protected Set<Long> getNodeIdsInRelation(Relation r) {
   HashSet<Long> ret = new HashSet<Long>();
   if (r == null) return ret;
   for (RelationMember m : r.getMembers()) {
     if (m.isNode()) {
       ret.add(m.getMember().getId());
     } else if (m.isWay()) {
       ret.addAll(getNodeIdsInWay(m.getWay()));
     } else if (m.isRelation()) {
       ret.addAll(getNodeIdsInRelation(m.getRelation()));
     }
   }
   return ret;
 }
  /**
   * Find the upwards and downwards transitive closure for each node in a graph. Assumes the graph
   * is a DAG in general, but handles cycles (which may occur in the case of meta-annotations).
   * Updates the allSubNodes and allSuperNodes fields of each node based on the downwards and
   * upwards transitive closures respectively.
   */
  public static void findTransitiveClosure(final Collection<? extends DAGNode> nodes) {
    // Find top nodes as initial active set
    HashSet<DAGNode> activeTopDownNodes = new HashSet<>();
    for (final DAGNode node : nodes) {
      if (node.directSuperNodes.isEmpty()) {
        activeTopDownNodes.addAll(node.directSubNodes);
      }
    }
    // Use DP-style "wavefront" to find top-down transitive closure, even if there are cycles
    while (!activeTopDownNodes.isEmpty()) {
      final HashSet<DAGNode> activeTopDownNodesNext = new HashSet<>(activeTopDownNodes.size());
      for (final DAGNode node : activeTopDownNodes) {
        boolean changed = node.allSuperNodes.addAll(node.directSuperNodes);
        for (final DAGNode superNode : node.directSuperNodes) {
          changed |= node.allSuperNodes.addAll(superNode.allSuperNodes);
        }
        if (changed) {
          for (final DAGNode subNode : node.directSubNodes) {
            activeTopDownNodesNext.add(subNode);
          }
        }
      }
      activeTopDownNodes = activeTopDownNodesNext;
    }

    // Find bottom nodes as initial active set
    HashSet<DAGNode> activeBottomUpNodes = new HashSet<>();
    for (final DAGNode node : nodes) {
      if (node.directSubNodes.isEmpty()) {
        activeBottomUpNodes.addAll(node.directSuperNodes);
      }
    }
    // Use DP-style "wavefront" to find bottom-up transitive closure, even if there are cycles
    while (!activeBottomUpNodes.isEmpty()) {
      final HashSet<DAGNode> activeBottomUpNodesNext = new HashSet<>(activeBottomUpNodes.size());
      for (final DAGNode node : activeBottomUpNodes) {
        boolean changed = node.allSubNodes.addAll(node.directSubNodes);
        for (final DAGNode subNode : node.directSubNodes) {
          changed |= node.allSubNodes.addAll(subNode.allSubNodes);
        }
        if (changed) {
          for (final DAGNode superNode : node.directSuperNodes) {
            activeBottomUpNodesNext.add(superNode);
          }
        }
      }
      activeBottomUpNodes = activeBottomUpNodesNext;
    }
  }