org.eclipse.jetty.util.ConcurrentHashSet Java Examples

@Test
public void shouldNotifyOneListenerForEachMessage() throws InterruptedException {
    GoMessageQueue<GoMessage> queue = new GoMessageQueue<>(messageService, "TestQueue");

    int numberOfListeners = 2;
    int numberOfMessages = numberOfListeners + 2;

    for (int i = 0; i < numberOfListeners; i++) {
        queue.addListener(new StubGoMessageListener(i));
    }

    Set<String> expectMessages = new ConcurrentHashSet<>();
    for (int i = 0; i < numberOfMessages; i++) {
        String text = "Message-" + i;
        queue.post(new GoTextMessage(text));
        expectMessages.add(text);
    }

    assertWillHappen(receivedMessage, is(expectMessages), Timeout.FIVE_SECONDS);
}
 

public SubPipelineExecutor( String subPipelineName, IPipelineEngine<PipelineMeta> parentPipeline, PipelineMeta subPipelineMeta, boolean shareVariables,
                            PipelineExecutorParameters parameters, String subTransform, PipelineRunConfiguration runConfiguration ) {
  this.subPipelineName = subPipelineName;
  this.parentPipeline = parentPipeline;
  this.subPipelineMeta = subPipelineMeta;
  this.shareVariables = shareVariables;
  this.parameters = parameters;
  this.subTransform = subTransform;
  this.statuses = new LinkedHashMap<>();
  this.running = new ConcurrentHashSet<>();
  this.runConfiguration = runConfiguration;
}
 

public NINO() {
    this.whitelistedUrls = new ConcurrentHashSet<>();
    this.whitelistedChannels = new ConcurrentHashSet<>();
    this.whitelistedUrls.add("discord.gg/discord-developers");
    this.whitelistedUrls.add("discord.gg/TTAUGvZ");
    this.removeMessages.add("No no no, you post not an invite here!\nYes, hmmm.");
}
 

public static void pushAction(String userID, RunnableWrapper action) {
    Set<RunnableWrapper> actions = confirmCache.getIfPresent(userID);
    if (actions != null) {
        if (actions.stream().noneMatch(wrapper -> wrapper.getOrigin().equals(action.getOrigin()))) {
            actions.add(action);
        }
    } else {
        Set<RunnableWrapper> newActions = new ConcurrentHashSet<>();
        newActions.add(action);
        confirmCache.put(userID, newActions);
    }
}
 

/**
 *
 * @param fileTree The file tree representation of PeerWasp
 * @param messageBus To publish events system-wide
 */
   @Inject
public FileEventManager(final FileTree fileTree, MessageBus messageBus) {
   	this.fileComponentQueue = new FileComponentQueue();
	this.fileTree = fileTree;
	this.messageBus = messageBus;
	this.failedOperations = new ConcurrentHashSet<Path>();
}
 

public SubtransExecutor( String subTransName, Trans parentTrans, TransMeta subtransMeta, boolean shareVariables,
                         TransExecutorParameters parameters, String subStep, int prefetchCount ) {
  this.subTransName = subTransName;
  this.parentTrans = parentTrans;
  this.subtransMeta = subtransMeta;
  this.shareVariables = shareVariables;
  this.parameters = parameters;
  this.subStep = subStep;
  this.statuses = new LinkedHashMap<>();
  this.running = new ConcurrentHashSet<>();
  this.prefetchCount = prefetchCount;
  this.semaphore = new Semaphore( prefetchCount );
}
 

public JobThread(int jobId, IJobHandler handler) {
	this.jobId = jobId;
	this.handler = handler;
	this.triggerQueue = new LinkedBlockingQueue<TriggerParam>();
	this.triggerLogIdSet = new ConcurrentHashSet<Integer>();
}
 

public JsonVertex() {
    this.edges = new ConcurrentHashSet<>();
}
 

public ConcurrentHashSet<String> getPermissions() {
    return permissions;
}
 

public GuildSettings() {
    this.deleteCommands = true;
    this.channelBlacklist = new ConcurrentHashSet<>();
    this.userBlacklist = new ConcurrentHashSet<>();
}
 

public WriteTask(final Journal journal,
        final String[] resource, final int trial, final int keyLen,
        final int nops, final double failureRate, final double commitRate,
        final ConcurrentHashSet<Thread> threads) {

    this.journal = journal;
    
    this.resource = resource;

    this.trial = trial;
    
    this.keyLen = keyLen;
    
    this.nops = nops;
    
    this.failureRate = failureRate;
    
    this.commitRate = commitRate;
    
    this.threads = threads;
    
}
 

@Override
public Set<Path> getSynchronizedPathsAsSet() {
	Set<Path> synchronizedFiles = new ConcurrentHashSet<Path>();
	rootOfFileTree.getSynchronizedChildrenPaths(synchronizedFiles);
	return synchronizedFiles;
}