fileio

type Dialect struct {
	Comma    rune
	Encoding string // "UTF-8", "UTF-16" or "Windows-1252"
}

type ErrNeedTable struct{ Tables []TableInfo }

type ExportOptions struct {
	Table string // SQLite: the table to write; replaced if it exists
}

type ExportResult struct {
	Rows  int
	Notes []string
}

type HTMLPage struct {
	Title string    // the page's title, and the first line's
	Snap  *Snapshot // the cells, when Chart is nil
	Chart *SnapChart
}

type Kind int

type LineFormat struct {
	Format sheet.Format
	Style  sheet.Style
}

type NumberSort struct {
	// contains filtered or unexported fields
}

type Options struct {
	// Table is the SQLite table to import, or Query a SELECT to run.
	// With neither, a database with one table imports it.
	Table, Query string
	Progress     *Progress
	// MaxCells is the most cells to keep, whole rows at a time; 0 is the
	// max-cells setting (sheet.MaxCells). WK1 files keep their own limits.
	MaxCells int
	// Locale is what CSV and TSV fields are read in (see numberLocale);
	// nil is en-US.
	Locale *locale.Locale
}

type Progress struct {
	// contains filtered or unexported fields
}

type RangeResolver func(ref string) (*sheet.Sheet, sheet.Rect, error)

type Result struct {
	Sheet *sheet.Sheet
	Kind  Kind
	Rows  int // rows of the file that were read, including a header
	Notes []string
}

type SnapCell struct {
	Input   string
	Value   sheet.Value
	Format  sheet.Format // as displayed, including one inferred from a formula
	Own     sheet.Format // the cell's own format
	Style   sheet.Style
	Formula bool
	Sheets  []string // the sheets a formula names, as written
	Tables  []string // the tables a formula reads, as written
}

type SnapChart struct {
	sheet.Chart
	Values sheet.ChartData
}

type SnapName struct {
	Name, Sheet string
	Range       sheet.Rect
}

type Snapshot struct {
	// Range is what's exported. Whole-sheet exports start at A1, as
	// Sheets' downloads do, so cells keep their addresses.
	Range  sheet.Rect
	Cells  map[sheet.Addr]SnapCell
	Widths map[int]int // non-default column widths
	Name   string      // what to call the data: a sheet or table name
	// Locale is the sheet's, which text formats (CSV) are written in.
	Locale *locale.Locale

	// ColFormats and RowFormats are the formats of whole columns and
	// rows, for formats that keep them (XLSX).
	ColFormats, RowFormats map[int]LineFormat

	// Sheets are every sheet of the workbook, in order, for formats that
	// hold several (XLSX); the snapshot itself is one of them, the one
	// shown. Nil exports just this snapshot. Names are the workbook's
	// named ranges.
	Sheets []*Snapshot
	Names  []SnapName
	Hidden bool // a hidden sheet of Sheets, written hidden

	// FrozenRows and FrozenCols are the frozen panes; Filter is the
	// sheet's filter, if any, and HiddenRows the rows of Range it hides,
	// for formats that keep them (XLSX).
	FrozenRows, FrozenCols int
	Filter                 *sheet.Filter
	HiddenRows             map[int]bool

	// Spills are the cells each formula whose array spills covers, by
	// the formula's cell, for formats that keep formulas (XLSX).
	Spills map[sheet.Addr]sheet.Rect

	// CondFormats and Validations are the sheet's rules, for formats
	// that keep them (XLSX).
	CondFormats []sheet.CondFormat
	Validations []sheet.Validation
	// Notes are the cells' notes in the range, for formats that keep
	// them (XLSX, as comments). A note may be on a cell with no contents.
	Notes map[sheet.Addr]string

	// Heights are the rows' heights set by hand, in lines, and Merges
	// the merged cells in the range, for formats that keep them (XLSX).
	Heights map[int]int
	Merges  []sheet.Rect

	// Tables are the tables wholly in the range, for formats that keep
	// them (XLSX).
	Tables []sheet.Table

	// Looks are how the sheet's rules draw the range's cells, and Charts
	// the charts whose top-left cell is in it, for formats that show
	// what the screen shows (HTML); see snapdrawn.go.
	Looks  map[sheet.Addr]sheet.Look
	Charts []SnapChart
}

type SortedNumbers struct {
	// contains filtered or unexported fields
}

type Source interface {
	// Columns are the source's columns, left to right.
	Columns() []SourceColumn
	// Rows counts its rows, the header not among them.
	Rows() int64
	// Scan streams the rows from row from on (counting from 0) in the
	// source's order, calling fn with each row's number and the values
	// of cols (every column when cols is nil, in that order; the slice
	// is reused) until fn returns false, the rows end or ctx is done.
	Scan(ctx context.Context, from int64, cols []int, fn func(row int64, vals []sheet.LiveCell) bool) error
	// Fetch reads the rows numbered rows, in the order given, with the
	// values of cols (every column when nil).
	Fetch(ctx context.Context, rows []int64, cols []int) ([][]sheet.LiveCell, error)
	// View orders the rows as o says. Building it may read the whole
	// source once, which the caller does in the background.
	View(ctx context.Context, o SourceOrder) (SourceView, error)
	// Close lets the file go, and what its views built.
	Close() error
}

type SourceColumn struct {
	Name string
	// Format is what its values show in when the column's type says (a
	// Parquet DATE column's FmtDate); a value's own may differ.
	Format sheet.Format
	// Numeric is set when its type holds numbers, dates and times
	// included.
	Numeric bool
}

type SourceFilter struct {
	Col  int
	Cond sheet.Condition
}

type SourceOrder struct {
	Sort   []SourceSort
	Filter []SourceFilter
}

type SourceSort struct {
	Col  int
	Desc bool
}

type SourceSpec struct {
	// Path is the file.
	Path string
	// Format is "Parquet" or "SQLite", or "" to tell by the extension.
	Format string
	// Table is a SQLite table or view to read, or Query a query to run;
	// both empty reads a database's only table.
	Table, Query string
	// TempDir is where views keep what they build (sorted row orders,
	// SQLite's temporary tables); "" is the system's.
	TempDir string
}

type SourceView interface {
	// Rows counts the rows the view shows.
	Rows() int64
	// Page reads n rows from position from of the view: each one's
	// number in the source and its values.
	Page(ctx context.Context, from int64, n int) ([]int64, [][]sheet.LiveCell, error)
	// Close lets go of what the view built.
	Close() error
}

type TableInfo struct {
	Name string
	View bool
	Rows int
	Cols []string
}

type Tail struct {
	// contains filtered or unexported fields
}

type TailRows struct {
	// Header is the table's first row when it's new or changed: a CSV
	// file's first record, or NUON's column names as they're seen.
	Header sheet.LiveRow
	Rows   []sheet.LiveRow
}