105 lines
2.2 KiB
Go
105 lines
2.2 KiB
Go
// Copyright (c) 2024 Celestino Amoroso (celestino.amoroso@gmail.com).
|
|
// All rights reserved.
|
|
|
|
// operand-iterator.go
|
|
package expr
|
|
|
|
import (
|
|
"fmt"
|
|
)
|
|
|
|
// -------- iterator term
|
|
|
|
func newIteratorTerm(tk *Token, dsTerm *term, args []*term) *term {
|
|
tk.Sym = SymIterator
|
|
|
|
children := make([]*term, 0, 1+len(args))
|
|
children = append(children, dsTerm)
|
|
children = append(children, args...)
|
|
return &term{
|
|
tk: *tk,
|
|
parent: nil,
|
|
children: children,
|
|
position: posLeaf,
|
|
priority: priValue,
|
|
evalFunc: evalIterator,
|
|
}
|
|
}
|
|
|
|
// -------- eval iterator
|
|
|
|
func evalTermArray(ctx ExprContext, a []*term) (values []any, err error) {
|
|
values = make([]any, len(a))
|
|
for i, t := range a {
|
|
var value any
|
|
if value, err = t.compute(ctx); err == nil {
|
|
values[i] = value
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
func getDataSourceDict(ctx ExprContext, self *term) (ds map[string]Functor, err error) {
|
|
var value any
|
|
if len(self.children) < 1 || self.children[0] == nil {
|
|
err = self.Errorf("missing the data-source parameter")
|
|
return
|
|
}
|
|
|
|
if value, err = self.children[0].compute(ctx); err != nil {
|
|
return
|
|
}
|
|
|
|
if dictAny, ok := value.(map[any]any); ok {
|
|
ds = make(map[string]Functor)
|
|
for _, k := range []string{initName, currentName, nextName} {
|
|
if item, exists := dictAny[k]; exists && item != nil {
|
|
if functor, ok := item.(*funcDefFunctor); ok {
|
|
ds[k] = functor
|
|
}
|
|
} else if k != initName {
|
|
err = fmt.Errorf("the data-source must provide a non-nil %q operator", k)
|
|
break
|
|
}
|
|
}
|
|
} else {
|
|
err = self.Errorf("the first param (data-source) of an iterator must be a dict, not a %T", value)
|
|
}
|
|
return
|
|
}
|
|
|
|
func evalIterator(ctx ExprContext, self *term) (v any, err error) {
|
|
var ds map[string]Functor
|
|
|
|
if ds, err = getDataSourceDict(ctx, self); err != nil {
|
|
return
|
|
}
|
|
|
|
dc := &dataCursor{
|
|
index: -1,
|
|
ctx: ctx.Clone(),
|
|
}
|
|
|
|
if initFunc, exists := ds[initName]; exists && initFunc != nil {
|
|
var args []any
|
|
if len(self.children) > 1 {
|
|
if args, err = evalTermArray(ctx, self.children[1:]); err != nil {
|
|
return
|
|
}
|
|
} else {
|
|
args = []any{}
|
|
}
|
|
if dc.resource, err = initFunc.Invoke(dc.ctx, initName, args); err != nil {
|
|
return
|
|
}
|
|
}
|
|
|
|
dc.nextFunc, _ = ds[nextName]
|
|
dc.currentFunc, _ = ds[currentName]
|
|
v = dc
|
|
|
|
return
|
|
}
|