Returns the number of Resources currently in the list.

@return The number of registered Resources.
963052
public int numRegistered() {
        final int result = _resourceObjects.size();

        if (tc.isDebugEnabled())
            Tr.debug(tc, "numRegistered", result);
        return result;
    }
1290860
public List<ResourceFileSource> getSources() {
		List<ResourceFileSource> sources = new ArrayList<ResourceFileSource>();
		sources.add(this);
		return sources;
	}
795620
public java.util.List<GroupedResourceCount> getGroupedResourceCounts() {
        if (groupedResourceCounts == null) {
            groupedResourceCounts = new com.amazonaws.internal.SdkInternalList<GroupedResourceCount>();
        }
        return groupedResourceCounts;
    }
885691
public int size() {
        int count=0;
        for(Value val: map.values())
            count+=val.count();

        return count;
    }
437756
public function getCount()
    {
        if ($this->_count !== null) {
            return $this->_count;
        }

        while ($this->_hasMore) {
            $this->fetchOutstanding();
        }

        return $this->_length;
    }
894961
@Synchronized
    public int getNumberOfSegments() {
        return assignedSegments.values().stream().mapToInt(Map::size).sum() + unassignedSegments.size();
    }
597521
public int getNumberOfSuccessors() {

		int numberOfSuccessors = 0;

		for (int i = 0; i < this.outputGates.length; ++i) {
			numberOfSuccessors += this.outputGates[i].getNumberOfEdges();
		}

		return numberOfSuccessors;
	}
1302938
@Override
    public int size() {
        stateLock.readLock().lock();
        try {
            switch (state) {
                default:
                    // This list might be empty or full or somewhere in between:
                    // we don't know until we look!
                    preFetchAll();
                    // The list is now either complete or timed out - recurse to find the result.
                    return size();
                case TIMED_OUT:
                    return currentSize();
                case COMPLETE_WITH_FAILURES:
                    return elements.length - failedKeys.size();
                case COMPLETE:
                    return elements.length;
            }
        } finally {
            stateLock.readLock().unlock();
        }
    }
1326376
@Nullable
    public final Resources getResources() {
        Activity activity = getActivity();
        return activity != null ? activity.getResources() : null;
    }
532406
public long numRecords() {
        if (numRecords == null) {
            try {
                numRecords = indexToKey.getNumRecords();
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return numRecords;
    }
822457
public List<String> getPaths() {
        final List<String> resourcePaths = new ArrayList<>(this.size());
        for (final Resource resource : this) {
            resourcePaths.add(resource.getPath());
        }
        return resourcePaths;
    }
1177250
public synchronized int getPartitionStoreCount() {
        int count = 0;
        for (String store : storeToPartitionIds.keySet()) {
            count += storeToPartitionIds.get(store).size();
        }
        return count;
    }
883044
public int getCount(final int state)
   {
      int count = 0;
      for (IConcurrentBagEntry e : sharedList) {
         if (e.getState() == state) {
            count++;
         }
      }
      return count;
   }
1223745
@VisibleForTesting
    public int getCurrentTaskCount() {
        synchronized (this.queue) {
            int size = this.queue.size() + this.filterQueue.size();
            if (size > 0) {
                // Some tasks may have completed, but we haven't yet been able to clean them up.
                size -= this.queue.values().stream().filter(CompletableFuture::isDone).count();
                size -= this.filterQueue.values().stream().filter(CompletableFuture::isDone).count();
            }

            return size;
        }
    }
1166799
public int size() {
        int count = 0;

        for (int i = 0, size = mScrapLength.size(); i < size; i++) {
            int val = mScrapLength.valueAt(i);
            count += val;
        }

        return count;
    }
1176184
public int getCount() {
        Lock lock = this.lock.readLock();
        lock.lock();
        try {
            return this.count;
        } finally {
            lock.unlock();
        }
    }
226168
public long getNumberOfCompletedRequests()
  {
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.entry(tc, "getNumberOfCompletedRequests"); 
    long completedRequests = 
      getNumberOfRequestsReceived() - getNumberOfCurrentRequests();
    if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled())
      SibTr.exit(tc, "getNumberOfCompletedRequests", new Long(completedRequests));
    return completedRequests; 
  }