Returns the old chunk files.

@return Collection<ChunkFile> collection of a ChunkFile objects
193710
public function oldChunkFiles()
    {
        $files = $this->files();
        // if there are no files, lets return the empty collection
        if ($files->isEmpty()) {
            return $files;
        }

        // build the timestamp
        $timeToCheck = strtotime($this->config->clearTimestampString());
        $collection = new Collection();

        // filter the collection with files that are not correct chunk file
        // loop all current files and filter them by the time
        $files->each(function ($file) use ($timeToCheck, $collection) {
            // get the last modified time to check if the chunk is not new
            $modified = $this->disk()->lastModified($file);

            // delete only old chunk
            if ($modified < $timeToCheck) {
                $collection->push(new ChunkFile($file, $modified, $this));
            }
        });

        return $collection;
    }
1065541
public Collection<BoxFileVersion> getVersions() {
        URL url = VERSIONS_URL_TEMPLATE.build(this.getAPI().getBaseURL(), this.getID());
        BoxAPIRequest request = new BoxAPIRequest(this.getAPI(), url, "GET");
        BoxJSONResponse response = (BoxJSONResponse) request.send();

        JsonObject jsonObject = JsonObject.readFrom(response.getJSON());
        JsonArray entries = jsonObject.get("entries").asArray();
        Collection<BoxFileVersion> versions = new ArrayList<BoxFileVersion>();
        for (JsonValue entry : entries) {
            versions.add(new BoxFileVersion(this.getAPI(), entry.asObject(), this.getID()));
        }

        return versions;
    }
476497
public alluxio.grpc.Chunk getChunk() {
    return chunk_ == null ? alluxio.grpc.Chunk.getDefaultInstance() : chunk_;
  }
388069
public function getNewBuilds()
    {
        $lastBuildFilename = $this->getLatestBuildName();
        $iterator          = $this->getBuilds();

        $files = array();
        /** @var $fileInfo \splFileInfo */
        foreach ($iterator as $fileInfo) {
            if ($fileInfo->getFilename() > $lastBuildFilename) {
                array_push($files, $fileInfo->getPathname());
            }
        }

        // sort builds in timely order
        sort($files);

        return $files;
    }
337757
private Chunk[] getScoringChunks(Chunk[] allChunks) {
    if (_preds == null)
      return allChunks;
    Chunk[] chks = new Chunk[allChunks.length - _preds.numCols()];
    System.arraycopy(allChunks, 0, chks, 0, chks.length);
    return chks;
  }
785026
protected List<File> getSpooledFileList()
    {
        final List<File> spooledFileList = new ArrayList<File>();

        for (final File file : spoolDirectory.listFiles()) {
            if (file.isFile()) {
                spooledFileList.add(file);
            }
        }

        return spooledFileList;
    }
772328
@java.lang.Deprecated
  public java.util.Map<java.lang.String, java.lang.Long> getUsedBytesOnTiers() {
    return getUsedBytesOnTiersMap();
  }
1207711
public function files()
    {
        $filesList = array_filter($this->items, function($item) {
            return ($item['instance'] instanceof FileInterface);
        });

        $filesList = array_map(function($item) {
            return $item['instance'];
        }, $filesList);

        return new Collection($filesList);
    }
12882
def _GetChunk(self):
    """"""

    found_ref = None
    for ref in self._blob_refs:
      if self._offset >= ref.offset and self._offset < (ref.offset + ref.size):
        found_ref = ref
        break

    if not found_ref:
      return None, None

    # If self._current_ref == found_ref, then simply return previously found
    # chunk. Otherwise, update self._current_chunk value.
    if self._current_ref != found_ref:
      self._current_ref = found_ref

      data = data_store.BLOBS.ReadBlobs([found_ref.blob_id])
      self._current_chunk = data[found_ref.blob_id]

    return self._current_chunk, self._current_ref
925425
def get_chunked_archive(self, **kwargs):
        

        chunk_size = kwargs.pop('chunk_size', 8192)
        stream = kwargs.get('stream')
        self.fill_archive(**kwargs)
        while True:
            data = stream.read(chunk_size)
            if not data:
                break
            yield data
1314112
public List<Bucket> getBuckets() {
        List<Bucket> result = Lists.newArrayList();
        for (File file : getBaseDir().listFiles()) {
            if (file.isDirectory()) {
                result.add(new Bucket(file));
            }
        }

        return result;
    }
1030819
protected List<File> getRecursiveThriftFiles(MavenProject project, String outputDirectory) throws IOException {
    return getRecursiveThriftFiles(project, outputDirectory, new ArrayList<File>());
  }
29198
public function getCsvFiles()
    {
        // parse what's in cache before returning results
        while ($batch = $this->cache->getNext()) {
            // root node is always array
            $this->parse($batch["data"], new NodePath([$batch['type'], Structure::ARRAY_NAME]), $batch["parentId"]);
        }
        return $this->csvFiles;
    }
1305442
public static function getFiles()
    {
        if (self::$_files === null) {
            self::$_files = [];
            if (isset($_FILES) && is_array($_FILES)) {
                foreach ($_FILES as $class => $info) {
                    self::getUploadFilesRecursive($class, $info['name'], $info['error']);
                }
            }
        }
        return self::$_files;
    }
206461
synchronized List<SegmentChunk> chunks() {
        if (this.sealed) {
            return this.segmentChunks; // This is already an unmodifiable list.
        } else {
            return Collections.unmodifiableList(this.segmentChunks.subList(0, this.segmentChunks.size()));
        }
    }
800160
public ArrayList<MemorySegment> resetOverflowBuckets() {
		this.numOverflowSegments = 0;
		this.nextOverflowBucket = 0;
		
		ArrayList<MemorySegment> result = new ArrayList<MemorySegment>(this.overflowSegments.length);
		for(int i = 0; i < this.overflowSegments.length; i++) {
			if(this.overflowSegments[i] != null) {
				result.add(this.overflowSegments[i]);
			}
		}
		this.overflowSegments = new MemorySegment[2];
		return result;
	}
966830
protected final File getStaleFile() {
        final String staleFileName = "."
                + (getExecution() == null ? "nonExecutionJaxb" : getExecution().getExecutionId())
                + "-" + getStaleFileName();
        return new File(staleFileDirectory, staleFileName);
    }