xlsx

package
v0.0.0-...-52d6a69 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jun 19, 2019 License: Apache-2.0, BSD-3-Clause Imports: 15 Imported by: 0

README

* XLSX

[[https://travis-ci.org/tealeg/xlsx][https://img.shields.io/travis/tealeg/xlsx/master.svg?style=flat-square]]
[[https://codecov.io/gh/tealeg/xlsx][https://codecov.io/gh/tealeg/xlsx/branch/master/graph/badge.svg]]
[[https://godoc.org/github.com/tealeg/xlsx][https://godoc.org/github.com/tealeg/xlsx?status.svg]]
[[https://github.com/tealeg/xlsx#license][https://img.shields.io/badge/license-bsd-orange.svg]]

** Introduction
xlsx is a library to simplify reading and writing the XML format used
by recent version of Microsoft Excel in Go programs.

The support for writing XLSX files is currently extremely minimal.  It
will expand slowly, but in the meantime patches are welcome!

** Full API docs
The full API docs can be viewed using go's built in documentation
tool, or online at [[http://godoc.org/github.com/tealeg/xlsx][godoc.org]].

** Basic Usage
*** Reading XLSX files
Here is a minimal example usage that will dump all cell data in a
given XLSX file.  A more complete example of this kind of
functionality is contained in [[https://github.com/tealeg/xlsx2csv][the XLSX2CSV program]]:

#+BEGIN_SRC go

package main

import (
    "fmt"
    "github.com/tealeg/xlsx"
)

func main() {
    excelFileName := "/home/tealeg/foo.xlsx"
    xlFile, err := xlsx.OpenFile(excelFileName)
    if err != nil {
        ...
    }
    for _, sheet := range xlFile.Sheets {
        for _, row := range sheet.Rows {
            for _, cell := range row.Cells {
                text := cell.String()
                fmt.Printf("%s\n", text)
            }
        }
    }
}

#+END_SRC

Some additional information is available from the cell (for example,
style information).  For more details see the godoc output for this
package.

*** Writing XLSX files
The following constitutes the bare minimum required to write an XLSX document.

#+BEGIN_SRC go

package main

import (
    "fmt"
    "github.com/tealeg/xlsx"
)

func main() {
    var file *xlsx.File
    var sheet *xlsx.Sheet
    var row *xlsx.Row
    var cell *xlsx.Cell
    var err error

    file = xlsx.NewFile()
    sheet, err = file.AddSheet("Sheet1")
    if err != nil {
        fmt.Printf(err.Error())
    }
    row = sheet.AddRow()
    cell = row.AddCell()
    cell.Value = "I am a cell!"
    err = file.Save("MyXLSXFile.xlsx")
    if err != nil {
        fmt.Printf(err.Error())
    }
}

#+END_SRC

** Contributing

We're extremely happy to review pull requests.  Please be patient, maintaining XLSX doesn't pay anyone's salary (to my knowledge).

If you'd like to propose a change please ensure the following:

- All existing tests are passing.
- There are tests in the test suite that cover the changes you're making.
- You have added documentation strings (in English) to (at least) the public functions you've added or modified.
- Your use of, or creation of, XML is compliant with [[http://www.ecma-international.org/publications/standards/Ecma-376.htm][part 1 of the 4th edition of the ECMA-376 Standard for Office Open XML]].

Eat a peach - Geoff

Documentation

Index

Examples

Constants

View Source
const ColWidth = 9.5

Default column width in excel

View Source
const MJD_0 float64 = 2400000.5
View Source
const MJD_JD2000 float64 = 51544.5
View Source
const NoRowLimit int = -1
View Source
const TEMPLATE_DOCPROPS_APP = `` /* 308-byte string literal not displayed */
View Source
const TEMPLATE_DOCPROPS_CORE = `` /* 364-byte string literal not displayed */
View Source
const TEMPLATE_XL_THEME_THEME = `` /* 10942-byte string literal not displayed */
View Source
const TEMPLATE__RELS_DOT_RELS = `` /* 580-byte string literal not displayed */

Variables

View Source
var (
	DefaultDateFormat     = builtInNumFmt[14]
	DefaultDateTimeFormat = builtInNumFmt[22]

	DefaultDateOptions = DateTimeOptions{
		Location:        timeLocationUTC,
		ExcelTimeFormat: DefaultDateFormat,
	}

	DefaultDateTimeOptions = DateTimeOptions{
		Location:        timeLocationUTC,
		ExcelTimeFormat: DefaultDateTimeFormat,
	}
)
View Source
var (
	NoCurrentSheetError     = errors.New("no Current Sheet")
	WrongNumberOfRowsError  = errors.New("invalid number of cells passed to Write. All calls to Write on the same sheet must have the same number of cells")
	AlreadyOnLastSheetError = errors.New("NextSheet() called, but already on last sheet")
)
View Source
var BuiltStreamFileBuilderError = errors.New("StreamFileBuilder has already been built, functions may no longer be used")
View Source
var HSLModel = color.ModelFunc(hslModel)

HSLModel converts any color.Color to a HSL color.

Functions

func ColIndexToLetters

func ColIndexToLetters(colRef int) string

ColIndexToLetters is used to convert a zero based, numeric column indentifier into a character code.

func ColLettersToIndex

func ColLettersToIndex(letters string) int

ColLettersToIndex is used to convert a character based column reference to a zero based numeric column identifier.

func FileToSlice

func FileToSlice(path string) ([][][]string, error)

A convenient wrapper around File.ToSlice, FileToSlice will return the raw data contained in an Excel XLSX file as three dimensional slice. The first index represents the sheet number, the second the row number, and the third the cell number.

For example:

var mySlice [][][]string
var value string
mySlice = xlsx.FileToSlice("myXLSX.xlsx")
value = mySlice[0][0][0]

Here, value would be set to the raw value of the cell A1 in the first sheet in the XLSX file.

func FileToSliceUnmerged

func FileToSliceUnmerged(path string) ([][][]string, error)

FileToSliceUnmerged is a wrapper around File.ToSliceUnmerged. It returns the raw data contained in an Excel XLSX file as three dimensional slice. Merged cells will be unmerged. Covered cells become the values of theirs origins.

func GetCellIDStringFromCoords

func GetCellIDStringFromCoords(x, y int) string

GetCellIDStringFromCoords returns the Excel format cell name that represents a pair of zero based cartesian coordinates.

func GetCoordsFromCellIDString

func GetCoordsFromCellIDString(cellIDString string) (x, y int, error error)

GetCoordsFromCellIDString returns the zero based cartesian coordinates from a cell name in Excel format, e.g. the cellIDString "A1" returns 0, 0 and the "B3" return 1, 2.

func HSLToRGB

func HSLToRGB(h, s, l float64) (r, g, b uint8)

HSLToRGB converts an HSL triple to a RGB triple.

Ported from http://goo.gl/Vg1h9

func MakeDefaultContentTypes

func MakeDefaultContentTypes() (types xlsxTypes)

func RGBToHSL

func RGBToHSL(r, g, b uint8) (h, s, l float64)

RGBToHSL converts an RGB triple to a HSL triple.

Ported from http://goo.gl/Vg1h9

func SetDefaultFont

func SetDefaultFont(size int, name string)

func TimeFromExcelTime

func TimeFromExcelTime(excelTime float64, date1904 bool) time.Time

Convert an excelTime representation (stored as a floating point number) to a time.Time.

func TimeToExcelTime

func TimeToExcelTime(t time.Time) float64

func TimeToUTCTime

func TimeToUTCTime(t time.Time) time.Time

Types

type Alignment

type Alignment struct {
	Horizontal   string
	Indent       int
	ShrinkToFit  bool
	TextRotation int
	Vertical     string
	WrapText     bool
}

func DefaultAlignment

func DefaultAlignment() *Alignment

type AutoFilter

type AutoFilter struct {
	TopLeftCell     string
	BottomRightCell string
}

type Border

type Border struct {
	Left        string
	LeftColor   string
	Right       string
	RightColor  string
	Top         string
	TopColor    string
	Bottom      string
	BottomColor string
}

Border is a high level structure intended to provide user access to the contents of Border Style within an Sheet.

func DefaultBorder

func DefaultBorder() *Border

func NewBorder

func NewBorder(left, right, top, bottom string) *Border

type Cell

type Cell struct {
	Row   *Row
	Value string

	NumFmt string

	Hidden bool
	HMerge int
	VMerge int
	// contains filtered or unexported fields
}

Cell is a high level structure intended to provide user access to the contents of Cell within an xlsx.Row.

func NewCell

func NewCell(r *Row) *Cell

NewCell creates a cell and adds it to a row.

func (*Cell) Bool

func (c *Cell) Bool() bool

Bool returns a boolean from a cell's value. TODO: Determine if the current return value is appropriate for types other than CellTypeBool.

func (*Cell) Float

func (c *Cell) Float() (float64, error)

Float returns the value of cell as a number.

func (*Cell) FormattedValue

func (c *Cell) FormattedValue() (string, error)

FormattedValue returns a value, and possibly an error condition from a Cell. If it is possible to apply a format to the cell value, it will do so, if not then an error will be returned, along with the raw value of the Cell.

func (*Cell) Formula

func (c *Cell) Formula() string

Formula returns the formula string for the cell.

func (*Cell) GeneralNumeric

func (c *Cell) GeneralNumeric() (string, error)

GeneralNumeric returns the value of the cell as a string. It is formatted very closely to the the XLSX spec for how to display values when the storage type is Number and the format type is General. It is not 100% identical to the spec but is as close as you can get using the built in Go formatting tools.

func (*Cell) GeneralNumericWithoutScientific

func (c *Cell) GeneralNumericWithoutScientific() (string, error)

GeneralNumericWithoutScientific returns numbers that are always formatted as numbers, but it does not follow the rules for when XLSX should switch to scientific notation, since sometimes scientific notation is not desired, even if that is how the document is supposed to be formatted.

func (*Cell) GetNumberFormat

func (c *Cell) GetNumberFormat() string

GetNumberFormat returns the number format string for a cell.

func (*Cell) GetStyle

func (c *Cell) GetStyle() *Style

GetStyle returns the Style associated with a Cell

func (*Cell) GetTime

func (c *Cell) GetTime(date1904 bool) (t time.Time, err error)

GetTime returns the value of a Cell as a time.Time

func (*Cell) Int

func (c *Cell) Int() (int, error)

Int returns the value of cell as integer. Has max 53 bits of precision See: float64(int64(math.MaxInt))

func (*Cell) Int64

func (c *Cell) Int64() (int64, error)

Int64 returns the value of cell as 64-bit integer.

func (*Cell) Merge

func (c *Cell) Merge(hcells, vcells int)

Merge with other cells, horizontally and/or vertically.

func (*Cell) SetBool

func (c *Cell) SetBool(b bool)

SetBool sets a cell's value to a boolean.

func (*Cell) SetDate

func (c *Cell) SetDate(t time.Time)

SetDate sets the value of a cell to a float.

func (*Cell) SetDateTime

func (c *Cell) SetDateTime(t time.Time)

func (*Cell) SetDateTimeWithFormat

func (c *Cell) SetDateTimeWithFormat(n float64, format string)

func (*Cell) SetDateWithOptions

func (c *Cell) SetDateWithOptions(t time.Time, options DateTimeOptions)

SetDateWithOptions allows for more granular control when exporting dates and times

func (*Cell) SetFloat

func (c *Cell) SetFloat(n float64)

SetFloat sets the value of a cell to a float.

func (*Cell) SetFloatWithFormat

func (c *Cell) SetFloatWithFormat(n float64, format string)

SetFloatWithFormat sets the value of a cell to a float and applies formatting to the cell.

func (*Cell) SetFormula

func (c *Cell) SetFormula(formula string)

SetFormula sets the format string for a cell.

func (*Cell) SetInt

func (c *Cell) SetInt(n int)

SetInt sets a cell's value to an integer.

func (*Cell) SetInt64

func (c *Cell) SetInt64(n int64)

SetInt64 sets a cell's value to a 64-bit integer.

func (*Cell) SetString

func (c *Cell) SetString(s string)

SetString sets the value of a cell to a string.

func (*Cell) SetStringFormula

func (c *Cell) SetStringFormula(formula string)

func (*Cell) SetStyle

func (c *Cell) SetStyle(style *Style)

SetStyle sets the style of a cell.

func (*Cell) SetValue

func (c *Cell) SetValue(n interface{})

SetInt sets a cell's value to an integer.

func (*Cell) String

func (c *Cell) String() string

String returns the value of a Cell as a string. If you'd like to see errors returned from formatting then please use Cell.FormattedValue() instead.

func (*Cell) Type

func (c *Cell) Type() CellType

Type returns the CellType of a cell. See CellType constants for more details.

type CellInterface

type CellInterface interface {
	String() string
	FormattedValue() string
}

CellInterface defines the public API of the Cell.

type CellType

type CellType int

CellType is an int type for storing metadata about the data type in the cell.

const (
	CellTypeString CellType = iota
	// CellTypeStringFormula is a specific format for formulas that return string values. Formulas that return numbers
	// and booleans are stored as those types.
	CellTypeStringFormula
	CellTypeNumeric
	CellTypeBool
	// CellTypeInline is not respected on save, all inline string cells will be saved as SharedStrings
	// when saving to an XLSX file. This the same behavior as that found in Excel.
	CellTypeInline
	CellTypeError
	// d (Date): Cell contains a date in the ISO 8601 format.
	// That is the only mention of this format in the XLSX spec.
	// Date seems to be unused by the current version of Excel, it stores dates as Numeric cells with a date format string.
	// For now these cells will have their value output directly. It is unclear if the value is supposed to be parsed
	// into a number and then formatted using the formatting or not.
	CellTypeDate
)

These are the cell types from the ST_CellType spec

func (CellType) Ptr

func (ct CellType) Ptr() *CellType

type Col

type Col struct {
	Min          int
	Max          int
	Hidden       bool
	Width        float64
	Collapsed    bool
	OutlineLevel uint8
	// contains filtered or unexported fields
}

func (*Col) GetStyle

func (c *Col) GetStyle() *Style

GetStyle returns the Style associated with a Col

func (*Col) SetStyle

func (c *Col) SetStyle(style *Style)

SetStyle sets the style of a Col

func (*Col) SetType

func (c *Col) SetType(cellType CellType)

SetType will set the format string of a column based on the type that you want to set it to. This function does not really make a lot of sense.

type DateTimeOptions

type DateTimeOptions struct {
	// Location allows calculating times in other timezones/locations
	Location *time.Location
	// ExcelTimeFormat is the string you want excel to use to format the datetime
	ExcelTimeFormat string
}

DateTimeOptions are additional options for exporting times

type File

type File struct {
	Date1904 bool

	Sheets []*Sheet
	Sheet  map[string]*Sheet

	DefinedNames []*xlsxDefinedName
	// contains filtered or unexported fields
}

File is a high level structure providing a slice of Sheet structs to the user.

func NewFile

func NewFile() *File

Create a new File

func OpenBinary

func OpenBinary(bs []byte) (*File, error)

OpenBinary() take bytes of an XLSX file and returns a populated xlsx.File struct for it.

func OpenBinaryWithRowLimit

func OpenBinaryWithRowLimit(bs []byte, rowLimit int) (*File, error)

OpenBinaryWithRowLimit() take bytes of an XLSX file and returns a populated xlsx.File struct for it.

func OpenFile

func OpenFile(fileName string) (file *File, err error)

OpenFile() take the name of an XLSX file and returns a populated xlsx.File struct for it.

func OpenFileWithRowLimit

func OpenFileWithRowLimit(fileName string, rowLimit int) (file *File, err error)

OpenFileWithRowLimit() will open the file, but will only read the specified number of rows. If you save this file, it will be truncated to the number of rows specified.

func OpenReaderAt

func OpenReaderAt(r io.ReaderAt, size int64) (*File, error)

OpenReaderAt() take io.ReaderAt of an XLSX file and returns a populated xlsx.File struct for it.

func OpenReaderAtWithRowLimit

func OpenReaderAtWithRowLimit(r io.ReaderAt, size int64, rowLimit int) (*File, error)

OpenReaderAtWithRowLimit() take io.ReaderAt of an XLSX file and returns a populated xlsx.File struct for it.

func ReadZip

func ReadZip(f *zip.ReadCloser) (*File, error)

ReadZip() takes a pointer to a zip.ReadCloser and returns a xlsx.File struct populated with its contents. In most cases ReadZip is not used directly, but is called internally by OpenFile.

func ReadZipReader

func ReadZipReader(r *zip.Reader) (*File, error)

ReadZipReader() can be used to read an XLSX in memory without touching the filesystem.

func ReadZipReaderWithRowLimit

func ReadZipReaderWithRowLimit(r *zip.Reader, rowLimit int) (*File, error)

ReadZipReaderWithRowLimit() can be used to read an XLSX in memory without touching the filesystem. rowLimit is the number of rows that should be read from the file. If rowLimit is -1, no limit is applied. You can specify this with the constant NoRowLimit.

func ReadZipWithRowLimit

func ReadZipWithRowLimit(f *zip.ReadCloser, rowLimit int) (*File, error)

ReadZipWithRowLimit() takes a pointer to a zip.ReadCloser and returns a xlsx.File struct populated with its contents. In most cases ReadZip is not used directly, but is called internally by OpenFile.

func (*File) AddSheet

func (f *File) AddSheet(sheetName string) (*Sheet, error)

Add a new Sheet, with the provided name, to a File

func (*File) AppendSheet

func (f *File) AppendSheet(sheet Sheet, sheetName string) (*Sheet, error)

Appends an existing Sheet, with the provided name, to a File

func (*File) MarshallParts

func (f *File) MarshallParts() (map[string]string, error)

Construct a map of file name to XML content representing the file in terms of the structure of an XLSX file.

func (*File) Save

func (f *File) Save(path string) (err error)

Save the File to an xlsx file at the provided path.

func (*File) ToSlice

func (f *File) ToSlice() (output [][][]string, err error)

Return the raw data contained in the File as three dimensional slice. The first index represents the sheet number, the second the row number, and the third the cell number.

For example:

var mySlice [][][]string
var value string
mySlice = xlsx.FileToSlice("myXLSX.xlsx")
value = mySlice[0][0][0]

Here, value would be set to the raw value of the cell A1 in the first sheet in the XLSX file.

func (*File) ToSliceUnmerged

func (f *File) ToSliceUnmerged() (output [][][]string, err error)

ToSliceUnmerged returns the raw data contained in the File as three dimensional slice (s. method ToSlice). A covered cell become the value of its origin cell. Example: table where A1:A2 merged. | 01.01.2011 | Bread | 20 | | | Fish | 70 | This sheet will be converted to the slice: [ [01.01.2011 Bread 20]

[01.01.2011 Fish 70] ]

func (*File) Write

func (f *File) Write(writer io.Writer) (err error)

Write the File to io.Writer as xlsx

type Fill

type Fill struct {
	PatternType string
	BgColor     string
	FgColor     string
}

Fill is a high level structure intended to provide user access to the contents of background and foreground color index within an Sheet.

func DefaultFill

func DefaultFill() *Fill

func NewFill

func NewFill(patternType, fgColor, bgColor string) *Fill

type Font

type Font struct {
	Size      int
	Name      string
	Family    int
	Charset   int
	Color     string
	Bold      bool
	Italic    bool
	Underline bool
}

func DefaultFont

func DefaultFont() *Font

func NewFont

func NewFont(size int, name string) *Font

type HSL

type HSL struct {
	H, S, L float64
}

HSL represents a cylindrical coordinate of points in an RGB color model.

Values are in the range 0 to 1.

func (HSL) RGBA

func (c HSL) RGBA() (uint32, uint32, uint32, uint32)

RGBA returns the alpha-premultiplied red, green, blue and alpha values for the HSL.

type Pane

type Pane struct {
	XSplit      float64
	YSplit      float64
	TopLeftCell string
	ActivePane  string
	State       string // Either "split" or "frozen"
}

type RefTable

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

func MakeSharedStringRefTable

func MakeSharedStringRefTable(source *xlsxSST) *RefTable

MakeSharedStringRefTable() takes an xlsxSST struct and converts it's contents to an slice of strings used to refer to string values by numeric index - this is the model used within XLSX worksheet (a numeric reference is stored to a shared cell value).

func NewSharedStringRefTable

func NewSharedStringRefTable() *RefTable

NewSharedStringRefTable() creates a new, empty RefTable.

func (*RefTable) AddString

func (rt *RefTable) AddString(str string) int

AddString adds a string to the reference table and return it's numeric index. If the string already exists then it simply returns the existing index.

func (*RefTable) Length

func (rt *RefTable) Length() int

func (*RefTable) ResolveSharedString

func (rt *RefTable) ResolveSharedString(index int) string

Resolvesharedstring() looks up a string value by numeric index from a provided reference table (just a slice of strings in the correct order). This function only exists to provide clarity or purpose via it's name.

type Row

type Row struct {
	Cells        []*Cell
	Hidden       bool
	Sheet        *Sheet
	Height       float64
	OutlineLevel uint8
	// contains filtered or unexported fields
}

func (*Row) AddCell

func (r *Row) AddCell() *Cell

func (*Row) ReadStruct

func (r *Row) ReadStruct(ptr interface{}) error

ReadStruct reads a struct from r to ptr. Accepts a ptr to struct. This code expects a tag xlsx:"N", where N is the index of the cell to be used. Basic types like int,string,float64 and bool are supported

Example
//example type
type structTest struct {
	IntVal     int     `xlsx:"0"`
	StringVal  string  `xlsx:"1"`
	FloatVal   float64 `xlsx:"2"`
	IgnoredVal int     `xlsx:"-"`
	BoolVal    bool    `xlsx:"4"`
}
structVal := structTest{
	IntVal:     16,
	StringVal:  "heyheyhey :)!",
	FloatVal:   3.14159216,
	IgnoredVal: 7,
	BoolVal:    true,
}
//create a new xlsx file and write a struct
//in a new row
f := NewFile()
sheet, _ := f.AddSheet("TestRead")
row := sheet.AddRow()
row.WriteStruct(&structVal, -1)

//read the struct from the same row
readStruct := &structTest{}
err := row.ReadStruct(readStruct)
if err != nil {
	fmt.Println(readStruct)
} else {
	panic(err)
}
Output:

func (*Row) SetHeight

func (r *Row) SetHeight(ht float64)

func (*Row) SetHeightCM

func (r *Row) SetHeightCM(ht float64)

func (*Row) WriteSlice

func (r *Row) WriteSlice(e interface{}, cols int) int

Writes an array to row r. Accepts a pointer to array type 'e', and writes the number of columns to write, 'cols'. If 'cols' is < 0, the entire array will be written if possible. Returns -1 if the 'e' doesn't point to an array, otherwise the number of columns written.

func (*Row) WriteStruct

func (r *Row) WriteStruct(e interface{}, cols int) int

Writes a struct to row r. Accepts a pointer to struct type 'e', and the number of columns to write, `cols`. If 'cols' is < 0, the entire struct will be written if possible. Returns -1 if the 'e' doesn't point to a struct, otherwise the number of columns written

type Sheet

type Sheet struct {
	Name        string
	File        *File
	Rows        []*Row
	Cols        []*Col
	MaxRow      int
	MaxCol      int
	Hidden      bool
	Selected    bool
	SheetViews  []SheetView
	SheetFormat SheetFormat
	AutoFilter  *AutoFilter
}

Sheet is a high level structure intended to provide user access to the contents of a particular sheet within an XLSX file.

func (*Sheet) AddRow

func (s *Sheet) AddRow() *Row

Add a new Row to a Sheet

func (*Sheet) Cell

func (sh *Sheet) Cell(row, col int) *Cell

Get a Cell by passing it's cartesian coordinates (zero based) as row and column integer indexes.

For example:

cell := sheet.Cell(0,0)

... would set the variable "cell" to contain a Cell struct containing the data from the field "A1" on the spreadsheet.

func (*Sheet) Col

func (s *Sheet) Col(idx int) *Col

Make sure we always have as many Cols as we do cells.

func (*Sheet) SetColWidth

func (s *Sheet) SetColWidth(startcol, endcol int, width float64) error

Set the width of a single column or multiple columns.

type SheetFormat

type SheetFormat struct {
	DefaultColWidth  float64
	DefaultRowHeight float64
	OutlineLevelCol  uint8
	OutlineLevelRow  uint8
}

type SheetView

type SheetView struct {
	Pane *Pane
}

type StreamFile

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

func (*StreamFile) Close

func (sf *StreamFile) Close() error

Close closes the Stream File. Any sheets that have not yet been written to will have an empty sheet created for them.

func (*StreamFile) Error

func (sf *StreamFile) Error() error

Error reports any error that has occurred during a previous Write or Flush.

func (*StreamFile) Flush

func (sf *StreamFile) Flush()

func (*StreamFile) NextSheet

func (sf *StreamFile) NextSheet() error

NextSheet will switch to the next sheet. Sheets are selected in the same order they were added. Once you leave a sheet, you cannot return to it.

func (*StreamFile) Write

func (sf *StreamFile) Write(cells []string) error

Write will write a row of cells to the current sheet. Every call to Write on the same sheet must contain the same number of cells as the header provided when the sheet was created or an error will be returned. This function will always trigger a flush on success. Currently the only supported data type is string data.

func (*StreamFile) WriteAll

func (sf *StreamFile) WriteAll(records [][]string) error

type StreamFileBuilder

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

func NewStreamFileBuilder

func NewStreamFileBuilder(writer io.Writer) *StreamFileBuilder

NewStreamFileBuilder creates an StreamFileBuilder that will write to the the provided io.writer

func NewStreamFileBuilderForPath

func NewStreamFileBuilderForPath(path string) (*StreamFileBuilder, error)

NewStreamFileBuilderForPath takes the name of an XLSX file and returns a builder for it. The file will be created if it does not exist, or truncated if it does.

func (*StreamFileBuilder) AddSheet

func (sb *StreamFileBuilder) AddSheet(name string, headers []string, cellTypes []*CellType) error

AddSheet will add sheets with the given name with the provided headers. The headers cannot be edited later, and all rows written to the sheet must contain the same number of cells as the header. Sheet names must be unique, or an error will be thrown.

func (*StreamFileBuilder) Build

func (sb *StreamFileBuilder) Build() (*StreamFile, error)

Build begins streaming the XLSX file to the io, by writing all the XLSX metadata. It creates a StreamFile struct that can be used to write the rows to the sheets.

type Style

type Style struct {
	Border          Border
	Fill            Fill
	Font            Font
	ApplyBorder     bool
	ApplyFill       bool
	ApplyFont       bool
	ApplyAlignment  bool
	Alignment       Alignment
	NamedStyleIndex *int
}

Style is a high level structure intended to provide user access to the contents of Style within an XLSX file.

func NewStyle

func NewStyle() *Style

Return a new Style structure initialised with the default values.

type WorkBookRels

type WorkBookRels map[string]string

func (*WorkBookRels) MakeXLSXWorkbookRels

func (w *WorkBookRels) MakeXLSXWorkbookRels() xlsxWorkbookRels

type XLSXReaderError

type XLSXReaderError struct {
	Err string
}

XLSXReaderError is the standard error type for otherwise undefined errors in the XSLX reading process.

func (*XLSXReaderError) Error

func (e *XLSXReaderError) Error() string

Error returns a string value from an XLSXReaderError struct in order that it might comply with the builtin.error interface.

type XLSXUnmarshaler

type XLSXUnmarshaler interface {
	Unmarshal(*Row) error
}

XLSXUnmarshaler is the interface implemented for types that can unmarshal a Row as a representation of themselves.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL