Gather a collection of files at least as large as minSize.
@return The total size of files returned.
549527
public long getInputFiles(long minSize, Collection<FileStatus> files)
      throws IOException {
    updateLock.readLock().lock();
    try {
      return root.selectFiles(minSize, files);
    } finally {
      updateLock.readLock().unlock();
    }
  }
316875
def size(self):
        """"""
        total_size = 0
        for dir_path, dir_names, filenames in os.walk(self.dir):
            for f in filenames:
                fp = os.path.join(dir_path, f)
                total_size += os.path.getsize(fp)
        return total_size
631675
public static int getSize (Object[] list)
    {
        int size = 0;
        for (int ii = 0, nn = (list == null) ? 0 : list.length; ii < nn; ii++) {
            if (list[ii] != null) {
                size++;
            }
        }
        return size;
    }
459646
private int getSize() {

        return Integer.valueOf(
            (String)CmsVaadinUtils.getRequest().getSession().getAttribute(ATTR_FILE_VIEW_SIZE)).intValue();
    }
441800
public int getSerializedSize() {
    int size = 0;
    for (int i = 0; i < fields.getNumArrayEntries(); i++) {
      final Map.Entry<FieldDescriptorType, Object> entry =
          fields.getArrayEntryAt(i);
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    for (final Map.Entry<FieldDescriptorType, Object> entry :
         fields.getOverflowEntries()) {
      size += computeFieldSize(entry.getKey(), entry.getValue());
    }
    return size;
  }
1071624
public long getUsedSpace() {
        long count = 0L;
        final int bufferSize = 1024 * 8;// Relatively big buffer (8MB); we're just reading

        final Map<ArchivePath, Node> contents = archive.getContent();
        final Collection<Node> nodes = contents.values();
        for (final Node node : nodes) {
            final Asset asset = node.getAsset();
            if (asset == null) {
                continue; // Directory
            }
            final InputStream in = new BufferedInputStream(asset.openStream(), bufferSize);
            final byte[] buffer = new byte[bufferSize];

            int read = 0;
            try {
                while ((read = in.read(buffer)) != -1) {
                    // Just count
                    count += read;
                }
            } catch (final IOException ioe) {
                throw new RuntimeException("Could not count size of archive " + this.archive.getName() + " at "
                    + asset.toString(), ioe);
            }

        }

        return count;
    }
357397
static long getTotalSize(Collection<Allocation> allocations) {
    long totalSize = 0;
    for (Allocation allocation : allocations) {
      totalSize += allocation.size;
    }
    return totalSize;
  }
769650
public Integer getFileSizeThreshold()
   {
      if (childNode.getTextValueForPatternName("file-size-threshold") != null && !childNode.getTextValueForPatternName("file-size-threshold").equals("null")) {
         return Integer.valueOf(childNode.getTextValueForPatternName("file-size-threshold"));
      }
      return null;
   }
865353
public static int getSparseStorageSize(int nonEmptyBuckets)
  {
    return COMMON_FIELDS_SIZE +
           Integer.BYTES +
           (Integer.BYTES + Long.BYTES) * nonEmptyBuckets;
  }
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;
   }
906642
static long calculateDirSizeAndSave(final File dir) throws IOException {
    final Path path = Paths.get(dir.getPath(), FlowPreparer.PROJECT_DIR_SIZE_FILE_NAME);
    if (!Files.exists(path)) {
      final long sizeInByte = FileUtils.sizeOfDirectory(dir);
      FileIOUtils.dumpNumberToFile(path, sizeInByte);
      return sizeInByte;
    } else {
      return FileIOUtils.readNumberFromFile(path);
    }
  }
1093036
public int getNextFiles(final File[] files, final int batchSize) throws IOException {
		int c=0;
		while(c<batchSize) {
			File file=getNextFile();
			if(file==null) break;
			files[c++]=file;
		}
		return c;
	}
1027804
@Override
	public long getSize() throws IOException {
		if (length < 0) {
			try {
				if (activeMethod != null) {
					length = activeMethod.getResponseContentLength();
				} else {
					acquireLength();
				}
			} catch (URISyntaxException e) {
				throw new IOException(e);
			}
		}
		return length;
	}
845170
@Override
    public long getFileSize() {
        try {
            final rh_protoClient client = getRpcClient(OncRpcProtocols.ONCRPC_UDP);
            try {
                return BlockingWrapper.execute(() -> client.getFileSize_1());
            } finally {
                client.close();
            }
        } catch (OncRpcException | IOException | InterruptedException | RuntimeException ex) {
            LOG.log(Level.SEVERE, "getFileSize RPC call failed", ex);
            throw new RuntimeException("RPC call failed", ex);
        }
    }
144695
public int totalSize() {
        int size = 0;
        for (F first: keySet()) {
            size += getCounter(first).size();
        }

        return size;
    }
1186210
public function getSize() : int
    {
        $files = $this->getFiles();
        $size = 0;
        foreach($files as $file) {
            $size += $file->getSize();
        }
        return $size;
    }
628867
public int getSize() {
		int dataSize = size;

		for (int i = 0; i < getChildCount(); i++) {
			dataSize += ((ObjectGraphNode) getChildAt(i)).getSize();
		}

		return dataSize;
	}