array-iterator.go: changed 'list' name component with 'array'

array-iterator.go

@@ -14,7 +14,7 @@ import (
 	"git.portale-stac.it/go-pkg/expr/types/array"
 )
 
-type ListIterator struct {
+type ArrayIterator struct {
 	a     *array.ArrayType
 	count int64
 	index int64
@@ -23,13 +23,13 @@ type ListIterator struct {
 	step  int64
 }
 
-func NewListIterator(list *array.ArrayType, args []any) (it *ListIterator) {
+func NewArrayIteratorFromArray(a *array.ArrayType, args []any) (it *ArrayIterator) {
 	var argc int = 0
-	listLen := int64(len(([]any)(*list)))
+	listLen := int64(len(([]any)(*a)))
 	if args != nil {
 		argc = len(args)
 	}
-	it = &ListIterator{a: list, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
+	it = &ArrayIterator{a: a, count: 0, index: -1, start: 0, stop: listLen - 1, step: 1}
 	if argc >= 1 {
 		if i, err := types.ToGoInt64(args[0], "start index"); err == nil {
 			if i < 0 {
@@ -62,12 +62,12 @@ func NewListIterator(list *array.ArrayType, args []any) (it *ListIterator) {
 	return
 }
 
-func NewArrayIterator(a []any) (it *ListIterator) {
+func NewArrayIterator(a []any) (it *ArrayIterator) {
-	it = &ListIterator{a: (*array.ArrayType)(&a), count: 0, index: -1, start: 0, stop: int64(len(a)) - 1, step: 1}
+	it = &ArrayIterator{a: (*array.ArrayType)(&a), count: 0, index: -1, start: 0, stop: int64(len(a)) - 1, step: 1}
 	return
 }
 
-func (it *ListIterator) String() string {
+func (it *ArrayIterator) String() string {
 	var l = int64(0)
 	if it.a != nil {
 		l = int64(len(*it.a))
@@ -75,17 +75,17 @@ func (it *ListIterator) String() string {
 	return fmt.Sprintf("$([#%d])", l)
 }
 
-func (it *ListIterator) TypeName() string {
+func (it *ArrayIterator) TypeName() string {
-	return "ListIterator"
+	return "ArrayIterator"
 }
 
-func (it *ListIterator) HasOperation(name string) bool {
+func (it *ArrayIterator) HasOperation(name string) bool {
 	//yes := name == expr.NextName || name == expr.ResetName || name == expr.IndexName || name == expr.CountName || name == expr.CurrentName
 	yes := slices.Contains([]string{kern.NextName, kern.ResetName, kern.IndexName, kern.CountName, kern.CurrentName}, name)
 	return yes
 }
 
-func (it *ListIterator) CallOperation(name string, args map[string]any) (v any, err error) {
+func (it *ArrayIterator) CallOperation(name string, args map[string]any) (v any, err error) {
 	switch name {
 	case kern.NextName:
 		v, err = it.Next()
@@ -105,7 +105,7 @@ func (it *ListIterator) CallOperation(name string, args map[string]any) (v any,
 	return
 }
 
-func (it *ListIterator) Current() (item any, err error) {
+func (it *ArrayIterator) Current() (item any, err error) {
 	a := *(it.a)
 	if it.start <= it.stop {
 		if it.stop < int64(len(a)) && it.index >= it.start && it.index <= it.stop {
@@ -124,7 +124,7 @@ func (it *ListIterator) Current() (item any, err error) {
 	return
 }
 
-func (it *ListIterator) Next() (item any, err error) {
+func (it *ArrayIterator) Next() (item any, err error) {
 	it.index += it.step
 	if item, err = it.Current(); err != io.EOF {
 		it.count++
@@ -132,20 +132,20 @@ func (it *ListIterator) Next() (item any, err error) {
 	return
 }
 
-func (it *ListIterator) Index() int64 {
+func (it *ArrayIterator) Index() int64 {
 	return it.index
 }
 
-func (it *ListIterator) Count() int64 {
+func (it *ArrayIterator) Count() int64 {
 	return it.count
 }
 
-func (it *ListIterator) Reset() error {
+func (it *ArrayIterator) Reset() error {
 	it.index = it.start - it.step
 	it.count = 0
 	return nil
 }
 
-func (it *ListIterator) Clean() error {
+func (it *ArrayIterator) Clean() error {
 	return nil
 }

builtin-math-arith.go

@@ -34,7 +34,7 @@ func doAdd(ctx kern.ExprContext, name string, it kern.Iterator, count, level int
 
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
 		if list, ok := v.(*array.ArrayType); ok {
-			v = NewListIterator(list, nil)
+			v = NewArrayIteratorFromArray(list, nil)
 		}
 		if subIter, ok := v.(kern.Iterator); ok {
 			if v, err = doAdd(ctx, name, subIter, count, level); err != nil {
@@ -108,7 +108,7 @@ func doMul(ctx kern.ExprContext, name string, it kern.Iterator, count, level int
 	level++
 	for v, err = it.Next(); err == nil; v, err = it.Next() {
 		if list, ok := v.(*array.ArrayType); ok {
-			v = NewListIterator(list, nil)
+			v = NewArrayIteratorFromArray(list, nil)
 		}
 		if subIter, ok := v.(kern.Iterator); ok {
 			if v, err = doMul(ctx, name, subIter, count, level); err != nil {

iter-factory.go

@@ -30,7 +30,7 @@ func NewIterator(ctx kern.ExprContext, value any, ops []*scan.Term) (it kern.Ite
 
 	switch v := value.(type) {
 	case *array.ArrayType:
-		it = NewListIterator(v, nil)
+		it = NewArrayIteratorFromArray(v, nil)
 	case *list.LinkedList:
 		it = NewLinkedListIterator(v, nil)
 	case *dict.DictType:

operand-iterator.go

@@ -140,7 +140,7 @@ func evalIterator(ctx kern.ExprContext, opTerm *scan.Term) (v any, err error) {
 	} else if a, ok := firstChildValue.(*array.ArrayType); ok {
 		var args []any
 		if args, err = evalSiblings(ctx, opTerm.Children, nil); err == nil {
-			v = NewListIterator(a, args)
+			v = NewArrayIteratorFromArray(a, args)
 		}
 	} else if ll, ok := firstChildValue.(*list.LinkedList); ok {
 		var args []any

t_iter-list_test.go

@@ -13,7 +13,7 @@ import (
 
 func TestNewListIterator(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "b" {
@@ -25,7 +25,7 @@ func TestNewListIterator(t *testing.T) {
 
 func TestNewListIterator2(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{3, 1, -1})
+	it := NewArrayIteratorFromArray(a, []any{3, 1, -1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "d" {
@@ -37,7 +37,7 @@ func TestNewListIterator2(t *testing.T) {
 
 func TestNewListIterator3(t *testing.T) {
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, -1, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, -1, 1})
 	if item, err := it.Next(); err != nil {
 		t.Errorf("error: %v", err)
 	} else if item != "b" {
@@ -116,7 +116,7 @@ func TestNewString(t *testing.T) {
 func TestHasOperation(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	hasOp := it.HasOperation("reset")
 	if !hasOp {
 		t.Errorf("HasOperation(reset) must be true, got false")
@@ -126,7 +126,7 @@ func TestHasOperation(t *testing.T) {
 func TestCallOperationReset(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("reset", nil); err != nil {
 		t.Errorf("Error on CallOperation(reset): %v", err)
 	} else {
@@ -137,7 +137,7 @@ func TestCallOperationReset(t *testing.T) {
 func TestCallOperationIndex(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("index", nil); err != nil {
 		t.Errorf("Error on CallOperation(index): %v", err)
 	} else {
@@ -148,7 +148,7 @@ func TestCallOperationIndex(t *testing.T) {
 func TestCallOperationCount(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("count", nil); err != nil {
 		t.Errorf("Error on CallOperation(count): %v", err)
 	} else {
@@ -159,7 +159,7 @@ func TestCallOperationCount(t *testing.T) {
 func TestCallOperationUnknown(t *testing.T) {
 
 	a := array.NewArrayA("a", "b", "c", "d")
-	it := NewListIterator(a, []any{1, 3, 1})
+	it := NewArrayIteratorFromArray(a, []any{1, 3, 1})
 	if v, err := it.CallOperation("unknown", nil); err == nil {
 		t.Errorf("Expected error on CallOperation(unknown), got %v", v)
 	}