files

func AllChunks ¶

func AllChunks(r io.Reader, n int) ([][]string, error)

AllChunks materializes every chunk of up to n lines. Like AllLines, it is for inputs small enough to hold in memory.

func AllLines ¶

func AllLines(r io.Reader) ([]string, error)

AllLines materializes every line of r. It is a convenience for inputs small enough to hold in memory; prefer Lines for large files. An empty input yields a non-nil, empty slice.

func Chunks ¶

func Chunks(r io.Reader, n int) iter.Seq2[[]string, error]

Chunks yields successive slices of up to n lines; the final chunk may hold fewer than n. n must be greater than zero, otherwise the iterator yields ErrNonPositiveChunkSize once and stops. A read error is surfaced the same way Lines surfaces it, discarding any in-progress partial chunk.

package main

import (
	"fmt"
	"strings"

	"github.com/primandproper/platform-go/v2/files"
)

func main() {
	for chunk, err := range files.Chunks(strings.NewReader("a\nb\nc\n"), 2) {
		if err != nil {
			panic(err)
		}

		fmt.Println(chunk)
	}
}

Output:
[a b]
[c]

func ChunksFile ¶

func ChunksFile(name string, n int) (iter.Seq2[[]string, error], error)

ChunksFile opens name and yields successive slices of up to n lines.

func Decode ¶

func Decode[T any](ctx context.Context, r io.Reader, ct encoding.ContentType) (T, error)

Decode reads all of r and unmarshals it into a T as content type ct — any encoding the encoding package supports (JSON, XML, TOML, YAML, Emoji). It builds a one-off encoder internally.

package main

import (
	"context"
	"fmt"
	"strings"

	"github.com/primandproper/platform-go/v2/encoding"
	"github.com/primandproper/platform-go/v2/files"
)

func main() {
	type config struct {
		Name string `json:"name"`
	}

	cfg, err := files.Decode[config](context.Background(), strings.NewReader(`{"name":"platform"}`), encoding.ContentTypeJSON)
	if err != nil {
		panic(err)
	}

	fmt.Println(cfg.Name)
}

Output:
platform

func DecodeFile ¶

func DecodeFile[T any](ctx context.Context, name string, ct encoding.ContentType) (T, error)

DecodeFile opens name, reads it, and unmarshals it into a T as content type ct. The read is traced via the default Reader, and the encoder traces under the same tracer.

func Lines ¶

func Lines(r io.Reader) iter.Seq2[string, error]

Lines yields each line of r without its trailing newline (handling both \n and \r\n). An unterminated final line is still yielded. A terminal read error is yielded once, as the second value after the last good line; io.EOF is normal completion and is never surfaced.

Lines reads with a bufio.Reader rather than a bufio.Scanner, so there is no 64KB line-length cap.

package main

import (
	"fmt"
	"strings"

	"github.com/primandproper/platform-go/v2/files"
)

func main() {
	for line, err := range files.Lines(strings.NewReader("alpha\nbeta\n")) {
		if err != nil {
			panic(err)
		}

		fmt.Println(line)
	}
}

Output:
alpha
beta

func LinesFile ¶

func LinesFile(name string) (iter.Seq2[string, error], error)

LinesFile opens name and yields each of its lines. The open error is returned up front; read errors are yielded by the iterator. The file is closed when iteration ends or the caller breaks.

func MustAllLines ¶

func MustAllLines(r io.Reader) []string

MustAllLines is like AllLines but panics on error.

func MustChunksFile ¶

func MustChunksFile(name string, n int) iter.Seq2[[]string, error]

MustChunksFile is like ChunksFile but panics on an open error.

func MustDecode ¶

func MustDecode[T any](ctx context.Context, r io.Reader, ct encoding.ContentType) T

MustDecode is like Decode but panics on error.

func MustDecodeFile ¶

func MustDecodeFile[T any](ctx context.Context, name string, ct encoding.ContentType) T

MustDecodeFile is like DecodeFile but panics on error.

func MustLinesFile ¶

func MustLinesFile(name string) iter.Seq2[string, error]

MustLinesFile is like LinesFile but panics on an open error.

func MustSliceLines ¶

func MustSliceLines(r io.Reader, offset, count int) []string

MustSliceLines is like SliceLines but panics on error.

func SliceLines ¶

func SliceLines(r io.Reader, offset, count int) ([]string, error)

SliceLines returns up to count lines after skipping offset lines: "the 10 lines after the first 8" is SliceLines(r, 8, 10). It reads no further than it needs to. If offset lands at or past the end of the input, it returns ErrOffsetBeyondEOF; if fewer than count lines remain, it returns the shorter slice with a nil error.

package main

import (
	"fmt"
	"strings"

	"github.com/primandproper/platform-go/v2/files"
)

func main() {
	lines, err := files.SliceLines(strings.NewReader("0\n1\n2\n3\n4\n"), 1, 2)
	if err != nil {
		panic(err)
	}

	fmt.Println(lines)
}

Output:
[1 2]

func SliceLinesFile ¶

func SliceLinesFile(ctx context.Context, name string, offset, count int) ([]string, error)

SliceLinesFile opens name and returns up to count lines after skipping offset lines.

func StreamChunks ¶

func StreamChunks(ctx context.Context, src io.Reader, n int) (<-chan ChunkResult, error)

StreamChunks reads src in a background goroutine and sends each chunk of up to n lines on the returned channel, which StreamChunks owns and closes. A synchronous error is returned for setup failures (n <= 0), in which case no goroutine is started and the channel is nil. Once streaming, a mid-stream read error or context cancellation is delivered as the final ChunkResult.Err and the channel is then closed; io.EOF is clean completion (the channel simply closes).

func StreamChunksFile ¶

func StreamChunksFile(ctx context.Context, name string, n int) (<-chan ChunkResult, error)

StreamChunksFile opens name and streams chunks of up to n lines on the returned channel.