aof

README

go-aof

Minimalist Append Only File API

Installation

go get github.com/jeroiraz/go-aof

Example

package main

import (
	"log"
	"math/rand"
	"time"

	"github.com/jeroiraz/go-aof"
)

func randomBytes(size int) []byte {
	rand.Seed(time.Now().UnixNano())
	b := make([]byte, size)
	rand.Read(b)
	return b
}

func main() {
	app, err := aof.Open("file.aof")
	if err != nil {
		panic(err)
	}
	defer app.Close()

	for i := 1; i <= 10; i++ {
		b := randomBytes(i)
		_, err := app.Append(b)
		if err != nil {
			panic(err)
		}
	}

	err = app.ForEach(func(e *aof.Entry) (cutoff bool, err error) {
		log.Printf("Entry at offset: %d has size: %d", e.Offset(), e.Size())
		return false, nil
	})
	if err != nil {
		panic(err)
	}

	mr, err := app.Map(func(e *aof.Entry) (size interface{}, cutoff bool, err error) {
		return e.Size(), false, nil
	})
	if err != nil {
		panic(err)
	}

	log.Printf("Sizes: %v", mr)
}

Documentation

Overview

Package aof implements a minimalist append-only file API with build-in fold-powered operators

package main import (

"log"
"github.com/jeroiraz/go-aof"

)

// Note: Error handling not included

func main() {
  app, err := app.Open("test_file.aof")
  defer app.Close()

  // put some data into slice and append to file using the appender
  var bs []byte
  off, err := app.Append(bs)

  app.ForEach(func(e *aof.Entry) (cutoff bool, err error) {
      log.Printf("Entry at offset: %d has size: %d", e.Offset(), e.Size())
      return false, nil
  })

  mr, err := app.Map(func(e *aof.Entry) (size interface{}, cutoff bool, err error) {
      return e.Size(), false, nil
  })
  log.Printf("Sizes: %v", mr)
}

Index

• Constants
• Variables
• type Appender
  • func Open(filename string) (app *Appender, err error)
  • func OpenWithConfig(filename string, cfg *Config) (app *Appender, err error)
  • func (app *Appender) Append(bs []byte) (off int64, err error)
  • func (app *Appender) AppendBulk(bss [][]byte) (offs []int64, err error)
  • func (app *Appender) Close() error
  • func (app *Appender) FilteredMap(f FilterFn, m MapFn) (ls []interface{}, err error)
  • func (app *Appender) Fold(f FoldFn, v interface{}) (ret interface{}, err error)
  • func (app *Appender) FoldWithHandler(handler FoldHandler) error
  • func (app *Appender) ForEach(f ForEachFn) error
  • func (app *Appender) Map(f MapFn) (ls []interface{}, err error)
  • func (app *Appender) Read(off int64) (e *Entry, err error)
• type Config
• type Entry
  • func (e *Entry) Bytes() []byte
  • func (e *Entry) Incomplete() bool
  • func (e *Entry) Offset() int64
  • func (e *Entry) Size() int
  • func (e *Entry) String() string
• type FilterFn
• type FoldFn
• type FoldHandler
• type ForEachFn
• type MapFn

Constants

const DefaultBaseOffset = 0

const DefaultMaxEntrySize = 65535

const DefaultPerm = 0644

const DefaultReadOnly = false

Variables

var (
	ErrUnexpectedReadError = errors.New("aof: Unexpected error reading file")
	ErrCompletingLastEntry = errors.New("aof: Error completing last Entry")
	ErrLastEntryIncomplete = errors.New("aof: Last Entry was incomplete")
	ErrInvalidArguments    = errors.New("aof: Invalid arguments")
	ErrUnexpectedWriteErr  = errors.New("aof: Unexpected error writing file")
	ErrEntryExceedsMaxSize = errors.New("aof: Entry exceeds max supported size")
	ErrAppenderClosed      = errors.New("aof: Appender closed")
)

Types

type Appender

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

func Open

func Open(filename string) (app *Appender, err error)

func OpenWithConfig

func OpenWithConfig(filename string, cfg *Config) (app *Appender, err error)

func (*Appender) Append

func (app *Appender) Append(bs []byte) (off int64, err error)

func (*Appender) AppendBulk

func (app *Appender) AppendBulk(bss [][]byte) (offs []int64, err error)

func (*Appender) Close

func (app *Appender) Close() error

func (*Appender) FilteredMap

func (app *Appender) FilteredMap(f FilterFn, m MapFn) (ls []interface{}, err error)

func (*Appender) Fold

func (app *Appender) Fold(f FoldFn, v interface{}) (ret interface{}, err error)

func (*Appender) FoldWithHandler

func (app *Appender) FoldWithHandler(handler FoldHandler) error

func (*Appender) ForEach

func (app *Appender) ForEach(f ForEachFn) error

func (*Appender) Map

func (app *Appender) Map(f MapFn) (ls []interface{}, err error)

func (*Appender) Read

func (app *Appender) Read(off int64) (e *Entry, err error)

type Config

type Config struct {
	MaxEntrySize int
	BaseOffset   int64
	Perm         os.FileMode
	ReadOnly     bool
}

type Entry

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

func (*Entry) Bytes

func (e *Entry) Bytes() []byte

func (*Entry) Incomplete

func (e *Entry) Incomplete() bool

func (*Entry) Offset

func (e *Entry) Offset() int64

func (*Entry) Size

func (e *Entry) Size() int

func (*Entry) String

func (e *Entry) String() string

type FilterFn

type FilterFn func(e *Entry) (include bool, cutoff bool, err error)

type FoldFn

type FoldFn func(e *Entry, pred interface{}) (red interface{}, cutoff bool, err error)

Note: entry may be used as a shared memory and it should not leave its intended scope

type FoldHandler

type FoldHandler interface {
	Fold(e *Entry) (bool, error)
	Value() interface{}
	Values() []interface{}
}

type ForEachFn

type ForEachFn func(e *Entry) (cutoff bool, err error)

type MapFn

type MapFn func(e *Entry) (r interface{}, cutoff bool, err error)