protected void closeWebDriver(Thread thread) {
    ALL_WEB_DRIVERS_THREADS.remove(thread);
    WebDriver webdriver = THREAD_WEB_DRIVER.remove(thread.getId());

    if (webdriver != null && !holdBrowserOpen) {
      log.info("Close webdriver: " + thread.getId() + " -> " + webdriver);

      long start = System.currentTimeMillis();

      Thread t = new Thread(new CloseBrowser(webdriver));
      t.setDaemon(true);
      t.start();

      try {
        t.join(closeBrowserTimeoutMs);
      } catch (InterruptedException e) {
        log.log(FINE, "Failed to close webdriver in " + closeBrowserTimeoutMs + " milliseconds", e);
      }

      long duration = System.currentTimeMillis() - start;
      if (duration >= closeBrowserTimeoutMs) {
        log.severe("Failed to close webdriver in " + closeBrowserTimeoutMs + " milliseconds");
      } else if (duration > 200) {
        log.info("Closed webdriver in " + duration + " ms");
      } else {
        log.fine("Closed webdriver in " + duration + " ms");
      }
    }
  }
示例#2
0
  public void testValuesRemove() {
    final Map<K, V> map;
    try {
      map = makePopulatedMap();
    } catch (UnsupportedOperationException e) {
      return;
    }

    Collection<V> valueCollection = map.values();
    if (supportsRemove) {
      int initialSize = map.size();
      valueCollection.remove(valueCollection.iterator().next());
      assertEquals(initialSize - 1, map.size());
      // (We can't assert that the values collection no longer contains the
      // removed value, because the underlying map can have multiple mappings
      // to the same value.)
    } else {
      try {
        valueCollection.remove(valueCollection.iterator().next());
        fail("Expected UnsupportedOperationException.");
      } catch (UnsupportedOperationException e) {
        // Expected.
      }
    }
    assertInvariants(map);
  }
  private List<IArc> generateArcsInstancesCaseNN(
      Collection<INode> sourcesNodes,
      Collection<INode> targetsNodes,
      AssociationDefinition associationDefinition) {
    List<IArc> arcsInstances = new ArrayList<IArc>();
    while (!sourcesNodes.isEmpty()) {
      INode source = RandomMethods.selectRandomlyNode(sourcesNodes);
      Collection<INode> tempTargetsNodes = targetsNodes;
      int numberOfArcs = 0;
      if (!targetsNodes.isEmpty()) {
        while (numberOfArcs < numberOfOutputArcs && /*
															 * targetsNodes.size(
															 * ) >=
															 * numberOfOutputArcs
															 */ !tempTargetsNodes.isEmpty()) {
          INode target = RandomMethods.selectRandomlyNode(targetsNodes);
          IArc arc = createRandomlyArc(source, target, associationDefinition);
          if (arc != null) {
            arcsInstances.add(arc);
            numberOfArcs++;
          }
          tempTargetsNodes.remove(target);
        }
      }
      sourcesNodes.remove(source);
    }
    return arcsInstances;
  }
示例#4
0
 /**
  * Recursive method. Add the parsed element group to the group collection. If the group contains
  * group-ref element, parse recursively this group.
  *
  * @param element Group Element to parse.
  * @param groups list of parsed groups where the parsed group is added..
  * @return list of resources associated with this resource
  */
 private Collection<Resource> parseGroup(final Element element, final Collection<Group> groups) {
   final String name = element.getAttribute(ATTR_GROUP_NAME);
   if (processingGroups.contains(name)) {
     throw new RecursiveGroupDefinitionException(
         "Infinite Recursion detected for the group: "
             + name
             + ". Recursion path: "
             + processingGroups);
   }
   processingGroups.add(name);
   LOG.debug("\tgroupName={}", name);
   // skip if this group is already parsed
   final Group parsedGroup = getGroupByName(name, groups);
   if (parsedGroup != null) {
     // remove before returning
     // this group is parsed, remove from unparsed groups collection
     processingGroups.remove(name);
     return parsedGroup.getResources();
   }
   final Group group = new Group(name);
   final List<Resource> resources = new ArrayList<Resource>();
   final NodeList resourceNodeList = element.getChildNodes();
   for (int i = 0; i < resourceNodeList.getLength(); i++) {
     final Node node = resourceNodeList.item(i);
     if (node instanceof Element) {
       final Element resourceElement = (Element) node;
       parseResource(resourceElement, resources, groups);
     }
   }
   group.setResources(resources);
   // this group is parsed, remove from unparsed collection
   processingGroups.remove(name);
   groups.add(group);
   return resources;
 }
  public static void checkObjects() {
    Collection<String> guilds = BasicUtils.getNames(GuildUtils.getGuilds());
    Collection<String> regions = BasicUtils.getNames(RegionUtils.getRegions());
    int i = 0;
    for (Guild guild : GuildUtils.getGuilds()) {
      if (guild.getName() != null && regions.contains(guild.getName())) {
        guilds.remove(guild.getName());
        continue;
      }
      GuildUtils.deleteGuild(guild);
      i++;
    }

    guilds = BasicUtils.getNames(GuildUtils.getGuilds());
    regions = BasicUtils.getNames(RegionUtils.getRegions());

    for (Region region : RegionUtils.getRegions()) {
      if (region.getName() != null && guilds.contains(region.getName())) {
        regions.remove(region.getName());
        continue;
      }
      RegionUtils.delete(region);
      i++;
    }
    if (i > 0) FunnyGuilds.warning("Repaired conflicts: " + i);
  }
示例#6
0
  public static <C extends OntologyClass> C getMostSpecializedClass(Collection<C> someClasses) {

    if (someClasses.size() == 0) {
      return null;
    }
    if (someClasses.size() == 1) {
      return someClasses.iterator().next();
    }
    OntologyClass[] array = someClasses.toArray(new OntologyClass[someClasses.size()]);

    for (int i = 0; i < someClasses.size(); i++) {
      for (int j = i + 1; j < someClasses.size(); j++) {
        OntologyClass c1 = array[i];
        OntologyClass c2 = array[j];
        if (c1.isSuperClassOf(c2)) {
          someClasses.remove(c1);
          return getMostSpecializedClass(someClasses);
        }
        if (c2.isSuperClassOf(c1)) {
          someClasses.remove(c2);
          return getMostSpecializedClass(someClasses);
        }
      }
    }

    // No parent were found, take first item
    logger.warning("Undefined specializing criteria between " + someClasses);
    return someClasses.iterator().next();
  }
 private List<IArc> generateArcsInstancesCase11(
     Collection<INode> sourcesNodes,
     Collection<INode> targetsNodes,
     AssociationDefinition associationDefinition,
     Collection<AssociationDefinition> associations,
     Collection<IArc> generatedArcs) {
   List<IArc> arcsInstances = new ArrayList<IArc>();
   if (numberOfOutputArcs > 0) {
     while (!sourcesNodes.isEmpty() && !targetsNodes.isEmpty()) {
       INode source = RandomMethods.selectRandomlyNode(sourcesNodes);
       INode target = RandomMethods.selectRandomlyNode(targetsNodes);
       IArc arc = createRandomlyArc(source, target, associationDefinition);
       AssociationDefinition invAssoc =
           generatorServices.searchInverseAssoc(
               source, target, associationDefinition, associations);
       if (invAssoc != null) {
         IArc invArc =
             generatorServices.getInverseGeneratedArc(source, target, invAssoc, generatedArcs);
         if (invArc != null) {
           arc = null;
         }
       }
       if (arc != null) {
         arcsInstances.add(arc);
       }
       sourcesNodes.remove(source);
       targetsNodes.remove(target);
     }
   }
   return arcsInstances;
 }
  /**
   * Schedules runnable task for execution.
   *
   * @param w Runnable task.
   * @throws IgniteCheckedException Thrown if any exception occurred.
   */
  @SuppressWarnings({"CatchGenericClass", "ProhibitedExceptionThrown"})
  public void execute(final GridWorker w) throws IgniteCheckedException {
    workers.add(w);

    try {
      exec.execute(
          new Runnable() {
            @Override
            public void run() {
              try {
                w.run();
              } finally {
                workers.remove(w);
              }
            }
          });
    } catch (RejectedExecutionException e) {
      workers.remove(w);

      throw new ComputeExecutionRejectedException(
          "Failed to execute worker due to execution rejection.", e);
    } catch (RuntimeException e) {
      workers.remove(w);

      throw new IgniteCheckedException("Failed to execute worker due to runtime exception.", e);
    } catch (Error e) {
      workers.remove(w);

      throw e;
    }
  }
示例#9
0
    @Override
    protected void realRun() {
      try {
        foundMatches = 0;
        SearchCompiler.Match matcher = SearchCompiler.compile(setting);

        if (setting.mode == SearchMode.replace) {
          selection.clear();
        } else if (setting.mode == SearchMode.in_selection) {
          foundMatches = selection.size();
        }

        Collection<OsmPrimitive> all;
        if (setting.allElements) {
          all = ds.allPrimitives();
        } else {
          all = ds.getPrimitives(OsmPrimitive::isSelectable);
        }
        final ProgressMonitor subMonitor =
            getProgressMonitor().createSubTaskMonitor(all.size(), false);
        subMonitor.beginTask(
            trn("Searching in {0} object", "Searching in {0} objects", all.size(), all.size()));

        for (OsmPrimitive osm : all) {
          if (canceled) {
            return;
          }
          if (setting.mode == SearchMode.replace) {
            if (matcher.match(osm)) {
              selection.add(osm);
              ++foundMatches;
            }
          } else if (setting.mode == SearchMode.add && !predicate.test(osm) && matcher.match(osm)) {
            selection.add(osm);
            ++foundMatches;
          } else if (setting.mode == SearchMode.remove
              && predicate.test(osm)
              && matcher.match(osm)) {
            selection.remove(osm);
            ++foundMatches;
          } else if (setting.mode == SearchMode.in_selection
              && predicate.test(osm)
              && !matcher.match(osm)) {
            selection.remove(osm);
            --foundMatches;
          }
          subMonitor.worked(1);
        }
        subMonitor.finishTask();
      } catch (ParseError e) {
        Main.debug(e);
        JOptionPane.showMessageDialog(
            Main.parent, e.getMessage(), tr("Error"), JOptionPane.ERROR_MESSAGE);
      }
    }
  public void markAsAcknowledged(long messageNumber) {
    updateLastActivityTime();

    try {
      lockWrite();
      receivedUnackedMessageNumbers.remove(messageNumber);
      allUnackedMessageNumbers.remove(messageNumber);
    } finally {
      unlockWrite();
    }
  }
示例#11
0
  // Update roles and protocolMappers to given consentEntity from the consentModel
  private void updateGrantedConsentEntity(
      UserConsentEntity consentEntity, UserConsentModel consentModel) {
    Collection<UserConsentProtocolMapperEntity> grantedProtocolMapperEntities =
        consentEntity.getGrantedProtocolMappers();
    Collection<UserConsentProtocolMapperEntity> mappersToRemove =
        new HashSet<UserConsentProtocolMapperEntity>(grantedProtocolMapperEntities);

    for (ProtocolMapperModel protocolMapper : consentModel.getGrantedProtocolMappers()) {
      UserConsentProtocolMapperEntity grantedProtocolMapperEntity =
          new UserConsentProtocolMapperEntity();
      grantedProtocolMapperEntity.setUserConsent(consentEntity);
      grantedProtocolMapperEntity.setProtocolMapperId(protocolMapper.getId());

      // Check if it's already there
      if (!grantedProtocolMapperEntities.contains(grantedProtocolMapperEntity)) {
        em.persist(grantedProtocolMapperEntity);
        em.flush();
        grantedProtocolMapperEntities.add(grantedProtocolMapperEntity);
      } else {
        mappersToRemove.remove(grantedProtocolMapperEntity);
      }
    }
    // Those mappers were no longer on consentModel and will be removed
    for (UserConsentProtocolMapperEntity toRemove : mappersToRemove) {
      grantedProtocolMapperEntities.remove(toRemove);
      em.remove(toRemove);
    }

    Collection<UserConsentRoleEntity> grantedRoleEntities = consentEntity.getGrantedRoles();
    Set<UserConsentRoleEntity> rolesToRemove =
        new HashSet<UserConsentRoleEntity>(grantedRoleEntities);
    for (RoleModel role : consentModel.getGrantedRoles()) {
      UserConsentRoleEntity consentRoleEntity = new UserConsentRoleEntity();
      consentRoleEntity.setUserConsent(consentEntity);
      consentRoleEntity.setRoleId(role.getId());

      // Check if it's already there
      if (!grantedRoleEntities.contains(consentRoleEntity)) {
        em.persist(consentRoleEntity);
        em.flush();
        grantedRoleEntities.add(consentRoleEntity);
      } else {
        rolesToRemove.remove(consentRoleEntity);
      }
    }
    // Those roles were no longer on consentModel and will be removed
    for (UserConsentRoleEntity toRemove : rolesToRemove) {
      grantedRoleEntities.remove(toRemove);
      em.remove(toRemove);
    }

    em.flush();
  }
 private void validateUnion(Collection<Type> result, Collection<Type> c1, Collection<Type> c2) {
   Assert.assertEquals(c1.size() + c2.size(), result.size());
   for (Type t : c1) {
     Assert.assertTrue(result.contains(t));
     result.remove(t);
   }
   for (Type t : c2) {
     Assert.assertTrue(result.contains(t));
     result.remove(t);
   }
   Assert.assertEquals(result.size(), 0);
 }
  public void removeEvent(RosterEventType type, String entry) {

    switch (type) {
      case ADDED:
        entriesAdded.remove(entry);
      case DELETED:
        entriesDeleted.remove(entry);
      case UPDATED:
        entriesUpdated.remove(entry);
      case PRESENCE:
        presenceChanged.remove(entry);
    }
  }
 /** Removes a listener for updated cluster states. */
 public void remove(ClusterStateListener listener) {
   clusterStateListeners.remove(listener);
   priorityClusterStateListeners.remove(listener);
   lastClusterStateListeners.remove(listener);
   postAppliedListeners.remove(listener);
   for (Iterator<NotifyTimeout> it = onGoingTimeouts.iterator(); it.hasNext(); ) {
     NotifyTimeout timeout = it.next();
     if (timeout.listener.equals(listener)) {
       timeout.cancel();
       it.remove();
     }
   }
 }
示例#15
0
  /** @see MutableAlignment#removeCell(Cell) */
  @Override
  public boolean removeCell(Cell cell) {
    boolean removed = cells.remove(cell);
    if (removed) {
      typeCells.remove(cell);

      idToCell.remove(cell.getId());

      // remove from maps
      internalRemoveFromMaps(cell.getSource(), cell);
      internalRemoveFromMaps(cell.getTarget(), cell);
    }

    return removed;
  }
示例#16
0
 /**
  * Clean the modified flag for the given iterator over a collection if it is in the list of
  * processed entries.
  *
  * @param it The iterator to change the modified and remove the items if deleted.
  * @param processed A list of all objects that have been successfully progressed. If the object in
  *     the iterator is not in the list, nothing will be changed on it.
  */
 private void cleanIterator(
     final Iterator<? extends OsmPrimitive> it, final Collection<OsmPrimitive> processed) {
   final OsmPrimitive osm = it.next();
   if (!processed.remove(osm)) return;
   osm.modified = false;
   if (osm.deleted) it.remove();
 }
示例#17
0
  private <T extends FactoryAccessor> void replaceIn(Object toReplace, T replacement, Object parent)
      throws IllegalArgumentException, IllegalAccessException {

    for (Field f : RtHelper.getAllFields(parent.getClass())) {
      f.setAccessible(true);
      Object tmp = f.get(parent);

      if (tmp != null) {
        if (tmp instanceof List) {
          @SuppressWarnings("unchecked")
          List<T> lst = (List<T>) tmp;
          for (int i = 0; i < lst.size(); i++) {
            if (lst.get(i) != null && compare(lst.get(i), toReplace)) {
              lst.remove(i);
              if (replacement != null) {
                lst.add(i, getReplacement(replacement, parent));
              }
            }
          }
        } else if (tmp instanceof Collection) {
          @SuppressWarnings("unchecked")
          Collection<T> collect = (Collection<T>) tmp;
          Object[] array = collect.toArray();
          for (Object obj : array) {
            if (compare(obj, toReplace)) {
              collect.remove(obj);
              collect.add(getReplacement(replacement, parent));
            }
          }
        } else if (compare(tmp, toReplace)) {
          f.set(parent, getReplacement(replacement, parent));
        }
      }
    }
  }
示例#18
0
 private void refreshList() {
   OWLModel owlModel = ((ImportWizard) getWizard()).getOWLModel();
   Collection availOntologies = new LinkedHashSet();
   for (Iterator it = owlModel.getRepositoryManager().getProjectRepositories().iterator();
       it.hasNext(); ) {
     Repository rep = (Repository) it.next();
     availOntologies.addAll(new TreeSet(rep.getOntologies()));
   }
   for (Iterator it = owlModel.getRepositoryManager().getGlobalRepositories().iterator();
       it.hasNext(); ) {
     Repository rep = (Repository) it.next();
     availOntologies.addAll(new TreeSet(rep.getOntologies()));
   }
   Collection importedOntologies = owlModel.getAllImports();
   for (Iterator it = availOntologies.iterator(); it.hasNext(); ) {
     URI uri = (URI) it.next();
     if (importedOntologies.contains(uri.toString())) {
       it.remove();
     }
   }
   try {
     availOntologies.remove(new URI(owlModel.getDefaultOWLOntology().getURI()));
   } catch (URISyntaxException e) {
     System.err.print(e.getMessage());
   }
   list.setListData(availOntologies.toArray());
 }
    @Override
    public void join(
        IntPair rec1, Tuple2<Integer, String> rec2, Collector<Tuple2<Integer, String>> out)
        throws Exception {
      final int k = rec1.getKey();
      final int v = rec1.getValue();

      final Integer key = rec2.f0;
      final String value = rec2.f1;

      Assert.assertTrue("Key does not match for matching IntPair Tuple combination.", k == key);

      Collection<TupleIntPairMatch> matches = this.toRemoveFrom.get(key);
      if (matches == null) {
        Assert.fail("Match " + key + " - " + v + ":" + value + " is unexpected.");
      }

      Assert.assertTrue(
          "Produced match was not contained: " + key + " - " + v + ":" + value,
          matches.remove(new TupleIntPairMatch(v, value)));

      if (matches.isEmpty()) {
        this.toRemoveFrom.remove(key);
      }
    }
示例#20
0
 public void testSkip_structurallyModifiedSkipSome() throws Exception {
   Collection<String> set = newLinkedHashSet(asList("a", "b", "c"));
   Iterable<String> tail = skip(set, 1);
   set.remove("b");
   set.addAll(newArrayList("A", "B", "C"));
   assertThat(tail).containsExactly("c", "A", "B", "C").inOrder();
 }
示例#21
0
 /**
  * Removes the given task from the calendar.
  *
  * @param taskId The identifier for the given task.
  * @throws IllegalArgumentException if the task is not found.
  */
 public void removeTask(String taskId) {
   CalendarTask toRemove = getTask(taskId);
   if (toRemove == null) {
     throw new IllegalArgumentException("Task to remove does not exist:" + taskId);
   }
   tasks.remove(toRemove);
 }
  @Override
  public String execute() throws Exception {
    Program program = programService.getProgram(programId);

    Collection<OrganisationUnit> orgunits = selectionTreeManager.getRootOrganisationUnits();

    program = programService.getProgram(programId);

    // ---------------------------------------------------------------------
    // Get orgunitIds
    // ---------------------------------------------------------------------

    Collection<Integer> orgunitIds = new HashSet<>();

    for (OrganisationUnit orgunit : orgunits) {
      if (facilityLB.equals("selected")) {
        orgunitIds.add(orgunit.getId());
      } else if (facilityLB.equals("childrenOnly")) {
        orgunitIds.addAll(
            organisationUnitService.getOrganisationUnitHierarchy().getChildren(orgunit.getId()));
        orgunitIds.remove(orgunit.getId());
      } else {
        orgunitIds.addAll(
            organisationUnitService.getOrganisationUnitHierarchy().getChildren(orgunit.getId()));
      }
    }

    if (orgunitIds.size() > 0) {
      grid =
          programStageInstanceService.getCompletenessProgramStageInstance(
              orgunitIds, program, startDate, endDate, i18n);
    }

    return (type == null) ? SUCCESS : type;
  }
示例#23
0
  public void testHtml5Model() throws ParseException {
    String code = "<!doctype html><title>hi</title>";
    HtmlParseResult result = parse(code);

    HtmlModel model = result.model();
    assertNotNull(model);
    //        assertEquals("html5model", model.getModelId());

    Collection<HtmlTag> all = model.getAllTags();
    assertNotNull(all);
    assertEquals(ElementDescriptor.values().length, all.size());

    HtmlTag table = HtmlTagProvider.getTagForElement("table");
    assertNotNull(table);

    assertTrue(all.contains(table));

    // try to modify the unmodifiable collection
    try {
      all.remove(table);
      assertTrue("The tags collection can be modified!", false);
    } catch (UnsupportedOperationException t) {
      // ok
    }
  }
  private void associateWithBuildRun(
      BuildRun buildRun, Collection<ChangeSet> changeSets, Set<PrimaryWorkitem> workitems) {
    for (ChangeSet changeSet : changeSets) {
      buildRun.getChangeSets().add(changeSet);
      for (PrimaryWorkitem workitem : workitems) {
        if (workitem.isClosed()) {
          logger.println(MessagesRes.workitemClosedCannotAttachData(workitem.getDisplayID()));
          continue;
        }

        final Collection<BuildRun> completedIn = workitem.getCompletedIn();
        final List<BuildRun> toRemove = new ArrayList<BuildRun>(completedIn.size());

        changeSet.getPrimaryWorkitems().add(workitem);

        for (BuildRun otherRun : completedIn) {
          if (otherRun.getBuildProject().equals(buildRun.getBuildProject())) {
            toRemove.add(otherRun);
          }
        }

        for (BuildRun buildRunDel : toRemove) {
          completedIn.remove(buildRunDel);
        }

        completedIn.add(buildRun);
      }
    }
  }
  @MapFeature.Require(SUPPORTS_REMOVE)
  @CollectionSize.Require(absent = ZERO)
  public void testRemovePropagatesToAsMapEntrySet() {
    List<Entry<K, V>> entries = Helpers.copyToList(multimap().entries());
    for (Entry<K, V> entry : entries) {
      resetContainer();

      K key = entry.getKey();
      V value = entry.getValue();

      Iterator<Entry<K, Collection<V>>> asMapItr = multimap().asMap().entrySet().iterator();
      Collection<V> collection = null;
      while (asMapItr.hasNext()) {
        Entry<K, Collection<V>> asMapEntry = asMapItr.next();
        if (key.equals(asMapEntry.getKey())) {
          collection = asMapEntry.getValue();
          break;
        }
      }
      assertNotNull(collection);
      Collection<V> expectedCollection = Helpers.copyToList(collection);

      multimap().remove(key, value);
      expectedCollection.remove(value);

      ASSERT.that(collection).hasContentsAnyOrder(expectedCollection.toArray());
      assertEquals(!expectedCollection.isEmpty(), multimap().containsKey(key));
    }
  }
示例#26
0
  @Override
  public void addRelation(IRelation r) {

    if (!Model.relations.containsKey(r.getSubClass())) {
      Model.relations.put(r.getSubClass(), r);
    } else {
      // get the relation we want to modify
      IRelation modify = Model.relations.get(r.getSubClass());
      Collection<String> modify_uses = modify.getUses();
      Collection<String> modify_ass = modify.getAssociations();

      if (!r.getUses().isEmpty()) {
        for (String u : r.getUses())
          // if (!modify_uses.contains(u) && !modify_ass.contains(u)
          // && this.classNames.contains(u)) {
          if (!modify_uses.contains(u) && !modify_ass.contains(u)) {
            modify_uses.add(u);
          }
      }

      if (!r.getAssociations().isEmpty()) {
        for (String u : r.getAssociations())
          // if (!modify_ass.contains(u) &&
          // this.classNames.contains(u)) {
          if (!modify_ass.contains(u)) {
            if (modify_uses.contains(u)) modify_uses.remove(u);
            modify_ass.add(u);
          }
      }
    }
  }
示例#27
0
 public void testSkip_structurallyModifiedSkipAll() throws Exception {
   Collection<String> set = newLinkedHashSet(asList("a", "b", "c"));
   Iterable<String> tail = skip(set, 2);
   set.remove("a");
   set.remove("b");
   assertFalse(tail.iterator().hasNext());
 }
示例#28
0
 /**
  * Register a listener to receive notifications of mismatched ANTLR versions. This method ensures
  * that as long as {@link DefaultListener#INSTANCE} is registered as a listener, it will always be
  * the last listener notified of mismatched versions.
  *
  * @param listener the listener to notify if mismatched ANTLR versions are detected
  * @see #checkVersion
  */
 public static synchronized void addListener(@NotNull Listener listener) {
   boolean containedDefault = listeners.remove(DefaultListener.INSTANCE);
   listeners.add(listener);
   if (containedDefault) {
     listeners.add(DefaultListener.INSTANCE);
   }
 }
 private void validateMap(Collection<Type> from, Collection<Type> to, IMapper<Type> mapper) {
   for (Type t : from) {
     Type m = mapper.map(t);
     Assert.assertTrue(to.contains(m));
     to.remove(m);
   }
 }
示例#30
0
  @Override
  @Nullable
  public Collection<PsiImportStatementBase> findRedundantImports(final PsiJavaFile file) {
    final PsiImportList importList = file.getImportList();
    if (importList == null) return null;
    final PsiImportStatementBase[] imports = importList.getAllImportStatements();
    if (imports.length == 0) return null;

    Set<PsiImportStatementBase> allImports =
        new THashSet<PsiImportStatementBase>(Arrays.asList(imports));
    final Collection<PsiImportStatementBase> redundant;
    if (FileTypeUtils.isInServerPageFile(file)) {
      // remove only duplicate imports
      redundant = ContainerUtil.newIdentityTroveSet();
      ContainerUtil.addAll(redundant, imports);
      redundant.removeAll(allImports);
      for (PsiImportStatementBase importStatement : imports) {
        if (importStatement instanceof JspxImportStatement
            && importStatement.isForeignFileImport()) {
          redundant.remove(importStatement);
        }
      }
    } else {
      redundant = allImports;
      final List<PsiFile> roots = file.getViewProvider().getAllFiles();
      for (PsiElement root : roots) {
        root.accept(
            new JavaRecursiveElementWalkingVisitor() {
              @Override
              public void visitReferenceElement(PsiJavaCodeReferenceElement reference) {
                if (!reference.isQualified()) {
                  final JavaResolveResult resolveResult = reference.advancedResolve(false);
                  if (!inTheSamePackage(file, resolveResult.getElement())) {
                    final PsiElement resolveScope = resolveResult.getCurrentFileResolveScope();
                    if (resolveScope instanceof PsiImportStatementBase) {
                      final PsiImportStatementBase importStatementBase =
                          (PsiImportStatementBase) resolveScope;
                      redundant.remove(importStatementBase);
                    }
                  }
                }
                super.visitReferenceElement(reference);
              }

              private boolean inTheSamePackage(PsiJavaFile file, PsiElement element) {
                if (element instanceof PsiClass
                    && ((PsiClass) element).getContainingClass() == null) {
                  final PsiFile containingFile = element.getContainingFile();
                  if (containingFile instanceof PsiJavaFile) {
                    return Comparing.strEqual(
                        file.getPackageName(), ((PsiJavaFile) containingFile).getPackageName());
                  }
                }
                return false;
              }
            });
      }
    }
    return redundant;
  }