Returns the number of registered runners.

@return number of registered runners
544739
@Override
    public int size() {
        Map<String, GroovyRunner> map = getMap();
        readLock.lock();
        try {
            return map.size();
        } finally {
            readLock.unlock();
        }
    }
202274
protected Integer getTotalNumberOfChildren() {
        Integer numChildrenNodes = 0;
        for (Level childLevel : levels) {
            numChildrenNodes += childLevel.getTotalNumberOfChildren();
        }
        return nodes.size() + numChildrenNodes;
    }
1267621
@Override
    public long getNumberOfEvents() {
        try {
            lock.readLock().lock();
            long currentTime = System.currentTimeMillis();
            actualizeCounts(currentTime);
            return sumCounts();
        } finally {
            lock.readLock().unlock();
        }
    }
425787
protected int numFreeEntries() {
        int res = 0;
        for (int i = 0; i < entries.length; i++) {
            Entry entry = entries[i];
            if (entry.isEmpty()) {
                res++;
            }
        }

        assert (NUMBER_ENTRIES == entries.length);
        return res;
    }
812617
public ArrayList<Integer> getUnvisited() {
    if (0 == this.unvisitedCount) {
      return new ArrayList<Integer>();
    }
    ArrayList<Integer> res = new ArrayList<Integer>(this.unvisitedCount);
    for (int i = 0; i < this.registry.length; i++) {
      if (ZERO == this.registry[i]) {
        res.add(i);
      }
    }
    return res;
  }
883470
public int numberOfInserts() {
        final Integer cachedValue = numberOfInsertsCache;

        if (cachedValue != null) {
            return cachedValue;
        }

        int numberOfInserts = 0;

        for (T object : results.keySet()) {
            if (results.get(object).wasInserted()) {
                numberOfInserts++;
            }
        }

        numberOfInsertsCache = numberOfInserts;

        return numberOfInserts;
    }
1083783
@Override
	public BigInteger getCount() {
		BigInteger cached = cachedCount;
		if(cached == null) {
			cachedCount = cached = getCountImpl();
		}
		return cached;
	}
1155640
public int getTotalClusterCount() {
    int clusterCount = 0;

    for(int i = 0; i < numclusters.length; i++) {
      clusterCount += numclusters[i];
    }

    return clusterCount;
  }
506829
public int getPathCount() {
    int result = 0;
    for(IndexTreePath<E> path = this; path != null; path = path.parentPath) {
      result++;
    }
    return result;
  }
1341088
public int threads() {
        return Integer.parseInt(
            this.map.getOrDefault(
                "threads",
                String.valueOf(Runtime.getRuntime().availableProcessors() << 2)
            )
        );
    }
859244
public int getNumberOfResults()
    {
        final String numberOfResults = agiReply.getAttribute("results");
        return numberOfResults == null ? 0 : Integer.parseInt(numberOfResults);
    }
991799
@Override
    public int getMonomerCount() {
        Iterator<String> keys = strands.keySet().iterator();
        int number = 0;

        if (!keys.hasNext()) // no strands
            return super.getMonomerCount();

        while (keys.hasNext()) {
            Strand tmp = (Strand) strands.get(keys.next()); // Cast exception?!
            number += (tmp.getMonomers()).size() - 1;
        }
        return number;
    }
69990
public final long getTotalCount()
    {
        long result = 0;
        result = result + _storedItemManager.getStatistics().getTotalCount();
        result = result + _unstoredItemManager.getStatistics().getTotalCount();
        return result;
    }
492699
public BigInteger getTotalCounts(){
		BigInteger result = BigInteger.ZERO;
		for (AtomicLong c: counters.getMap().values()){
			result = result.add(BigInteger.valueOf(c.get()));
		}
		return result;
	}
1302585
public int getNumDeliverable() {
        NumDeliverable visitor=new NumDeliverable();
        lock.lock();
        try {
            forEach(hd+1, hr, visitor);
            return visitor.getResult();
        }
        finally {
            lock.unlock();
        }
    }
871907
public int getIgnoredCount() {
    int count = 0;
    for (AggregatedTestResultEvent t : getTests()) {
      if (t.getStatus() == TestStatus.IGNORED ||
          t.getStatus() == TestStatus.IGNORED_ASSUMPTION) {
        count++;
      }
    }
    return count;
  }
1157420
public List<Integer> getRunningFlowIds() {
    final List<Integer> allIds = new ArrayList<>();
    try {
      getExecutionIdsHelper(allIds, this.executorLoader.fetchUnfinishedFlows().values());
    } catch (final ExecutorManagerException e) {
      this.logger.error("Failed to get running flow ids.", e);
    }
    return allIds;
  }