Returns an estimate of the number of path+queries that this visit state should keep in memory.

@return an estimate of the number of path+queries that this visit state should keep in memory.
3200
public int pathQueryLimit() {
		/* We first compute the ratio beween the delay for scheme+authorities and the IP delay.
		 * It is usually greater than one and it expresses the number of scheme+authorities
		 * that can "fit" the IP delay. */
		final double delayRatio = Math.max(1 , (frontier.rc.schemeAuthorityDelay + 1.) / (frontier.rc.ipDelay + 1.));
		/* We now establish a scaling factor depending on the size of the workbench entry. Entries of
		 * size less than or equal to delayRatio have scaling factor one, as there is no scheme+authority
		 * slowdown due to the IP delay. However, entries with greater size are scaled proportionally.
		 * For instance, if delayRatio is 4 up to 4 scheme+authorities with the same IP on average will cause
		 * no slowdown, but if you have 8 scheme+authorities on the same IP each one will be slowed down by a factor
		 * of two: indeed, if scheme+authorities are accessed round-robin, you will need to wait for 8 ipDelays, which
		 * amounts to 2 scheme+authority delays. */
		final double scalingFactor = workbenchEntry == null ? 1 : Math.max(1, workbenchEntry.size() / delayRatio);
		/* Finally, we divide the estimated workbench size in path+queries by the size of the required front multiplied
		 * by the scaling factor. We also maximize with 4 and minimize with the number of path+queries that
		 * can be fetched in five minutes. */
		return (int)Math.min(300000 / (frontier.rc.schemeAuthorityDelay + 1),
				Math.max(4, (long)Math.ceil((frontier.workbenchSizeInPathQueries /
						(scalingFactor * frontier.requiredFrontSize.get())))));
	}
674642
protected long getEstimatedCacheMemoryUsage ()
    {
        long size = 0;
        Iterator<CompositedMultiFrameImage> iter = _frameCache.values().iterator();
        while (iter.hasNext()) {
            size += iter.next().getEstimatedMemoryUsage();
        }
        return size;
    }
344915
public int getNumberOfSteps() {
		int result = 0;

		final Queue<TraceStep> queue = new LinkedList<>();
		queue.add(root);

		while (!queue.isEmpty()) {
			final TraceStep currentTraceStep = queue.poll();

			result++;

			final List<TraceStep> children = currentTraceStep.getChildren();
			if (!children.isEmpty()) {
				queue.addAll(children);
			}
		}

		return result;
	}
1080163
public int count() {
        int n = 0;
        for (ConcurrentMap<?, ?> bag : registry.values()) {
            n += bag.size();
        }
        return n;
    }
338491
function () {
            var state = this.state,
                currentPage = state.pages[state.currentPage - 1],
                rowIndex = currentPage.rowIndex,
                prevRow = state.rows[rowIndex - 1];
            return prevRow && prevRow[0] + 1 || state.currentPage;
        }
301677
public int getRequestCount() {
        synchronized (mapPluginStats) {
            int count = requestCount + getAnalyser().getRequestCount();
            for (PluginStats stats : mapPluginStats.values()) {
                count += stats.getMessageCount();
            }
            return count;
        }
    }
745417
public List<EdgeIteratorState> calcEdges() {
        final List<EdgeIteratorState> edges = new ArrayList<>(edgeIds.size());
        if (edgeIds.isEmpty())
            return edges;

        forEveryEdge(new EdgeVisitor() {
            @Override
            public void next(EdgeIteratorState eb, int index, int prevEdgeId) {
                edges.add(eb);
            }

            @Override
            public void finish() {

            }
        });
        return edges;
    }
729339
public int getRequestSize() {
        if (records == null) {
            return 1;
        }

        int size = 1;
        for (RecordRequest record : records) {
            size += record.getRequestSize();
        }

        return size;
    }
928796
public final int getLiveSegmentCount() {
        int num = 0;

        for (int i = 0; i < _segList.size(); i++) {
            if (_segList.get(i) != null)
                num++;
        }

        return num;
    }
915459
public int getNumOccupiedMemorySegments() {
		// either the number of memory segments, or one for spilling
		final int numPartitionBuffers = this.partitionBuffers != null ?
			this.partitionBuffers.length : this.buildSideWriteBuffer.getNumOccupiedMemorySegments();
		return numPartitionBuffers + numOverflowSegments;
	}
675119
public long getInvocationCacheHitCount()
  {
    LruCache<Object,I> invocationCache = _invocationCache;

    if (invocationCache != null) {
      return invocationCache.getHitCount();
    }
    else {
      return 0;
    }
  }
307533
@Pure
	public double getLength() {
		double length  = 0;
		for (final RoadPath p : this.paths) {
			length += p.getLength();
		}
		return length;
	}
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;
    }
847435
public static int numRoutes(int version) {
    int count = 0;
    for (Route route : routesList)
      if (route.getVersion() == version)
        count++;
    return count;
  }
928242
public int numVertices() {
	if(CACHING && (cachedNumVertices != -1)) {
	    return cachedNumVertices;
	}	
	int numVertices = vertices().size();       
	if(CACHING) {
	    cachedNumVertices = numVertices;
	}
	return numVertices;
    }
772690
public int getStatementCount() {
        int ret = 0;
        for (final StatementGroup sg : statementGroups) {
            ret += sg.getAllStatements().size();
        }
        return ret;
    }
1097392
public int getQueryCacheCount(String mapName) {
        Map<String, InternalQueryCache<K, V>> queryCacheRegistry = queryCacheRegistryPerMap.get(mapName);
        if (queryCacheRegistry == null) {
            return 0;
        }
        return queryCacheRegistry.size();
    }