Get the queue of sessions sorted for scheduling
@return the queue of sessions sorted for scheduling
422221
public Queue<SessionSchedulable> getScheduleQueue() {
    if (scheduleQueue == null) {
      scheduleQueue =
          createSessionQueue(configManager.getPoolComparator(poolInfo));
    }
    return scheduleQueue;
  }
1223314
public CompletableFuture<Void> scheduleForExecution() {
		final ExecutionGraph executionGraph = getVertex().getExecutionGraph();
		final SlotProvider resourceProvider = executionGraph.getSlotProvider();
		final boolean allowQueued = executionGraph.isQueuedSchedulingAllowed();
		return scheduleForExecution(
			resourceProvider,
			allowQueued,
			LocationPreferenceConstraint.ANY,
			Collections.emptySet());
	}
127543
Collection<AsteriskQueue> getQueues()
    {
        refreshQueuesIfForced();

        Collection<AsteriskQueue> copy;

        synchronized (queuesLRU)
        {
            copy = new ArrayList<AsteriskQueue>(queuesLRU.values());
        }
        return copy;
    }
1310860
public java.util.List<ScheduledWindowExecution> getScheduledWindowExecutions() {
        if (scheduledWindowExecutions == null) {
            scheduledWindowExecutions = new com.amazonaws.internal.SdkInternalList<ScheduledWindowExecution>();
        }
        return scheduledWindowExecutions;
    }
690441
public Queue<PoolGroupSchedulable> getPreemptQueue() {
    if (preemptQueue == null) {
      preemptQueue = createPoolGroupQueue(ScheduleComparator.FAIR_PREEMPT);
    }
    return preemptQueue;
  }
561915
protected String[] getSchedulerCommand() {
    List<Integer> freePorts = new ArrayList<>(SchedulerUtils.PORTS_REQUIRED_FOR_SCHEDULER);
    for (int i = 0; i < SchedulerUtils.PORTS_REQUIRED_FOR_SCHEDULER; i++) {
      freePorts.add(SysUtils.getFreePort());
    }

    return SchedulerUtils.schedulerCommand(config, runtime, freePorts);
  }
1212413
public IoSession getSession() {
        synchronized (lock) {
            if (sessions.isEmpty()) {
                return null;
            } else {
                final Object[] keys = sessions.keySet().toArray();
                for (int i = 0; i < sessions.size(); i++) { //
                    counter++;
                    final int pos = Math.abs(counter % sessions.size());
                    final IoSession session = sessions.get(keys[pos]);
                    if (isAvailable(session)) {
                        return session;
                    }
                }
                return null;
            }
        }
    }
1174733
public static List<String> listQueues() {
		List<String> list = new ArrayList<>();
		try {
			list = getClient().listQueues().getQueueUrls();
		} catch (AmazonServiceException ase) {
			logException(ase);
		} catch (AmazonClientException ace) {
			logger.error("Could not reach SQS. {0}", ace.toString());
		}
		return list;
	}
1087402
public int getMaxQueuedConnections() {
	return getThreadPool() == null ? -1 :
	    ((getThreadPool().getQueue() instanceof ArrayBlockingQueue) ?
	     ((ArrayBlockingQueue)getThreadPool().getQueue()).size() +
	     ((ArrayBlockingQueue)getThreadPool().getQueue()).remainingCapacity() : -1);	     
    }
690523
public static ScheduledEventService getScheduleService() {
        CHFWBundle c = instance.get().get();
        if (null != c) {
            return c.scheduler;
        }
        return null;
    }
347117
public function getMessageQueue()
	{
		// For empty queue, if messages exists in the session, enqueue them.
		if (!count($this->_messageQueue))
		{
			$session = JFactory::getSession();
			$sessionQueue = $session->get('application.queue');

			if (count($sessionQueue))
			{
				$this->_messageQueue = $sessionQueue;
				$session->set('application.queue', null);
			}
		}

		return $this->_messageQueue;
	}
598677
public Iterator<QueueUser> getUsers() {
        if (users == null) {
            return new HashSet<QueueUser>().iterator();
        }
        return Collections.unmodifiableSet(users).iterator();
    }
1038541
protected function getSessions() {
        if (!$this->_sessions) {
            $this->_sessions = new SessionList($this->version, $this->solution['sid']);
        }

        return $this->_sessions;
    }
1028253
public long getLastCompleted() {
    // If there are any queued events, return the index prior to the first event in the queue.
    EventHolder event = events.peek();
    if (event != null && event.eventIndex > completeIndex) {
      return event.eventIndex - 1;
    }
    // If no events are queued, return the highest index applied to the session.
    return lastApplied;
  }
1244258
public function index()
    {
        $schedule = Schedule::query();

        if ($sortBy = Binput::get('sort')) {
            $direction = Binput::has('order') && Binput::get('order') == 'desc';

            $schedule->sort($sortBy, $direction);
        }

        $schedule = $schedule->paginate(Binput::get('per_page', 20));

        return $this->paginator($schedule, Request::instance());
    }
1117540
public WaitingSessions getWaitingSessions() {
        String url = WxEndpoint.get("url.care.session.listwait");
        String response = wxClient.get(url);
        logger.debug("list care waiting sessions :{}", response);
        WaitingSessions sessionList = JsonMapper.defaultMapper().fromJson(response, WaitingSessions.class);
        return sessionList;
    }
181841
public java.util.List<Queue> getQueues() {
        if (queues == null) {
            queues = new com.amazonaws.internal.SdkInternalList<Queue>();
        }
        return queues;
    }