log.debug("Reading " + tc.getConfig().getLmHostsFileName());
                    }
                    this.lastModified = lm;
                    this.table.clear();
                    try (FileReader r = new FileReader(f)) {
                        populate(r, tc);
                    }
                }
                result = this.table.get(name);
            }
        } catch (final IOException fnfe) {

import org.gradle.api.tasks.PathSensitivity;
import org.gradle.api.tasks.TaskAction;
import org.gradle.internal.UncheckedException;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;

import org.codelibs.core.exception.IORuntimeException;

/**

        appendFileContentsTo(document.head(), "<style>", releaseNotesCss, "</style>");
    }

    private void appendFileContentsTo(Element element, String open, File file, String close) {
        try (FileReader reader = new FileReader(file)) {
            element.append(open + CharStreams.toString(reader) + close);
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

// physicalRemaining implements fileState.physicalRemaining.
func (fr regFileReader) physicalRemaining() int64 {
	return fr.nb
}

// sparseFileReader is a fileReader for reading data from a sparse file entry.
type sparseFileReader struct {
	fr  fileReader  // Underlying fileReader
	sp  sparseHoles // Normalized list of sparse holes
	pos int64       // Current position in sparse file
}

	"github.com/minio/minio/internal/s3select/jstream"
	"github.com/minio/minio/internal/s3select/sql"
)

// Reader implements reading records from parquet input.
type Reader struct {
	io.Closer
	r *parquetgo.FileReader
}

// NewParquetReader creates a Reader2 from a io.ReadSeekCloser.
func NewParquetReader(rsc io.ReadSeekCloser, _ *ReaderArgs) (r *Reader, err error) {
	fr, err := parquetgo.NewFileReader(rsc)
	if err != nil {

			testWriteTo{fileOps{int64(1), "abc", int64(2), "defgh", int64(4)}, 15, errUnrefData},
			testRead{100, "", errUnrefData},
			testRemaining{0, 5},
		},
	}}

	for i, v := range vectors {
		var fr fileReader
		switch maker := v.maker.(type) {
		case makeReg:
			r := testNonEmptyReader{strings.NewReader(maker.str)}
			fr = &regFileReader{r, maker.size}
		case makeSparse:

pkg archive/tar, method (*Header) FileInfo() os.FileInfo
pkg archive/zip, const Deflate = 8
pkg archive/zip, const Store = 0
pkg archive/zip, type FileHeader struct, CompressedSize64 uint64
pkg archive/zip, type FileHeader struct, UncompressedSize64 uint64
pkg bufio, const MaxScanTokenSize = 65536
pkg bufio, const MaxScanTokenSize ideal-int
pkg bufio, func NewScanner(io.Reader) *Scanner