go-pkg/expr
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

iterator.go: exported some const identifier

Browse Source
This commit is contained in:
Celestino Amoroso 2024-07-18 07:27:02 +02:00
parent 7745dc24e2
commit b4529499d6
6 changed files with 45 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
builtin-math-arith.go
View File

@ -34,8 +34,8 @@ func doAdd(ctx ExprContext, name string, it Iterator, count, level int) (result
if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
break
}
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
if _, err = extIter.CallOperation(cleanName, nil); err != nil {
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
if _, err = extIter.CallOperation(CleanName, nil); err != nil {
return
}
}
@ -107,8 +107,8 @@ func doMul(ctx ExprContext, name string, it Iterator, count, level int) (result
if v, err = doMul(ctx, name, subIter, count, level); err != nil {
break
}
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(cleanName) {
if _, err = extIter.CallOperation(cleanName, nil); err != nil {
if extIter, ok := v.(ExtIterator); ok && extIter.HasOperation(CleanName) {
if _, err = extIter.CallOperation(CleanName, nil); err != nil {
return
}
}

28
data-cursor.go
View File

@ -20,7 +20,7 @@ type dataCursor struct {
currentFunc Functor
}
func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
func NewDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
dc = &dataCursor{
ds: ds,
index: -1,
@ -29,6 +29,10 @@ func newDataCursor(ctx ExprContext, ds map[string]Functor) (dc *dataCursor) {
return
}
func (dc *dataCursor) Context() ExprContext {
return dc.ctx
}
func (dc *dataCursor) TypeName() string {
return "DataCursor"
}
@ -62,7 +66,7 @@ func (dc *dataCursor) String() string {
}
func (dc *dataCursor) HasOperation(name string) (exists bool) {
exists = name == indexName
exists = name == IndexName
if !exists {
f, ok := dc.ds[name]
exists = ok && isFunctor(f)
@ -71,7 +75,7 @@ func (dc *dataCursor) HasOperation(name string) (exists bool) {
}
func (dc *dataCursor) CallOperation(name string, args []any) (value any, err error) {
if name == indexName {
if name == IndexName {
value = int64(dc.Index())
} else if functor, ok := dc.ds[name]; ok && isFunctor(functor) {
if functor == dc.cleanFunc {
@ -93,7 +97,7 @@ func (dc *dataCursor) Reset() (success bool, 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 {
if _, err = dc.resetFunc.Invoke(ctx, ResetName, []any{dc.resource}); err == nil {
dc.index = -1
}
exportObjects(dc.ctx, ctx)
@ -101,7 +105,7 @@ func (dc *dataCursor) Reset() (success bool, err error) {
err = errInvalidDataSource()
}
} else {
err = errNoOperation(resetName)
err = errNoOperation(ResetName)
}
success = err == nil
return
@ -111,7 +115,7 @@ func (dc *dataCursor) Clean() (success bool, err error) {
if dc.cleanFunc != nil {
if dc.resource != nil {
ctx := cloneContext(dc.ctx)
_, err = dc.cleanFunc.Invoke(ctx, cleanName, []any{dc.resource})
_, err = dc.cleanFunc.Invoke(ctx, CleanName, []any{dc.resource})
dc.resource = nil
exportObjects(dc.ctx, ctx)
} else {
@ -126,7 +130,7 @@ func (dc *dataCursor) Clean() (success bool, err error) {
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 {
if item, err = dc.currentFunc.Invoke(ctx, CurrentName, []any{}); err == nil && item == nil {
err = io.EOF
}
exportObjects(dc.ctx, ctx)
@ -167,7 +171,7 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
var v any
var ok bool
ctx := cloneContext(dc.ctx)
if v, err = filter.Invoke(ctx, filterName, []any{item, dc.index}); err == nil && v != nil {
if v, err = filter.Invoke(ctx, FilterName, []any{item, dc.index}); err == nil && v != nil {
if accepted, ok = v.(bool); !ok {
accepted = true // NOTE: A non-boolean value that is not nil means the item has been accepted
}
@ -177,19 +181,19 @@ func (dc *dataCursor) checkFilter(filter Functor, item any) (accepted bool, err
}
func (dc *dataCursor) mapItem(mapper Functor, item any) (mappedItem any, err error) {
ctx := cloneContext(dc.ctx)
mappedItem, err = mapper.Invoke(ctx, mapName, []any{item, dc.index});
mappedItem, err = mapper.Invoke(ctx, MapName, []any{item, dc.index});
return
}
func (dc *dataCursor) Next() (item any, err error) { // must return io.EOF after the last item
var accepted bool
if dc.resource != nil {
filter := dc.ds[filterName]
mapper := dc.ds[mapName]
filter := dc.ds[FilterName]
mapper := dc.ds[MapName]
for item == nil && err == nil {
ctx := cloneContext(dc.ctx)
if item, err = dc.nextFunc.Invoke(ctx, nextName, []any{dc.resource}); err == nil {
if item, err = dc.nextFunc.Invoke(ctx, NextName, []any{dc.resource}); err == nil {
if item == nil {
err = io.EOF
} else {

18
iterator.go
View File

@ -12,15 +12,15 @@ import (
// Operator names
const (
initName = "init"
cleanName = "clean"
resetName = "reset"
nextName = "next"
currentName = "current"
indexName = "index"
countName = "count"
filterName = "filter"
mapName = "map"
InitName = "init"
CleanName = "clean"
ResetName = "reset"
NextName = "next"
CurrentName = "current"
IndexName = "index"
CountName = "count"
FilterName = "filter"
MapName = "map"
)
type Iterator interface {

12
list-iterator.go
View File

@ -90,21 +90,21 @@ func (it *ListIterator) TypeName() string {
}
func (it *ListIterator) HasOperation(name string) bool {
yes := name == nextName || name == resetName || name == indexName || name == countName || name == currentName
yes := name == NextName || name == ResetName || name == IndexName || name == CountName || name == CurrentName
return yes
}
func (it *ListIterator) CallOperation(name string, args []any) (v any, err error) {
switch name {
case nextName:
case NextName:
v, err = it.Next()
case resetName:
case ResetName:
v, err = it.Reset()
case indexName:
case IndexName:
v = int64(it.Index())
case currentName:
case CurrentName:
v, err = it.Current()
case countName:
case CountName:
v = it.count
default:
err = errNoOperation(name)

16
operand-iterator.go
View File

@ -66,7 +66,7 @@ func evalFirstChild(ctx ExprContext, iteratorTerm *term) (value any, err error)
func getDataSourceDict(iteratorTerm *term, firstChildValue any) (ds map[string]Functor, err error) {
if dictAny, ok := firstChildValue.(*DictType); ok {
requiredFields := []string{currentName, nextName}
requiredFields := []string{CurrentName, NextName}
fieldsMask := 0b11
foundFields := 0
ds = make(map[string]Functor)
@ -108,8 +108,8 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
}
if ds != nil {
dc := newDataCursor(ctx, ds)
if initFunc, exists := ds[initName]; exists && initFunc != nil {
dc := NewDataCursor(ctx, ds)
if initFunc, exists := ds[InitName]; exists && initFunc != nil {
var args []any
if len(opTerm.children) > 1 {
if args, err = evalTermArray(ctx, opTerm.children[1:]); err != nil {
@ -120,16 +120,16 @@ func evalIterator(ctx ExprContext, opTerm *term) (v any, err error) {
}
initCtx := dc.ctx.Clone()
if dc.resource, err = initFunc.Invoke(initCtx, initName, args); err != nil {
if dc.resource, err = initFunc.Invoke(initCtx, InitName, args); err != nil {
return
}
exportObjects(dc.ctx, initCtx)
}
dc.nextFunc = ds[nextName]
dc.currentFunc = ds[currentName]
dc.cleanFunc = ds[cleanName]
dc.resetFunc = ds[resetName]
dc.nextFunc = ds[NextName]
dc.currentFunc = ds[CurrentName]
dc.cleanFunc = ds[CleanName]
dc.resetFunc = ds[ResetName]
v = dc
} else if list, ok := firstChildValue.(*ListType); ok {

4
operator-length.go
View File

@ -34,8 +34,8 @@ func evalLength(ctx ExprContext, opTerm *term) (v any, err error) {
m, _ := childValue.(*DictType)
v = int64(len(*m))
} else if it, ok := childValue.(Iterator); ok {
if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(countName) {
count, _ := extIt.CallOperation(countName, nil)
if extIt, ok := childValue.(ExtIterator); ok && extIt.HasOperation(CountName) {
count, _ := extIt.CallOperation(CountName, nil)
v, _ = ToGoInt(count, "")
} else {
v = int64(it.Index() + 1)