ArbitraryIndex

Author: nikandfor

Diff for: arbitrary_index.go

@@ -0,0 +1,115 @@
+package jq
+
+import (
+	"fmt"
+
+	"nikand.dev/go/cbor"
+)
+
+type (
+	ArbitraryIndex struct {
+		Base  Filter
+		Index Filter
+		NoErr bool
+
+		lastl        Off
+		lnext, rnext bool
+
+		lastp NodePath
+	}
+)
+
+func NewIndex(base, index Filter) *ArbitraryIndex {
+	return &ArbitraryIndex{Base: base, Index: index}
+}
+
+func NewIndexNoErr(base, index Filter) *ArbitraryIndex {
+	return &ArbitraryIndex{Base: base, Index: index, NoErr: true}
+}
+
+func (f *ArbitraryIndex) ApplyToGetPath(b *Buffer, off Off, base NodePath, next bool) (res Off, path NodePath, more bool, err error) {
+	return f.applyTo(b, off, base, next, true, f.NoErr)
+}
+
+func (f *ArbitraryIndex) ApplyTo(b *Buffer, off Off, next bool) (res Off, more bool, err error) {
+	res, _, more, err = f.applyTo(b, off, nil, next, false, f.NoErr)
+	return
+}
+
+func (f *ArbitraryIndex) applyTo(b *Buffer, off Off, base NodePath, next bool, addpath addpath, null bool) (res Off, path NodePath, more bool, err error) {
+	if !next {
+		f.lastl = None
+		f.lnext = false
+		f.rnext = false
+		f.lastp = f.lastp[:0]
+	} else if !f.lnext && !f.rnext {
+		return None, base, false, nil
+	}
+
+	path = base
+
+	for !next || f.lnext || f.rnext {
+		next = true
+
+		if !f.rnext {
+			if addpath {
+				f.lastl, path, f.lnext, err = ApplyGetPath(f.Base, b, off, path[:len(base)], f.lnext)
+			} else {
+				f.lastl, f.lnext, err = f.Base.ApplyTo(b, off, f.lnext)
+			}
+			if err != nil {
+				return None, path, false, err
+			}
+
+			if f.lastl == None {
+				continue
+			}
+
+			f.lastp = append(f.lastp[:0], path[len(base):]...)
+		} else if addpath {
+			path = append(path[:len(base)], f.lastp...)
+		}
+
+		res, f.rnext, err = f.Index.ApplyTo(b, off, f.rnext)
+		if err != nil {
+			return None, path, false, err
+		}
+
+		if res == None {
+			continue
+		}
+
+		break
+	}
+
+	if f.lastl == None || res == None {
+		return None, path[:len(base)], false, nil
+	}
+
+	br := b.Reader()
+	tag := br.Tag(res)
+
+	switch tag {
+	case cbor.Int, cbor.Neg:
+		idx := br.Int(res)
+
+		res, path, err = indexApplyTo(idx, b, f.lastl, path, false, addpath, null)
+	case cbor.Bytes, cbor.String:
+		key := br.Bytes(res)
+
+		res, path, err = keyApplyTo(string(key), b, f.lastl, path, false, addpath, null, res)
+	default:
+		return None, base, false, NewTypeError(tag, cbor.Int, cbor.Neg, cbor.Bytes, cbor.String)
+	}
+	if err != nil {
+		return None, path[:len(base)], false, err
+	}
+
+	more = f.lnext || f.rnext
+
+	return res, path, more, nil
+}
+
+func (f ArbitraryIndex) String() string {
+	return fmt.Sprintf(".(%v)[%v]%s", f.Base, f.Index, csel(f.NoErr, "?", ""))
+}

Diff for: arbitrary_index_test.go

@@ -0,0 +1,106 @@
+package jq
+
+import "testing"
+
+func TestArbitraryIndex(tb *testing.T) {
+	b := NewBuffer()
+	r0 := b.appendVal(obj{
+		"arr",
+		arr{"a", "b", "c", "d"},
+		"idx",
+		arr{0, 1, 3, -1, -3, -4, -100, 100},
+	})
+
+	testIter(tb, NewIndex(NewQuery("arr"), NewQuery("idx", Iter{})), b, r0, []any{
+		"a", "b", "d", "d", "b", "a", Null, Null,
+	})
+}
+
+func TestArbitraryKey(tb *testing.T) {
+	b := NewBuffer()
+	r1 := b.appendVal(obj{
+		"a",
+		arr{
+			obj{"a", 1, "b", 2},
+			obj{"a", 3, "b", 4},
+		},
+		"b",
+		arr{"a", "b"},
+	})
+
+	testIter(tb, NewIndex(NewQuery("a", Iter{}), NewQuery("b", Iter{})), b, r1, []any{
+		1, 2, 3, 4,
+	})
+}
+
+func TestArbitraryIndexPath(tb *testing.T) {
+	b := NewBuffer()
+
+	arrkey := b.appendVal("arr")
+	a0 := b.appendVal("a")
+	b0 := b.appendVal("b")
+	c0 := b.appendVal("c")
+	d0 := b.appendVal("d")
+	arr0 := b.appendVal(arr{a0, b0, c0, d0})
+
+	r0 := b.appendVal(obj{
+		arrkey,
+		arr0,
+		"idx",
+		arr{0, 1, 3, -1, -3, -4, -100, 100},
+	})
+
+	testIterPath(tb, NewIndex(NewQuery("arr"), NewQuery("idx", Iter{})), b, r0, []any{
+		"a", "b", "d", "d", "b", "a", Null, Null,
+	}, []NodePath{
+		{psk(r0, 0, arrkey), ps(arr0, 0)},
+		{psk(r0, 0, arrkey), ps(arr0, 1)},
+		{psk(r0, 0, arrkey), ps(arr0, 3)},
+		{psk(r0, 0, arrkey), ps(arr0, 3)},
+		{psk(r0, 0, arrkey), ps(arr0, 1)},
+		{psk(r0, 0, arrkey), ps(arr0, 0)},
+		{psk(r0, 0, arrkey), ps(arr0, -100)},
+		{psk(r0, 0, arrkey), ps(arr0, 100)},
+	})
+
+	if tb.Failed() {
+		tb.Logf("dump %v\n%s", r0, b.Dump())
+	}
+}
+
+func TestArbitraryKeyPath(tb *testing.T) {
+	b := NewBuffer()
+
+	akey := b.appendVal("a")
+	bkey := b.appendVal("b")
+	ckey := b.appendVal("c")
+
+	obj0 := b.appendVal(obj{akey, 1, bkey, 2})
+	obj1 := b.appendVal(obj{akey, 3, bkey, 4})
+
+	arr0 := b.appendVal(arr{obj0, obj1})
+
+	r0 := b.appendVal(obj{
+		bkey,
+		arr{akey, bkey, ckey},
+		akey,
+		arr0,
+	})
+
+	testIterPath(tb, NewIndex(NewQuery("a", Iter{}), NewQuery("b", Iter{})), b, r0, []any{
+		1, 2, Null,
+		3, 4, Null,
+	}, []NodePath{
+		{psk(r0, 1, akey), ps(arr0, 0), psk(obj0, 0, akey)},
+		{psk(r0, 1, akey), ps(arr0, 0), psk(obj0, 1, bkey)},
+		{psk(r0, 1, akey), ps(arr0, 0), psk(obj0, -1, ckey)},
+
+		{psk(r0, 1, akey), ps(arr0, 1), psk(obj1, 0, akey)},
+		{psk(r0, 1, akey), ps(arr0, 1), psk(obj1, 1, bkey)},
+		{psk(r0, 1, akey), ps(arr0, 1), psk(obj1, -1, ckey)},
+	})
+
+	if tb.Failed() {
+		tb.Logf("dump %v\n%s", r0, b.Dump())
+	}
+}