Compute the size of all subtrees.

@param order Object order
@return Subtree sizes
171306
private WritableIntegerDataStore computeSubtreeSizes(DBIDs order) {
    WritableIntegerDataStore siz = DataStoreUtil.makeIntegerStorage(ids, DataStoreFactory.HINT_HOT | DataStoreFactory.HINT_TEMP, 1);
    DBIDVar v1 = DBIDUtil.newVar();
    for(DBIDIter it = order.iter(); it.valid(); it.advance()) {
      if(DBIDUtil.equal(it, parent.assignVar(it, v1))) {
        continue;
      }
      siz.increment(v1, siz.intValue(it));
    }
    return siz;
  }
1236129
public static Sort by(final List<Order> orders) {

    Assert.notNull(orders, "Orders must not be null!");

    return orders.isEmpty() ? Sort.unsorted() : new Sort(orders);
  }
793380
public int size() {
		int size = cleared ? 0 : snapshot.size();
		for ( Map.Entry<RowKey,AssociationOperation> op : currentState.entrySet() ) {
			switch ( op.getValue().getType() ) {
				case PUT:
					if ( cleared || !snapshot.containsKey( op.getKey() ) ) {
						size++;
					}
					break;
				case REMOVE:
					if ( !cleared && snapshot.containsKey( op.getKey() ) ) {
						size--;
					}
					break;
			}
		}
		return size;
	}
1056213
public int size() {
        int ele, count;

        count = 0;
        for (ele = first(); ele != -1; ele = next(ele)) {
            count++;
        }
        return count;
    }
934078
private int getMaxStructSize() {
		final int leafSize = (createLeafNode().getStructMaxSize());
		final int internalSize = (createInternalNode().getStructMaxSize());
		return Math.max(leafSize, internalSize);
	}
868835
public Sort and(final Sort sort) {

    Assert.notNull(sort, "Sort must not be null!");

    final ArrayList<Order> these = new ArrayList<>(orders);

    for (final Order order : sort) {
      these.add(order);
    }

    return Sort.by(these);
  }
1283790
OrderedProperty<S>[] asArray() {
        if (mOrderings == null) {
            OrderedProperty<S>[] orderings = new OrderedProperty[mSize];
            OrderingList<S> node = this;
            for (int i=mSize; --i>=0; ) {
                orderings[i] = node.mProperty;
                node = node.mParent;
            }
            mOrderings = orderings;
        }
        return mOrderings;
    }
67700
@Override
  public int size() {
    int size = 0;
    for (E e = first; e != null; e = getNext(e)) {
      size++;
    }
    return size;
  }
721791
public static long sizeOf(Struct sct) {
	Iterator<Entry<Key, Object>> it = sct.entryIterator();
	Entry<Key, Object> e;
	long size = 0;
	while (it.hasNext()) {
	    e = it.next();
	    size += SizeOf.size(e.getKey());
	    size += SizeOf.size(e.getValue());
	}
	return size;
    }
1103081
public static List<TreePath> computeExpandedPaths(JTree tree)
    {
        List<TreePath> treePaths = new ArrayList<TreePath>();
        int rows = tree.getRowCount();
        for (int i = 0; i < rows; i++)
        {
            TreePath treePath = tree.getPathForRow(i);
            treePaths.add(treePath);
        }
        return treePaths;
    }
493516
public static int computeListSize(int order, List<?> list, FieldType type, boolean debug, File path) {
        return computeListSize(order, list, type, debug, path, false, false);
    }
445130
public static Comparator<LongTuple> comparator(Order order)
    {
        if (order == Order.LEXICOGRAPHICAL)
        {
            return (t0, t1) -> compareLexicographically(t0, t1);
        }
        if (order == Order.COLEXICOGRAPHICAL)
        {
            return (t0, t1) -> compareColexicographically(t0, t1);
        }
        return null;
    }
144695
public int totalSize() {
        int size = 0;
        for (F first: keySet()) {
            size += getCounter(first).size();
        }

        return size;
    }
955959
public Integer getAllocationSize()
   {
      if(childNode.getAttribute("allocation-size") != null && !childNode.getAttribute("allocation-size").equals("null"))
      {
         return Integer.valueOf(childNode.getAttribute("allocation-size"));
      }
      return null;
   }
674549
public int sizeInSequence() {
        int sequence = 0;
        if (m_map.isEmpty()) {
            return sequence;
        }
        final Iterator<Range<Long>> iter = m_map.asRanges().iterator();
        while (iter.hasNext()) {
            Range<Long> range = iter.next();
            sequence += end(range) - start(range) + 1;
        }
        if (m_hasSentinel) {
            sequence -= 1;
        }
        return sequence;
    }
1173472
@Override
    public int size(PersistentStore store) {

        int count = 0;

        readLock.lock();

        try {
            RowIterator it = firstRow(null, store);

            while (it.hasNext()) {
                it.getNextRow();

                count++;
            }

            return count;
        } finally {
            readLock.unlock();
        }
    }
1054709
synchronized int getSize( int priority ) {
    int size = 0;
    for (int i=priority; i<LEVEL; i++) {
      size += priorityQueues.get(i).size();
    }
    return size;
  }