A convenience method equivalent to <code>{@link
#getCounts}({o1,o2,o3})</code>; works only for depth 3
GeneralizedCounters
436622
public double getCount(K o1, K o2, K o3) {
    if (depth != 3) {
      wrongDepth();
    }
    GeneralizedCounter<K> gc1 = ErasureUtils.<GeneralizedCounter<K>>uncheckedCast(map.get(o1));
    if (gc1 == null) {
      return 0.0;
    } else {
      return gc1.getCount(o2, o3);
    }
  }
807344
@Override
    public int getChildCount(Object nodeObj) {
        if (debugger == null) {
            return 0;
        }
        VariableNode node = (VariableNode) nodeObj;
        return children(node).length;
    }
1011505
public Method[] getMethods(Class clazz, Collection.Key methodName, int count) {
	Map<Key, Array> methodsMap = map.get(clazz);
	if (methodsMap == null) methodsMap = store(clazz);

	Array methods = methodsMap.get(methodName);
	if (methods == null) return null;

	Object o = methods.get(count + 1, null);
	if (o == null) return null;
	return (Method[]) o;
    }
685700
public int getCount(G g) {
        Pair<Integer> orderAndSize = new Pair<Integer>(g.order(), g.size());
        Map<G,Integer> graphs = orderAndSizeToGraphs.get(orderAndSize);
        if (graphs == null) 
            return 0;
        for (Map.Entry<G,Integer> e : graphs.entrySet()) {
            if (isoTest.areIsomorphic(g, e.getKey())) 
                return e.getValue();
        }
        return 0;
    }
386149
@Override
	public long getCount(long when){
		Long recWhen = when - (when % granularity);
		AtomicLong times = counters.get(recWhen);
		return times == null ? 0 : times.longValue(); 
	}
915893
public Long getCount(int pollerIndex) {
    long updates = 0;
    for (Counter c : bucketCount) {
      updates += c.getValue(pollerIndex).longValue();
    }
    updates += overflowCount.getValue(pollerIndex).longValue();

    return updates;
  }
413328
public long getCount(E e) {
    if (counters.containsKey(e)) {
      return counters.get(e).getCount();
    } else {
      return 0l;
    }
  }
1027472
def getCounts
      result = {}
      @classes.each do |c|
        count = 0
        ObjectSpace.each_object(c){ count += 1 }
        result[c] = count
      end
      result
    end
1305522
public GeneralizedCounter<K> conditionalize(List<K> l) {
    int n = l.size();
    if (n >= depth()) {
      throw new RuntimeException("Error -- attempted to conditionalize a GeneralizedCounter of depth " + depth() + " on a vector of length " + n);
    } else {
      GeneralizedCounter<K> next = this;
      for (K o: l) {
        next = next.conditionalizeHelper(o);
      }
      return next;
    }
  }
514590
private GeneralizedCounter<K> conditionalizeHelper(K o) {
    if (depth > 1) {
      GeneralizedCounter<K> next = ErasureUtils.<GeneralizedCounter<K>>uncheckedCast(map.get(o));
      if (next == null) // adds a new GeneralizedCounter if needed
      {
        map.put(o, (next = new GeneralizedCounter<K>(depth - 1)));
      }
      return next;
    } else {
      throw new RuntimeException("Error -- can't conditionalize a distribution of depth 1");
    }
  }
313655
List<Long> getCountList() {
		List<Long> ret = new ArrayList<Long>();
		long lastValue = 0;
		int positionInBlock = 0;
		for (long index = 0; index < this.bitVector.size(); index++) {
			if (this.bitVector.getBit(index)) {
				lastValue++;
			}
			positionInBlock++;
			if (positionInBlock == this.blockSize) {
				ret.add(lastValue);
				positionInBlock = 0;
			}
		}
		if (positionInBlock > 0) {
			ret.add(lastValue);
		}
		return ret;
	}
456792
@SuppressWarnings("deprecation")
  public Counters getCounters() {
    synchronized (lockObject) {
      Counters result = new Counters();
      result.incrAllCounters(getJobCounters());

      incrementTaskCountersUnprotected(result, maps);
      return incrementTaskCountersUnprotected(result, reduces);
    }
  }
122218
public static <T> int count(Iterable<T> iterable, Predicate<? super T> predicate, int batchSize, ForkJoinPool executor)
    {
        CountCombiner<T> combiner = new CountCombiner<>();
        CountProcedureFactory<T> procedureFactory = new CountProcedureFactory<>(predicate);
        FJIterate.forEach(iterable, procedureFactory, combiner, batchSize, executor);
        return combiner.getCount();
    }
401705
public double getCount(Object o) {
    if (depth > 1) {
      wrongDepth();
    }
    Number count = (Number) map.get(o);
    if (count != null) {
      return count.doubleValue();
    } else {
      return 0.0;
    }
  }
149859
public Counters getCounters() {
    Counters result = new Counters();
    synchronized (this) {
      result.incrAllCounters(getJobCounters());
    }

    incrementTaskCounters(result, maps);
    return incrementTaskCounters(result, reduces);
  }
1272134
public int getCount(Object o) {
    int[] nums = (int[]) cset.get(o);   
    if (nums == null ) {
      return(0);
    }
    else {
      return(nums[0]);
    }
  }
772690
public int getStatementCount() {
        int ret = 0;
        for (final StatementGroup sg : statementGroups) {
            ret += sg.getAllStatements().size();
        }
        return ret;
    }