Java Code Examples for java.util.concurrent.ConcurrentHashMap#newKeySet()

/**
 * Initializes the ACL objects and preemptively calculates all permissions for all sids.
 *
 * @param globalRoles set of roles from which to calculate the permissions.
 */
public GlobalAclImpl(Set<GlobalRole> globalRoles) {
    for (GlobalRole role : globalRoles) {
        Set<Permission> impliedPermissions = ConcurrentHashMap.newKeySet();

        role.getPermissionsUnsorted().parallelStream().map(PermissionWrapper::getPermission).forEach(impliedPermissions::add);

        role.getSids().parallelStream().forEach(sid -> {
            Set<Permission> permissionsForSid = permissionList.get(sid);
            if (permissionsForSid == null) {
                permissionsForSid = new HashSet<>();
            }
            permissionsForSid.addAll(impliedPermissions);
            permissionList.put(sid, permissionsForSid);
        });
    }
}
 

/**
 * KeySet.iterator() returns an iterator containing the elements of the
 * set
 */
public void testIterator() {
    Collection empty = ConcurrentHashMap.newKeySet();
    int size = 20;
    assertFalse(empty.iterator().hasNext());
    try {
        empty.iterator().next();
        shouldThrow();
    } catch (NoSuchElementException success) {}

    Integer[] elements = new Integer[size];
    for (int i = 0; i < size; i++)
        elements[i] = i;
    Collections.shuffle(Arrays.asList(elements));
    Collection<Integer> full = populatedSet(elements);

    Iterator it = full.iterator();
    for (int j = 0; j < size; j++) {
        assertTrue(it.hasNext());
        it.next();
    }
    assertIteratorExhausted(it);
}
 

public static void updateFrozenEdge(BalanceList frozenEdgeList) {

        if (frozenEdgeList != null) {
            for (int i = numberOfRecentLists - 1; i > 0; i--) {
                recentLists[i] = recentLists[i - 1];
            }
            recentLists[0] = frozenEdgeList;

            Set<ByteBuffer> accountsInSystem = ConcurrentHashMap.newKeySet();
            for (BalanceListItem item : frozenEdgeList.getItems()) {
                accountsInSystem.add(ByteBuffer.wrap(item.getIdentifier()));
            }

            BalanceListManager.accountsInSystem = accountsInSystem;

            balanceListMap.clear();
            balanceListMap.put(ByteBuffer.wrap(frozenEdgeList.getHash()), frozenEdgeList);
        }
    }
 

public MetadataConsumer(IMetadataService metadataService,
                        TorrentId torrentId,
                        Config config) {

    this.peersWithoutMetadata = new ConcurrentHashMap<>();

    this.supportingPeers = ConcurrentHashMap.newKeySet();
    this.requestedFirstPeers = new ConcurrentHashMap<>();
    this.requestedAllPeers = ConcurrentHashMap.newKeySet();

    this.metadataService = metadataService;

    this.torrentId = Objects.requireNonNull(torrentId);
    this.torrent = new AtomicReference<>();

    this.metadataExchangeBlockSize = config.getMetadataExchangeBlockSize();
    this.metadataExchangeMaxSize = config.getMetadataExchangeMaxSize();
}
 

@Reference(cardinality = ReferenceCardinality.MULTIPLE, policy = ReferencePolicy.DYNAMIC)
public void addActionProvider(AnnotatedActions actionProvider, Map<String, Object> properties) {
    Collection<ModuleInformation> moduleInformations = helper.parseAnnotations(actionProvider);

    String configName = getConfigNameFromService(properties);

    for (ModuleInformation mi : moduleInformations) {
        mi.setConfigName(configName);

        ModuleType oldType = null;
        if (this.moduleInformation.containsKey(mi.getUID())) {
            oldType = helper.buildModuleType(mi.getUID(), this.moduleInformation);
            Set<ModuleInformation> availableModuleConfigs = this.moduleInformation.get(mi.getUID());
            availableModuleConfigs.add(mi);
        } else {
            Set<ModuleInformation> configs = ConcurrentHashMap.newKeySet();
            configs.add(mi);
            this.moduleInformation.put(mi.getUID(), configs);
        }

        ModuleType mt = helper.buildModuleType(mi.getUID(), this.moduleInformation);
        if (mt != null) {
            for (ProviderChangeListener<ModuleType> l : changeListeners) {
                if (oldType != null) {
                    l.updated(this, oldType, mt);
                } else {
                    l.added(this, mt);
                }
            }
        }
    }
}
 

static Set<Integer> populatedSet(int n) {
    Set<Integer> a = ConcurrentHashMap.<Integer>newKeySet();
    assertTrue(a.isEmpty());
    for (int i = 0; i < n; i++)
        assertTrue(a.add(i));
    assertEquals(n == 0, a.isEmpty());
    assertEquals(n, a.size());
    return a;
}
 

@Ignore("This is currently unstable as if the clear does not complete before the failover," +
        "there is no future operation that will trigger the code in ClusterTierActiveEntity.invokeServerStoreOperation" +
        "dealing with in-flight invalidation reconstructed from reconnect data")
@Test(timeout=180000)
public void testClear() throws Exception {
  List<Future<?>> futures = new ArrayList<>();
  Set<Long> universalSet = ConcurrentHashMap.newKeySet();

  caches.forEach(cache -> {
    for (int i = 0; i < NUM_OF_THREADS; i++) {
      Map<Long, BlobValue> map = random.longs().limit(JOB_SIZE).collect(HashMap::new, (hashMap, x) -> hashMap.put(x, new BlobValue()), HashMap::putAll);
      futures.add(executorService.submit(() -> {
        cache.putAll(map);
        universalSet.addAll(map.keySet());
      }));
    }
  });

  drainTasks(futures);

  universalSet.forEach(x -> {
    cache1.get(x);
    cache2.get(x);
  });

  Future<?> clearFuture = executorService.submit(() -> cache1.clear());

  CLUSTER.getClusterControl().waitForRunningPassivesInStandby();
  CLUSTER.getClusterControl().terminateActive();

  clearFuture.get();

  universalSet.forEach(x -> assertThat(cache2.get(x), nullValue()));

}
 

@Autowired
public EventSourceSyncDurationLogger(final Optional<List<EventSource>> eventSources) {
    allChannels = eventSources.orElse(Collections.emptyList())
            .stream()
            .map(EventSource::getChannelName)
            .collect(toSet());
    healthyChannels = ConcurrentHashMap.newKeySet();
}
 

@Test
void putMissingNestedProductType_WithIdenticalOneReferencingAttrToAnEmptyMap_ShouldOverwriteExisting() {
    // preparation
    final ConcurrentHashMap<String,
        ConcurrentHashMap<String, ConcurrentHashMap.KeySetView<AttributeDefinitionDraft, Boolean>>>
        missingProductTypeReferences = new ConcurrentHashMap<>();

    final ConcurrentHashMap<String, ConcurrentHashMap.KeySetView<AttributeDefinitionDraft, Boolean>>
        productTypesReferencingMissing1 = new ConcurrentHashMap<>();

    final AttributeDefinitionDraft referencingAttributeDefinitionDraft = AttributeDefinitionDraftBuilder
        .of(NestedAttributeType.of(
            ProductType.referenceOfId("missingPT")), "attr-name", ofEnglish("label"), true)
        .build();

    final ConcurrentHashMap.KeySetView<AttributeDefinitionDraft, Boolean> definitionDrafts =
        ConcurrentHashMap.newKeySet();
    definitionDrafts.add(referencingAttributeDefinitionDraft);
    productTypesReferencingMissing1.put("referencingPT", definitionDrafts);

    missingProductTypeReferences.put("missingPT", productTypesReferencingMissing1);

    final ProductTypeSyncStatistics productTypeSyncStatistics =
        new ProductTypeSyncStatistics(missingProductTypeReferences);


    // test
    productTypeSyncStatistics.putMissingNestedProductType("missingPT",
        "referencingPT",
        referencingAttributeDefinitionDraft);

    // assertion
    assertThat(productTypeSyncStatistics.getProductTypeKeysWithMissingParents()).hasSize(1);
    assertThat(productTypeSyncStatistics.getProductTypeKeysWithMissingParents().get("missingPT")).hasSize(1);
    assertThat(productTypeSyncStatistics.getProductTypeKeysWithMissingParents()
                                        .get("missingPT")
                                        .get("referencingPT"))
        .contains(referencingAttributeDefinitionDraft);
}
 

private Set<AnnounceKey> getOrCreateExtraAnnounceKeys(TorrentId torrentId) {
    Set<AnnounceKey> announceKeys = extraAnnounceKeys.get(torrentId);
    if (announceKeys == null) {
        announceKeys = ConcurrentHashMap.newKeySet();
        Set<AnnounceKey> existing = extraAnnounceKeys.putIfAbsent(torrentId, announceKeys);
        if (existing != null) {
            announceKeys = existing;
        }
    }
    return announceKeys;
}
 

/**
 * Add an entry to the dnsToUuidMap, which maps hostname / IP to the DNs
 * running on that host. As each address can have many DNs running on it,
 * this is a one to many mapping.
 * @param dnsName String representing the hostname or IP of the node
 * @param uuid String representing the UUID of the registered node.
 */
private synchronized void addEntryTodnsToUuidMap(
    String dnsName, String uuid) {
  Set<String> dnList = dnsToUuidMap.get(dnsName);
  if (dnList == null) {
    dnList = ConcurrentHashMap.newKeySet();
    dnsToUuidMap.put(dnsName, dnList);
  }
  dnList.add(uuid);
}
 

public EmoteImpl(long id, GuildImpl guild, boolean fake)
{
    this.id = id;
    this.api = guild.getJDA();
    this.guild = new SnowflakeReference<>(guild, api::getGuildById);
    this.roles = ConcurrentHashMap.newKeySet();
    this.fake = fake;
}
 

public ServerStateNode(ServerName serverName) {
  this.serverName = serverName;
  this.regions = ConcurrentHashMap.newKeySet();
}
 

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
	Set<Object> seen = ConcurrentHashMap.newKeySet();
	return t -> seen.add(keyExtractor.apply(t));
}
 

@Test
public void test() {
  JavaFileObject javaFileObject =
      JavaFileObjects.forSourceLines(
          "foo.bar.Baz",
          "package foo.bar;",
          "",
          "import com.google.auto.value.AutoValue;",
          "",
          "@AutoValue",
          "public abstract class Baz {",
          "  public static Baz create() {",
          "    return new AutoValue_Baz();",
          "  }",
          "}");
  JavaFileObject expectedOutput =
      JavaFileObjects.forSourceLines(
          "foo.bar.AutoValue_Baz",
          "package foo.bar;",
          "",
          "final class AutoValue_Baz extends Baz {",
          "  AutoValue_Baz() {",
          "  }",
          "",
          "  @Override public String toString() {",
          "    return \"Baz{\"",
          "        + \"}\";",
          "  }",
          "",
          "  @Override public boolean equals(Object o) {",
          "    if (o == this) {",
          "      return true;",
          "    }",
          "    if (o instanceof Baz) {",
          "      return true;",
          "    }",
          "    return false;",
          "  }",
          "",
          "  @Override public int hashCode() {",
          "    int h$ = 1;",
          "    return h$;",
          "  }",
          "}");
  Set<String> ignoredGenerated = ConcurrentHashMap.newKeySet();
  Processor autoValueProcessor = new AutoValueProcessor();
  ProcessorHandler handler = new ProcessorHandler(autoValueProcessor, ignoredGenerated);
  Processor noGeneratedProcessor = partialProxy(Processor.class, handler);
  Compilation compilation =
      javac()
      .withOptions(javacOptions)
      .withProcessors(noGeneratedProcessor)
      .compile(javaFileObject);
  assertThat(compilation).succeededWithoutWarnings();
  assertThat(compilation)
      .generatedSourceFile("foo.bar.AutoValue_Baz")
      .hasSourceEquivalentTo(expectedOutput);
  assertThat(ignoredGenerated).containsExactly(expectedAnnotation);
}
 

/**
 * Tests that all slots are being returned to the {@link SlotOwner} if the
 * {@link ExecutionGraph} is being cancelled. See FLINK-9908
 */
@Test
public void testCancellationOfIncompleteScheduling() throws Exception {
	final int parallelism = 10;

	final JobVertex jobVertex = new JobVertex("Test job vertex");
	jobVertex.setInvokableClass(NoOpInvokable.class);
	jobVertex.setParallelism(parallelism);

	final JobGraph jobGraph = new JobGraph(jobVertex);
	jobGraph.setAllowQueuedScheduling(true);
	jobGraph.setScheduleMode(ScheduleMode.EAGER);

	final TestingSlotOwner slotOwner = new TestingSlotOwner();
	final SimpleAckingTaskManagerGateway taskManagerGateway = new SimpleAckingTaskManagerGateway();

	final ConcurrentMap<SlotRequestId, Integer> slotRequestIds = new ConcurrentHashMap<>(parallelism);

	final TestingSlotProvider slotProvider = new TestingSlotProvider(
		(SlotRequestId slotRequestId) -> {
			slotRequestIds.put(slotRequestId, 1);
			// return 50/50 fulfilled and unfulfilled requests
			return slotRequestIds.size() % 2 == 0 ?
				CompletableFuture.completedFuture(
					createSingleLogicalSlot(slotOwner, taskManagerGateway, slotRequestId)) :
				new CompletableFuture<>();
		});

	final ExecutionGraph executionGraph = createExecutionGraph(jobGraph, slotProvider);

	executionGraph.start(ComponentMainThreadExecutorServiceAdapter.forMainThread());
	final Set<SlotRequestId> slotRequestIdsToReturn = ConcurrentHashMap.newKeySet(slotRequestIds.size());

	executionGraph.scheduleForExecution();

	slotRequestIdsToReturn.addAll(slotRequestIds.keySet());

	slotOwner.setReturnAllocatedSlotConsumer(logicalSlot -> {
		slotRequestIdsToReturn.remove(logicalSlot.getSlotRequestId());
	});

	slotProvider.setSlotCanceller(slotRequestIdsToReturn::remove);

	// make sure that we complete cancellations of deployed tasks
	taskManagerGateway.setCancelConsumer(
		(ExecutionAttemptID executionAttemptId) -> {
			final Execution execution = executionGraph.getRegisteredExecutions().get(executionAttemptId);

			// if the execution was cancelled in state SCHEDULING, then it might already have been removed
			if (execution != null) {
				execution.completeCancelling();
			}
		}
	);

	executionGraph.cancel();
	assertThat(slotRequestIdsToReturn, is(empty()));
}
 

public JobCounter(int batchSize) {
    this.jobs = new AtomicInteger(0);
    this.elements = ConcurrentHashMap.newKeySet();
    this.indexes = ConcurrentHashMap.newKeySet();
    this.batchSize = batchSize;
}
 

protected static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}
 

/**
    * Registeres the Learner for processing by SendWorker.
    */
   @OnOpen
   public void registerUser(Session websocket) throws IOException {
Long lessonId = Long.valueOf(websocket.getRequestParameterMap().get(AttributeNames.PARAM_LESSON_ID).get(0));

String login = websocket.getUserPrincipal().getName();
User user = PresenceWebsocketServer.getUserManagementService().getUserByLogin(login);

String nickname = user.getFirstName() + " " + user.getLastName();
websocket.getUserProperties().put(PARAM_NICKNAME, nickname);
websocket.getUserProperties().put(AttributeNames.PARAM_LESSON_ID, lessonId);

PresenceWebsocketServer.getSecurityService().isLessonParticipant(lessonId, user.getUserId(), "join lesson chat",
	true);

Set<Session> lessonWebsockets = PresenceWebsocketServer.websockets.get(lessonId);
if (lessonWebsockets == null) {
    lessonWebsockets = ConcurrentHashMap.newKeySet();
    PresenceWebsocketServer.websockets.put(lessonId, lessonWebsockets);
}
lessonWebsockets.add(websocket);

Roster roster = PresenceWebsocketServer.rosters.get(lessonId);
if (roster == null) {
    Lesson lesson = PresenceWebsocketServer.getLessonService().getLesson(lessonId);
    // build a new roster object
    roster = new Roster(lessonId, lesson.getLearnerImAvailable());
    PresenceWebsocketServer.rosters.put(lessonId, roster);
}

new Thread(() -> {
    try {
	// websocket communication bypasses standard HTTP filters, so Hibernate session needs to be initialised manually
	HibernateSessionManager.openSession();
	SendWorker.send(lessonId, nickname);
    } finally {
	HibernateSessionManager.closeSession();
    }
}).start();

if (PresenceWebsocketServer.log.isDebugEnabled()) {
    PresenceWebsocketServer.log
	    .debug("User " + nickname + " entered Presence Chat with lesson ID: " + lessonId);
}
   }
 

public static <T> Predicate<T> distinctByKey(Function<? super T, ?> keyExtractor) {
    Set<Object> seen = ConcurrentHashMap.newKeySet();
    return t -> seen.add(keyExtractor.apply(t));
}