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"); } } }
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; }
/** * 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); }
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; } }
@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(); } }
// 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(); } } }
/** @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; }
/** * 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(); }
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)); } } } }
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); } }
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(); }
/** * 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; }
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)); } }
@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); } } } }
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()); }
/** * 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); } }
@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; }