158 lines
3.4 KiB
Go
158 lines
3.4 KiB
Go
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
|
// All rights reserved.
|
|
|
|
// data-cursors.go
|
|
package expr
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
initName = "init"
|
|
cleanName = "clean"
|
|
resetName = "reset"
|
|
nextName = "next"
|
|
currentName = "current"
|
|
)
|
|
|
|
type dataCursor struct {
|
|
ds map[string]Functor
|
|
ctx ExprContext
|
|
index int
|
|
resource any
|
|
nextFunc Functor
|
|
cleanFunc Functor
|
|
resetFunc Functor
|
|
currentFunc Functor
|
|
}
|
|
|
|
func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
|
|
dc = &dataCursor{
|
|
ds: ds,
|
|
index: -1,
|
|
ctx: ctx.Clone(),
|
|
}
|
|
return
|
|
}
|
|
|
|
func mapToString(m map[string]Functor) string {
|
|
var sb strings.Builder
|
|
sb.WriteByte('{')
|
|
for key, _ := range m {
|
|
if sb.Len() > 1 {
|
|
sb.WriteString(fmt.Sprintf(", %q: func(){}", key))
|
|
} else {
|
|
sb.WriteString(fmt.Sprintf("%q: func(){}", key))
|
|
}
|
|
}
|
|
sb.WriteByte('}')
|
|
return sb.String()
|
|
}
|
|
|
|
func (dc *dataCursor) String() string {
|
|
return "$()"
|
|
/* var sb strings.Builder
|
|
sb.WriteString(fmt.Sprintf(`$(
|
|
index: %d,
|
|
ds: %s,
|
|
ctx: `, dc.index, mapToString(dc.ds)))
|
|
CtxToBuilder(&sb, dc.ctx, 1)
|
|
sb.WriteByte(')')
|
|
return sb.String()
|
|
*/
|
|
}
|
|
|
|
func (dc *dataCursor) HasOperation(name string) (exists bool) {
|
|
f, ok := dc.ds[name]
|
|
exists = ok && isFunctor(f)
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
|
|
if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
|
|
if functor == dc.cleanFunc {
|
|
return nil, dc.Clean()
|
|
} else if functor == dc.resetFunc {
|
|
return nil, dc.Reset()
|
|
} else {
|
|
ctx := cloneContext(dc.ctx)
|
|
value, err = functor.Invoke(ctx, name, []any{})
|
|
exportObjects(dc.ctx, ctx)
|
|
}
|
|
|
|
} else {
|
|
err = errNoOperation(name)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) Reset() (err error) {
|
|
if dc.resetFunc != nil {
|
|
if dc.resource != nil {
|
|
ctx := cloneContext(dc.ctx)
|
|
if _, err = dc.resetFunc.Invoke(ctx, resetName, []any{dc.resource}); err == nil {
|
|
dc.index = -1
|
|
}
|
|
exportObjects(dc.ctx, ctx)
|
|
} else {
|
|
err = errInvalidDataSource()
|
|
}
|
|
} else {
|
|
err = errNoOperation(resetName)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) Clean() (err error) {
|
|
if dc.cleanFunc != nil {
|
|
if dc.resource != nil {
|
|
ctx := cloneContext(dc.ctx)
|
|
_, err = dc.cleanFunc.Invoke(ctx, cleanName, []any{dc.resource})
|
|
dc.resource = nil
|
|
exportObjects(dc.ctx, ctx)
|
|
} else {
|
|
err = errInvalidDataSource()
|
|
}
|
|
} else {
|
|
err = errors.New("no 'clean' function defined in the data-source")
|
|
}
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) Current() (item any, err error) { // must return io.EOF at the last item
|
|
ctx := cloneContext(dc.ctx)
|
|
if item, err = dc.currentFunc.Invoke(ctx, currentName, []any{}); err == nil && item == nil {
|
|
err = io.EOF
|
|
}
|
|
exportObjects(dc.ctx, ctx)
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
|
|
if dc.resource != nil {
|
|
ctx := cloneContext(dc.ctx)
|
|
// fmt.Printf("Entering Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
|
|
if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
|
|
if item == nil {
|
|
err = io.EOF
|
|
} else {
|
|
dc.index++
|
|
}
|
|
}
|
|
// fmt.Printf("Exiting Inner-Ctx [%p]: %s\n", ctx, CtxToString(ctx, 0))
|
|
exportObjects(dc.ctx, ctx)
|
|
// fmt.Printf("Outer-Ctx [%p]: %s\n", dc.ctx, CtxToString(dc.ctx, 0))
|
|
} else {
|
|
err = errInvalidDataSource()
|
|
}
|
|
return
|
|
}
|
|
|
|
func (dc *dataCursor) Index() int {
|
|
return dc.index
|
|
}
|