Returns the count of all requests in the ringbuffer
961179
@InterfaceAudience.Public
    @InterfaceStability.Experimental
    public int totalCount() {
        int total = countNonService;
        for (Map.Entry<ServiceType, Integer> entry : counts.entrySet()) {
            total += entry.getValue();
        }
        return total;
    }
264968
def get_listener_count(self):
        """"""

        if hasattr(self, "listener_count"):
            return self.listener_count
        else:
            self.listener_count = _number(
                _extract(self._request(self.ws_prefix + ".getInfo", True), "listeners")
            )
            return self.listener_count
329296
public int getCount() throws InterruptedException, KeeperException {
        return ByteBuffer.wrap(m_zk.getData(m_path, false, null)).getInt();
    }
594962
def _calculate_num_queries(self):
        
        request_totals = self._totals("request")
        response_totals = self._totals("response")

        return request_totals[2] + response_totals[2]
887625
def get_connection_count(self, is_full: bool = False) -> int:
        
        payload = self.generate_json_rpc_payload(RpcMethod.GET_NODE_COUNT)
        response = self.__post(self.__url, payload)
        if is_full:
            return response
        return response['result']
673526
def GetCountStopTimes(self):
    """"""
    cursor = self._schedule._connection.cursor()
    cursor.execute(
        'SELECT count(*) FROM stop_times WHERE trip_id=?', (self.trip_id,))
    return cursor.fetchone()[0]
1200954
def get_playcount(self):
        """"""

        return _number(
            _extract(
                self._request(self.ws_prefix + ".getInfo", cacheable=True), "playcount"
            )
        )
223373
def count_awaited_processes():
    """"""
    awaited = 0
    total = 0
    for i in all_instances():
        if i.enabled:
            total += 1
            if i.state is not remote_dispatcher.STATE_IDLE:
                awaited += 1
    return awaited, total
1368936
def count(self):
        
        params = self.dump()
        params['limit'] = 0
        params['count'] = 1
        content = self._do_request(params)
        return content['count']
700034
private ByteBuffer ringGet() {
		ByteBuffer bb = null;
		synchronized(ring) {
			bb=ring[start];
			ring[start]=null;
			if(bb!=null && ++start>15)start=0;
		}
		if(bb==null) {
			bb=ByteBuffer.allocate(DEFAULT_CHUNK);
		} else {
			bb.clear();// refresh reused buffer
		}
		return bb;
	}
310688
async def serviceQueues(self, limit=None) -> int:
        
        return await self._inbox_router.handleAll(self._inbox, limit)
539201
async def serviceQueues(self, limit=None) -> int:
        

        return await self.inBoxRouter.handleAll(self.filterMsgs(self.inBox),
                                                limit)
1060380
def count(self, *urls):
        

        threads = dict(self.db.execute([
            'SELECT threads.uri, COUNT(comments.id) FROM comments',
            'LEFT OUTER JOIN threads ON threads.id = tid AND comments.mode = 1',
            'GROUP BY threads.uri'
        ]).fetchall())

        return [threads.get(url, 0) for url in urls]
16649
def num_rings(self):
		

		num = self._libinput.libinput_device_tablet_pad_get_num_rings(
			self._handle)
		if num < 0:
			raise AttributeError('This device is not a tablet pad device')
		return num
339331
def get_count(self, request, notifications, mark_as_read=False):
        
        return Response({'count': notifications.filter(is_read=False).count()})
7509
def get_parameters(self, packet_count=None):
        
        params = super(LiveRingCapture, self).get_parameters(packet_count=packet_count)
        params += ['-b', 'filesize:' + str(self.ring_file_size), '-b', 'files:' + str(self.num_ring_files), '-w', self.ring_file_name, '-P']
        return params
1086068
final public int getConnectionCount() {
		int total = 0;
		synchronized(poolLock) {
			for(PooledConnection<C> pooledConnection : allConnections) {
				if(pooledConnection.connection!=null) total++;
			}
		}
		return total;
	}