You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@beam.apache.org by jr...@apache.org on 2022/07/25 20:06:36 UTC
[beam] branch master updated: Disallow EventTimes in iterators (#22435)
This is an automated email from the ASF dual-hosted git repository.
jrmccluskey pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/beam.git
The following commit(s) were added to refs/heads/master by this push:
new b2b466aabc8 Disallow EventTimes in iterators (#22435)
b2b466aabc8 is described below
commit b2b466aabc8ea6678fa88287a3c0de458d98182c
Author: Jack McCluskey <34...@users.noreply.github.com>
AuthorDate: Mon Jul 25 16:06:28 2022 -0400
Disallow EventTimes in iterators (#22435)
* Disallow EventTimes in iterators
* Remove other ET registration case
* Remove unused ET funcs
---
sdks/go/pkg/beam/core/funcx/sideinput.go | 8 +-
sdks/go/pkg/beam/core/funcx/sideinput_test.go | 24 +-
sdks/go/pkg/beam/core/runtime/exec/input.go | 2 -
.../pkg/beam/core/runtime/exec/optimized/inputs.go | 16008 +++----------------
.../beam/core/runtime/exec/optimized/inputs.tmpl | 43 -
5 files changed, 2466 insertions(+), 13619 deletions(-)
diff --git a/sdks/go/pkg/beam/core/funcx/sideinput.go b/sdks/go/pkg/beam/core/funcx/sideinput.go
index 168ff3c58e2..ab289ca3eba 100644
--- a/sdks/go/pkg/beam/core/funcx/sideinput.go
+++ b/sdks/go/pkg/beam/core/funcx/sideinput.go
@@ -27,6 +27,7 @@ var (
errIllegalParametersInIter = "All parameters in an iter must be universal type, container type, or concrete type"
errIllegalParametersInReIter = "Output of a reiter must be valid iter type"
errIllegalParametersInMultiMap = "Output of a multimap must be valid iter type"
+ errIllegalEventTimeInIter = "Iterators with timestamp values (<ET,V> and <ET, K, V>) are not valid, as side input time stamps are not preserved after windowing. See https://github.com/apache/beam/issues/22404 for more information."
)
// IsIter returns true iff the supplied type is a "single sweep functional iterator".
@@ -56,8 +57,10 @@ func IsMalformedIter(t reflect.Type) (bool, error) {
//
// func (*int) bool returns {int}
// func (*string, *int) bool returns {string, int}
-// func (*typex.EventTime, *int) bool returns {typex.EventTime, int}
//
+// EventTimes are not allowed in iterator types as per the Beam model
+// (see https://github.com/apache/beam/issues/22404) for more
+// information.
func UnfoldIter(t reflect.Type) ([]reflect.Type, bool) {
types, ok, _ := unfoldIter(t)
return types, ok
@@ -78,8 +81,7 @@ func unfoldIter(t reflect.Type) ([]reflect.Type, bool, error) {
var ret []reflect.Type
skip := 0
if t.In(0).Kind() == reflect.Ptr && t.In(0).Elem() == typex.EventTimeType {
- ret = append(ret, typex.EventTimeType)
- skip = 1
+ return nil, false, errors.New(errIllegalEventTimeInIter)
}
if t.NumIn()-skip > 2 || t.NumIn() == skip {
return nil, false, nil
diff --git a/sdks/go/pkg/beam/core/funcx/sideinput_test.go b/sdks/go/pkg/beam/core/funcx/sideinput_test.go
index 71b3c7bbfd6..f9048ee1843 100644
--- a/sdks/go/pkg/beam/core/funcx/sideinput_test.go
+++ b/sdks/go/pkg/beam/core/funcx/sideinput_test.go
@@ -31,14 +31,14 @@ func TestIsIter(t *testing.T) {
{func() bool { return false }, false}, // no value
{func(*int) int { return 0 }, false}, // no bool return
{func(int) bool { return false }, false}, // no ptr value
- {func(*typex.EventTime) bool { return false }, false}, // no values
+ {func(*typex.EventTime) bool { return false }, false}, // EventTimes disallowed
{func(*int) bool { return false }, true},
- {func(*typex.EventTime, *int) bool { return false }, true},
+ {func(*typex.EventTime, *int) bool { return false }, false}, // EventTimes disallowed
{func(*int, *string) bool { return false }, true},
{func(*typex.Y, *typex.Z) bool { return false }, true},
- {func(*typex.EventTime, *int, *string) bool { return false }, true},
+ {func(*typex.EventTime, *int, *string) bool { return false }, false}, // EventTimes disallowed
{func(*int, *typex.Y, *typex.Z) bool { return false }, false}, // too many values
- {func(*typex.EventTime, *int, *typex.Y, *typex.Z) bool { return false }, false}, // too many values
+ {func(*typex.EventTime, *int, *typex.Y, *typex.Z) bool { return false }, false}, // too many values, EventTimes disallowed
}
for _, test := range tests {
@@ -58,7 +58,7 @@ func TestIsReIter(t *testing.T) {
{func(*int) func(*int) bool { return nil }, false}, // takes parameters
{func(*int) (func(*int) bool, func(*int) bool) { return nil, nil }, false}, // too many iterators
{func() func(*int) bool { return nil }, true},
- {func() func(*typex.EventTime, *int, *string) bool { return nil }, true},
+ {func() func(*typex.EventTime, *int, *string) bool { return nil }, false}, // EventTimes disallowed
}
for _, test := range tests {
@@ -75,13 +75,13 @@ func TestIsMultiMap(t *testing.T) {
Exp bool
}{
{func(int) func(*int) bool { return nil }, true},
- {func() func(*int) bool { return nil }, false}, // Doesn't take an input (is a ReIter)
- {func(*int) bool { return false }, false}, // Doesn't return an iterator (is an iterator)
- {func(int) int { return 0 }, false}, // Doesn't return an iterator (returns a value)
- {func(string) func(*int) int { return nil }, false}, // Returned iterator isn't a boolean return
- {func(string) func(int) bool { return nil }, false}, // Returned iterator doesn't have a pointer receiver
- {func(string) func(*typex.EventTime, *int) bool { return nil }, true},
- {func(string) func(*typex.EventTime, *int) { return nil }, false}, // Returned iterator does not have a bool return
+ {func() func(*int) bool { return nil }, false}, // Doesn't take an input (is a ReIter)
+ {func(*int) bool { return false }, false}, // Doesn't return an iterator (is an iterator)
+ {func(int) int { return 0 }, false}, // Doesn't return an iterator (returns a value)
+ {func(string) func(*int) int { return nil }, false}, // Returned iterator isn't a boolean return
+ {func(string) func(int) bool { return nil }, false}, // Returned iterator doesn't have a pointer receiver
+ {func(string) func(*typex.EventTime, *int) bool { return nil }, false}, // EventTimes disallowed
+ {func(string) func(*typex.EventTime, *int) { return nil }, false}, // Returned iterator does not have a bool return, EventTimes disallowed
}
for _, test := range tests {
val := reflect.TypeOf(test.Fn)
diff --git a/sdks/go/pkg/beam/core/runtime/exec/input.go b/sdks/go/pkg/beam/core/runtime/exec/input.go
index ab17a831792..b673854769b 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/input.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/input.go
@@ -169,8 +169,6 @@ func (v *iterValue) invoke(args []reflect.Value) []reflect.Value {
for i, t := range v.types {
var v reflect.Value
switch {
- case t == typex.EventTimeType:
- v = reflect.ValueOf(elm.Timestamp)
case isKey:
v = reflect.ValueOf(Convert(elm.Elm, t))
isKey = false
diff --git a/sdks/go/pkg/beam/core/runtime/exec/optimized/inputs.go b/sdks/go/pkg/beam/core/runtime/exec/optimized/inputs.go
index d66f8ed7515..3a1ae8eba0b 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/optimized/inputs.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/optimized/inputs.go
@@ -28,1017 +28,511 @@ import (
func init() {
exec.RegisterInput(reflect.TypeOf((*func(*[]byte) bool)(nil)).Elem(), iterMakerByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte) bool)(nil)).Elem(), iterMakerETByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *[]byte) bool)(nil)).Elem(), iterMakerByteSliceByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *[]byte) bool)(nil)).Elem(), iterMakerETByteSliceByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *bool) bool)(nil)).Elem(), iterMakerByteSliceBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *bool) bool)(nil)).Elem(), iterMakerETByteSliceBool)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *string) bool)(nil)).Elem(), iterMakerByteSliceString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *string) bool)(nil)).Elem(), iterMakerETByteSliceString)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *int) bool)(nil)).Elem(), iterMakerByteSliceInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int) bool)(nil)).Elem(), iterMakerETByteSliceInt)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *int8) bool)(nil)).Elem(), iterMakerByteSliceInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int8) bool)(nil)).Elem(), iterMakerETByteSliceInt8)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *int16) bool)(nil)).Elem(), iterMakerByteSliceInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int16) bool)(nil)).Elem(), iterMakerETByteSliceInt16)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *int32) bool)(nil)).Elem(), iterMakerByteSliceInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int32) bool)(nil)).Elem(), iterMakerETByteSliceInt32)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *int64) bool)(nil)).Elem(), iterMakerByteSliceInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *int64) bool)(nil)).Elem(), iterMakerETByteSliceInt64)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *uint) bool)(nil)).Elem(), iterMakerByteSliceUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint) bool)(nil)).Elem(), iterMakerETByteSliceUint)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *uint8) bool)(nil)).Elem(), iterMakerByteSliceUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint8) bool)(nil)).Elem(), iterMakerETByteSliceUint8)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *uint16) bool)(nil)).Elem(), iterMakerByteSliceUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint16) bool)(nil)).Elem(), iterMakerETByteSliceUint16)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *uint32) bool)(nil)).Elem(), iterMakerByteSliceUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint32) bool)(nil)).Elem(), iterMakerETByteSliceUint32)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *uint64) bool)(nil)).Elem(), iterMakerByteSliceUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *uint64) bool)(nil)).Elem(), iterMakerETByteSliceUint64)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *float32) bool)(nil)).Elem(), iterMakerByteSliceFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *float32) bool)(nil)).Elem(), iterMakerETByteSliceFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *float64) bool)(nil)).Elem(), iterMakerByteSliceFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *float64) bool)(nil)).Elem(), iterMakerETByteSliceFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.T) bool)(nil)).Elem(), iterMakerByteSliceTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.T) bool)(nil)).Elem(), iterMakerETByteSliceTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.U) bool)(nil)).Elem(), iterMakerByteSliceTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.U) bool)(nil)).Elem(), iterMakerETByteSliceTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.V) bool)(nil)).Elem(), iterMakerByteSliceTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.V) bool)(nil)).Elem(), iterMakerETByteSliceTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.W) bool)(nil)).Elem(), iterMakerByteSliceTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.W) bool)(nil)).Elem(), iterMakerETByteSliceTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.X) bool)(nil)).Elem(), iterMakerByteSliceTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.X) bool)(nil)).Elem(), iterMakerETByteSliceTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.Y) bool)(nil)).Elem(), iterMakerByteSliceTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.Y) bool)(nil)).Elem(), iterMakerETByteSliceTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*[]byte, *typex.Z) bool)(nil)).Elem(), iterMakerByteSliceTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *[]byte, *typex.Z) bool)(nil)).Elem(), iterMakerETByteSliceTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*bool) bool)(nil)).Elem(), iterMakerBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool) bool)(nil)).Elem(), iterMakerETBool)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *[]byte) bool)(nil)).Elem(), iterMakerBoolByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *[]byte) bool)(nil)).Elem(), iterMakerETBoolByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *bool) bool)(nil)).Elem(), iterMakerBoolBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *bool) bool)(nil)).Elem(), iterMakerETBoolBool)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *string) bool)(nil)).Elem(), iterMakerBoolString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *string) bool)(nil)).Elem(), iterMakerETBoolString)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *int) bool)(nil)).Elem(), iterMakerBoolInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int) bool)(nil)).Elem(), iterMakerETBoolInt)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *int8) bool)(nil)).Elem(), iterMakerBoolInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int8) bool)(nil)).Elem(), iterMakerETBoolInt8)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *int16) bool)(nil)).Elem(), iterMakerBoolInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int16) bool)(nil)).Elem(), iterMakerETBoolInt16)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *int32) bool)(nil)).Elem(), iterMakerBoolInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int32) bool)(nil)).Elem(), iterMakerETBoolInt32)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *int64) bool)(nil)).Elem(), iterMakerBoolInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *int64) bool)(nil)).Elem(), iterMakerETBoolInt64)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *uint) bool)(nil)).Elem(), iterMakerBoolUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint) bool)(nil)).Elem(), iterMakerETBoolUint)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *uint8) bool)(nil)).Elem(), iterMakerBoolUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint8) bool)(nil)).Elem(), iterMakerETBoolUint8)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *uint16) bool)(nil)).Elem(), iterMakerBoolUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint16) bool)(nil)).Elem(), iterMakerETBoolUint16)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *uint32) bool)(nil)).Elem(), iterMakerBoolUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint32) bool)(nil)).Elem(), iterMakerETBoolUint32)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *uint64) bool)(nil)).Elem(), iterMakerBoolUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *uint64) bool)(nil)).Elem(), iterMakerETBoolUint64)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *float32) bool)(nil)).Elem(), iterMakerBoolFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *float32) bool)(nil)).Elem(), iterMakerETBoolFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *float64) bool)(nil)).Elem(), iterMakerBoolFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *float64) bool)(nil)).Elem(), iterMakerETBoolFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.T) bool)(nil)).Elem(), iterMakerBoolTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.T) bool)(nil)).Elem(), iterMakerETBoolTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.U) bool)(nil)).Elem(), iterMakerBoolTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.U) bool)(nil)).Elem(), iterMakerETBoolTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.V) bool)(nil)).Elem(), iterMakerBoolTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.V) bool)(nil)).Elem(), iterMakerETBoolTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.W) bool)(nil)).Elem(), iterMakerBoolTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.W) bool)(nil)).Elem(), iterMakerETBoolTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.X) bool)(nil)).Elem(), iterMakerBoolTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.X) bool)(nil)).Elem(), iterMakerETBoolTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.Y) bool)(nil)).Elem(), iterMakerBoolTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.Y) bool)(nil)).Elem(), iterMakerETBoolTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*bool, *typex.Z) bool)(nil)).Elem(), iterMakerBoolTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *bool, *typex.Z) bool)(nil)).Elem(), iterMakerETBoolTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*string) bool)(nil)).Elem(), iterMakerString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string) bool)(nil)).Elem(), iterMakerETString)
exec.RegisterInput(reflect.TypeOf((*func(*string, *[]byte) bool)(nil)).Elem(), iterMakerStringByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *[]byte) bool)(nil)).Elem(), iterMakerETStringByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*string, *bool) bool)(nil)).Elem(), iterMakerStringBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *bool) bool)(nil)).Elem(), iterMakerETStringBool)
exec.RegisterInput(reflect.TypeOf((*func(*string, *string) bool)(nil)).Elem(), iterMakerStringString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *string) bool)(nil)).Elem(), iterMakerETStringString)
exec.RegisterInput(reflect.TypeOf((*func(*string, *int) bool)(nil)).Elem(), iterMakerStringInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int) bool)(nil)).Elem(), iterMakerETStringInt)
exec.RegisterInput(reflect.TypeOf((*func(*string, *int8) bool)(nil)).Elem(), iterMakerStringInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int8) bool)(nil)).Elem(), iterMakerETStringInt8)
exec.RegisterInput(reflect.TypeOf((*func(*string, *int16) bool)(nil)).Elem(), iterMakerStringInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int16) bool)(nil)).Elem(), iterMakerETStringInt16)
exec.RegisterInput(reflect.TypeOf((*func(*string, *int32) bool)(nil)).Elem(), iterMakerStringInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int32) bool)(nil)).Elem(), iterMakerETStringInt32)
exec.RegisterInput(reflect.TypeOf((*func(*string, *int64) bool)(nil)).Elem(), iterMakerStringInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *int64) bool)(nil)).Elem(), iterMakerETStringInt64)
exec.RegisterInput(reflect.TypeOf((*func(*string, *uint) bool)(nil)).Elem(), iterMakerStringUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint) bool)(nil)).Elem(), iterMakerETStringUint)
exec.RegisterInput(reflect.TypeOf((*func(*string, *uint8) bool)(nil)).Elem(), iterMakerStringUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint8) bool)(nil)).Elem(), iterMakerETStringUint8)
exec.RegisterInput(reflect.TypeOf((*func(*string, *uint16) bool)(nil)).Elem(), iterMakerStringUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint16) bool)(nil)).Elem(), iterMakerETStringUint16)
exec.RegisterInput(reflect.TypeOf((*func(*string, *uint32) bool)(nil)).Elem(), iterMakerStringUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint32) bool)(nil)).Elem(), iterMakerETStringUint32)
exec.RegisterInput(reflect.TypeOf((*func(*string, *uint64) bool)(nil)).Elem(), iterMakerStringUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *uint64) bool)(nil)).Elem(), iterMakerETStringUint64)
exec.RegisterInput(reflect.TypeOf((*func(*string, *float32) bool)(nil)).Elem(), iterMakerStringFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *float32) bool)(nil)).Elem(), iterMakerETStringFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*string, *float64) bool)(nil)).Elem(), iterMakerStringFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *float64) bool)(nil)).Elem(), iterMakerETStringFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.T) bool)(nil)).Elem(), iterMakerStringTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.T) bool)(nil)).Elem(), iterMakerETStringTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.U) bool)(nil)).Elem(), iterMakerStringTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.U) bool)(nil)).Elem(), iterMakerETStringTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.V) bool)(nil)).Elem(), iterMakerStringTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.V) bool)(nil)).Elem(), iterMakerETStringTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.W) bool)(nil)).Elem(), iterMakerStringTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.W) bool)(nil)).Elem(), iterMakerETStringTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.X) bool)(nil)).Elem(), iterMakerStringTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.X) bool)(nil)).Elem(), iterMakerETStringTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.Y) bool)(nil)).Elem(), iterMakerStringTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.Y) bool)(nil)).Elem(), iterMakerETStringTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*string, *typex.Z) bool)(nil)).Elem(), iterMakerStringTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *string, *typex.Z) bool)(nil)).Elem(), iterMakerETStringTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*int) bool)(nil)).Elem(), iterMakerInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int) bool)(nil)).Elem(), iterMakerETInt)
exec.RegisterInput(reflect.TypeOf((*func(*int, *[]byte) bool)(nil)).Elem(), iterMakerIntByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *[]byte) bool)(nil)).Elem(), iterMakerETIntByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*int, *bool) bool)(nil)).Elem(), iterMakerIntBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *bool) bool)(nil)).Elem(), iterMakerETIntBool)
exec.RegisterInput(reflect.TypeOf((*func(*int, *string) bool)(nil)).Elem(), iterMakerIntString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *string) bool)(nil)).Elem(), iterMakerETIntString)
exec.RegisterInput(reflect.TypeOf((*func(*int, *int) bool)(nil)).Elem(), iterMakerIntInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int) bool)(nil)).Elem(), iterMakerETIntInt)
exec.RegisterInput(reflect.TypeOf((*func(*int, *int8) bool)(nil)).Elem(), iterMakerIntInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int8) bool)(nil)).Elem(), iterMakerETIntInt8)
exec.RegisterInput(reflect.TypeOf((*func(*int, *int16) bool)(nil)).Elem(), iterMakerIntInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int16) bool)(nil)).Elem(), iterMakerETIntInt16)
exec.RegisterInput(reflect.TypeOf((*func(*int, *int32) bool)(nil)).Elem(), iterMakerIntInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int32) bool)(nil)).Elem(), iterMakerETIntInt32)
exec.RegisterInput(reflect.TypeOf((*func(*int, *int64) bool)(nil)).Elem(), iterMakerIntInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *int64) bool)(nil)).Elem(), iterMakerETIntInt64)
exec.RegisterInput(reflect.TypeOf((*func(*int, *uint) bool)(nil)).Elem(), iterMakerIntUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint) bool)(nil)).Elem(), iterMakerETIntUint)
exec.RegisterInput(reflect.TypeOf((*func(*int, *uint8) bool)(nil)).Elem(), iterMakerIntUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint8) bool)(nil)).Elem(), iterMakerETIntUint8)
exec.RegisterInput(reflect.TypeOf((*func(*int, *uint16) bool)(nil)).Elem(), iterMakerIntUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint16) bool)(nil)).Elem(), iterMakerETIntUint16)
exec.RegisterInput(reflect.TypeOf((*func(*int, *uint32) bool)(nil)).Elem(), iterMakerIntUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint32) bool)(nil)).Elem(), iterMakerETIntUint32)
exec.RegisterInput(reflect.TypeOf((*func(*int, *uint64) bool)(nil)).Elem(), iterMakerIntUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *uint64) bool)(nil)).Elem(), iterMakerETIntUint64)
exec.RegisterInput(reflect.TypeOf((*func(*int, *float32) bool)(nil)).Elem(), iterMakerIntFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *float32) bool)(nil)).Elem(), iterMakerETIntFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*int, *float64) bool)(nil)).Elem(), iterMakerIntFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *float64) bool)(nil)).Elem(), iterMakerETIntFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.T) bool)(nil)).Elem(), iterMakerIntTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.T) bool)(nil)).Elem(), iterMakerETIntTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.U) bool)(nil)).Elem(), iterMakerIntTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.U) bool)(nil)).Elem(), iterMakerETIntTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.V) bool)(nil)).Elem(), iterMakerIntTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.V) bool)(nil)).Elem(), iterMakerETIntTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.W) bool)(nil)).Elem(), iterMakerIntTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.W) bool)(nil)).Elem(), iterMakerETIntTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.X) bool)(nil)).Elem(), iterMakerIntTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.X) bool)(nil)).Elem(), iterMakerETIntTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.Y) bool)(nil)).Elem(), iterMakerIntTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.Y) bool)(nil)).Elem(), iterMakerETIntTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*int, *typex.Z) bool)(nil)).Elem(), iterMakerIntTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int, *typex.Z) bool)(nil)).Elem(), iterMakerETIntTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*int8) bool)(nil)).Elem(), iterMakerInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8) bool)(nil)).Elem(), iterMakerETInt8)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *[]byte) bool)(nil)).Elem(), iterMakerInt8ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *[]byte) bool)(nil)).Elem(), iterMakerETInt8ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *bool) bool)(nil)).Elem(), iterMakerInt8Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *bool) bool)(nil)).Elem(), iterMakerETInt8Bool)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *string) bool)(nil)).Elem(), iterMakerInt8String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *string) bool)(nil)).Elem(), iterMakerETInt8String)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *int) bool)(nil)).Elem(), iterMakerInt8Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int) bool)(nil)).Elem(), iterMakerETInt8Int)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *int8) bool)(nil)).Elem(), iterMakerInt8Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int8) bool)(nil)).Elem(), iterMakerETInt8Int8)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *int16) bool)(nil)).Elem(), iterMakerInt8Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int16) bool)(nil)).Elem(), iterMakerETInt8Int16)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *int32) bool)(nil)).Elem(), iterMakerInt8Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int32) bool)(nil)).Elem(), iterMakerETInt8Int32)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *int64) bool)(nil)).Elem(), iterMakerInt8Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *int64) bool)(nil)).Elem(), iterMakerETInt8Int64)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *uint) bool)(nil)).Elem(), iterMakerInt8Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint) bool)(nil)).Elem(), iterMakerETInt8Uint)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *uint8) bool)(nil)).Elem(), iterMakerInt8Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint8) bool)(nil)).Elem(), iterMakerETInt8Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *uint16) bool)(nil)).Elem(), iterMakerInt8Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint16) bool)(nil)).Elem(), iterMakerETInt8Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *uint32) bool)(nil)).Elem(), iterMakerInt8Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint32) bool)(nil)).Elem(), iterMakerETInt8Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *uint64) bool)(nil)).Elem(), iterMakerInt8Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *uint64) bool)(nil)).Elem(), iterMakerETInt8Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *float32) bool)(nil)).Elem(), iterMakerInt8Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *float32) bool)(nil)).Elem(), iterMakerETInt8Float32)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *float64) bool)(nil)).Elem(), iterMakerInt8Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *float64) bool)(nil)).Elem(), iterMakerETInt8Float64)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.T) bool)(nil)).Elem(), iterMakerInt8Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.T) bool)(nil)).Elem(), iterMakerETInt8Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.U) bool)(nil)).Elem(), iterMakerInt8Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.U) bool)(nil)).Elem(), iterMakerETInt8Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.V) bool)(nil)).Elem(), iterMakerInt8Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.V) bool)(nil)).Elem(), iterMakerETInt8Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.W) bool)(nil)).Elem(), iterMakerInt8Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.W) bool)(nil)).Elem(), iterMakerETInt8Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.X) bool)(nil)).Elem(), iterMakerInt8Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.X) bool)(nil)).Elem(), iterMakerETInt8Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.Y) bool)(nil)).Elem(), iterMakerInt8Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.Y) bool)(nil)).Elem(), iterMakerETInt8Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*int8, *typex.Z) bool)(nil)).Elem(), iterMakerInt8Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int8, *typex.Z) bool)(nil)).Elem(), iterMakerETInt8Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*int16) bool)(nil)).Elem(), iterMakerInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16) bool)(nil)).Elem(), iterMakerETInt16)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *[]byte) bool)(nil)).Elem(), iterMakerInt16ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *[]byte) bool)(nil)).Elem(), iterMakerETInt16ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *bool) bool)(nil)).Elem(), iterMakerInt16Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *bool) bool)(nil)).Elem(), iterMakerETInt16Bool)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *string) bool)(nil)).Elem(), iterMakerInt16String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *string) bool)(nil)).Elem(), iterMakerETInt16String)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *int) bool)(nil)).Elem(), iterMakerInt16Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int) bool)(nil)).Elem(), iterMakerETInt16Int)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *int8) bool)(nil)).Elem(), iterMakerInt16Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int8) bool)(nil)).Elem(), iterMakerETInt16Int8)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *int16) bool)(nil)).Elem(), iterMakerInt16Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int16) bool)(nil)).Elem(), iterMakerETInt16Int16)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *int32) bool)(nil)).Elem(), iterMakerInt16Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int32) bool)(nil)).Elem(), iterMakerETInt16Int32)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *int64) bool)(nil)).Elem(), iterMakerInt16Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *int64) bool)(nil)).Elem(), iterMakerETInt16Int64)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *uint) bool)(nil)).Elem(), iterMakerInt16Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint) bool)(nil)).Elem(), iterMakerETInt16Uint)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *uint8) bool)(nil)).Elem(), iterMakerInt16Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint8) bool)(nil)).Elem(), iterMakerETInt16Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *uint16) bool)(nil)).Elem(), iterMakerInt16Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint16) bool)(nil)).Elem(), iterMakerETInt16Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *uint32) bool)(nil)).Elem(), iterMakerInt16Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint32) bool)(nil)).Elem(), iterMakerETInt16Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *uint64) bool)(nil)).Elem(), iterMakerInt16Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *uint64) bool)(nil)).Elem(), iterMakerETInt16Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *float32) bool)(nil)).Elem(), iterMakerInt16Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *float32) bool)(nil)).Elem(), iterMakerETInt16Float32)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *float64) bool)(nil)).Elem(), iterMakerInt16Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *float64) bool)(nil)).Elem(), iterMakerETInt16Float64)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.T) bool)(nil)).Elem(), iterMakerInt16Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.T) bool)(nil)).Elem(), iterMakerETInt16Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.U) bool)(nil)).Elem(), iterMakerInt16Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.U) bool)(nil)).Elem(), iterMakerETInt16Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.V) bool)(nil)).Elem(), iterMakerInt16Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.V) bool)(nil)).Elem(), iterMakerETInt16Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.W) bool)(nil)).Elem(), iterMakerInt16Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.W) bool)(nil)).Elem(), iterMakerETInt16Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.X) bool)(nil)).Elem(), iterMakerInt16Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.X) bool)(nil)).Elem(), iterMakerETInt16Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.Y) bool)(nil)).Elem(), iterMakerInt16Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.Y) bool)(nil)).Elem(), iterMakerETInt16Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*int16, *typex.Z) bool)(nil)).Elem(), iterMakerInt16Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int16, *typex.Z) bool)(nil)).Elem(), iterMakerETInt16Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*int32) bool)(nil)).Elem(), iterMakerInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32) bool)(nil)).Elem(), iterMakerETInt32)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *[]byte) bool)(nil)).Elem(), iterMakerInt32ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *[]byte) bool)(nil)).Elem(), iterMakerETInt32ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *bool) bool)(nil)).Elem(), iterMakerInt32Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *bool) bool)(nil)).Elem(), iterMakerETInt32Bool)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *string) bool)(nil)).Elem(), iterMakerInt32String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *string) bool)(nil)).Elem(), iterMakerETInt32String)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *int) bool)(nil)).Elem(), iterMakerInt32Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int) bool)(nil)).Elem(), iterMakerETInt32Int)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *int8) bool)(nil)).Elem(), iterMakerInt32Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int8) bool)(nil)).Elem(), iterMakerETInt32Int8)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *int16) bool)(nil)).Elem(), iterMakerInt32Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int16) bool)(nil)).Elem(), iterMakerETInt32Int16)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *int32) bool)(nil)).Elem(), iterMakerInt32Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int32) bool)(nil)).Elem(), iterMakerETInt32Int32)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *int64) bool)(nil)).Elem(), iterMakerInt32Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *int64) bool)(nil)).Elem(), iterMakerETInt32Int64)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *uint) bool)(nil)).Elem(), iterMakerInt32Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint) bool)(nil)).Elem(), iterMakerETInt32Uint)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *uint8) bool)(nil)).Elem(), iterMakerInt32Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint8) bool)(nil)).Elem(), iterMakerETInt32Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *uint16) bool)(nil)).Elem(), iterMakerInt32Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint16) bool)(nil)).Elem(), iterMakerETInt32Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *uint32) bool)(nil)).Elem(), iterMakerInt32Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint32) bool)(nil)).Elem(), iterMakerETInt32Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *uint64) bool)(nil)).Elem(), iterMakerInt32Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *uint64) bool)(nil)).Elem(), iterMakerETInt32Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *float32) bool)(nil)).Elem(), iterMakerInt32Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *float32) bool)(nil)).Elem(), iterMakerETInt32Float32)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *float64) bool)(nil)).Elem(), iterMakerInt32Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *float64) bool)(nil)).Elem(), iterMakerETInt32Float64)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.T) bool)(nil)).Elem(), iterMakerInt32Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.T) bool)(nil)).Elem(), iterMakerETInt32Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.U) bool)(nil)).Elem(), iterMakerInt32Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.U) bool)(nil)).Elem(), iterMakerETInt32Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.V) bool)(nil)).Elem(), iterMakerInt32Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.V) bool)(nil)).Elem(), iterMakerETInt32Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.W) bool)(nil)).Elem(), iterMakerInt32Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.W) bool)(nil)).Elem(), iterMakerETInt32Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.X) bool)(nil)).Elem(), iterMakerInt32Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.X) bool)(nil)).Elem(), iterMakerETInt32Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.Y) bool)(nil)).Elem(), iterMakerInt32Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.Y) bool)(nil)).Elem(), iterMakerETInt32Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*int32, *typex.Z) bool)(nil)).Elem(), iterMakerInt32Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int32, *typex.Z) bool)(nil)).Elem(), iterMakerETInt32Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*int64) bool)(nil)).Elem(), iterMakerInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64) bool)(nil)).Elem(), iterMakerETInt64)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *[]byte) bool)(nil)).Elem(), iterMakerInt64ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *[]byte) bool)(nil)).Elem(), iterMakerETInt64ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *bool) bool)(nil)).Elem(), iterMakerInt64Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *bool) bool)(nil)).Elem(), iterMakerETInt64Bool)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *string) bool)(nil)).Elem(), iterMakerInt64String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *string) bool)(nil)).Elem(), iterMakerETInt64String)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *int) bool)(nil)).Elem(), iterMakerInt64Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int) bool)(nil)).Elem(), iterMakerETInt64Int)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *int8) bool)(nil)).Elem(), iterMakerInt64Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int8) bool)(nil)).Elem(), iterMakerETInt64Int8)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *int16) bool)(nil)).Elem(), iterMakerInt64Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int16) bool)(nil)).Elem(), iterMakerETInt64Int16)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *int32) bool)(nil)).Elem(), iterMakerInt64Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int32) bool)(nil)).Elem(), iterMakerETInt64Int32)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *int64) bool)(nil)).Elem(), iterMakerInt64Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *int64) bool)(nil)).Elem(), iterMakerETInt64Int64)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *uint) bool)(nil)).Elem(), iterMakerInt64Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint) bool)(nil)).Elem(), iterMakerETInt64Uint)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *uint8) bool)(nil)).Elem(), iterMakerInt64Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint8) bool)(nil)).Elem(), iterMakerETInt64Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *uint16) bool)(nil)).Elem(), iterMakerInt64Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint16) bool)(nil)).Elem(), iterMakerETInt64Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *uint32) bool)(nil)).Elem(), iterMakerInt64Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint32) bool)(nil)).Elem(), iterMakerETInt64Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *uint64) bool)(nil)).Elem(), iterMakerInt64Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *uint64) bool)(nil)).Elem(), iterMakerETInt64Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *float32) bool)(nil)).Elem(), iterMakerInt64Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *float32) bool)(nil)).Elem(), iterMakerETInt64Float32)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *float64) bool)(nil)).Elem(), iterMakerInt64Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *float64) bool)(nil)).Elem(), iterMakerETInt64Float64)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.T) bool)(nil)).Elem(), iterMakerInt64Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.T) bool)(nil)).Elem(), iterMakerETInt64Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.U) bool)(nil)).Elem(), iterMakerInt64Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.U) bool)(nil)).Elem(), iterMakerETInt64Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.V) bool)(nil)).Elem(), iterMakerInt64Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.V) bool)(nil)).Elem(), iterMakerETInt64Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.W) bool)(nil)).Elem(), iterMakerInt64Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.W) bool)(nil)).Elem(), iterMakerETInt64Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.X) bool)(nil)).Elem(), iterMakerInt64Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.X) bool)(nil)).Elem(), iterMakerETInt64Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.Y) bool)(nil)).Elem(), iterMakerInt64Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.Y) bool)(nil)).Elem(), iterMakerETInt64Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*int64, *typex.Z) bool)(nil)).Elem(), iterMakerInt64Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *int64, *typex.Z) bool)(nil)).Elem(), iterMakerETInt64Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*uint) bool)(nil)).Elem(), iterMakerUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint) bool)(nil)).Elem(), iterMakerETUint)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *[]byte) bool)(nil)).Elem(), iterMakerUintByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *[]byte) bool)(nil)).Elem(), iterMakerETUintByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *bool) bool)(nil)).Elem(), iterMakerUintBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *bool) bool)(nil)).Elem(), iterMakerETUintBool)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *string) bool)(nil)).Elem(), iterMakerUintString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *string) bool)(nil)).Elem(), iterMakerETUintString)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *int) bool)(nil)).Elem(), iterMakerUintInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int) bool)(nil)).Elem(), iterMakerETUintInt)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *int8) bool)(nil)).Elem(), iterMakerUintInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int8) bool)(nil)).Elem(), iterMakerETUintInt8)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *int16) bool)(nil)).Elem(), iterMakerUintInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int16) bool)(nil)).Elem(), iterMakerETUintInt16)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *int32) bool)(nil)).Elem(), iterMakerUintInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int32) bool)(nil)).Elem(), iterMakerETUintInt32)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *int64) bool)(nil)).Elem(), iterMakerUintInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *int64) bool)(nil)).Elem(), iterMakerETUintInt64)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *uint) bool)(nil)).Elem(), iterMakerUintUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint) bool)(nil)).Elem(), iterMakerETUintUint)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *uint8) bool)(nil)).Elem(), iterMakerUintUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint8) bool)(nil)).Elem(), iterMakerETUintUint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *uint16) bool)(nil)).Elem(), iterMakerUintUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint16) bool)(nil)).Elem(), iterMakerETUintUint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *uint32) bool)(nil)).Elem(), iterMakerUintUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint32) bool)(nil)).Elem(), iterMakerETUintUint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *uint64) bool)(nil)).Elem(), iterMakerUintUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *uint64) bool)(nil)).Elem(), iterMakerETUintUint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *float32) bool)(nil)).Elem(), iterMakerUintFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *float32) bool)(nil)).Elem(), iterMakerETUintFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *float64) bool)(nil)).Elem(), iterMakerUintFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *float64) bool)(nil)).Elem(), iterMakerETUintFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.T) bool)(nil)).Elem(), iterMakerUintTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.T) bool)(nil)).Elem(), iterMakerETUintTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.U) bool)(nil)).Elem(), iterMakerUintTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.U) bool)(nil)).Elem(), iterMakerETUintTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.V) bool)(nil)).Elem(), iterMakerUintTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.V) bool)(nil)).Elem(), iterMakerETUintTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.W) bool)(nil)).Elem(), iterMakerUintTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.W) bool)(nil)).Elem(), iterMakerETUintTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.X) bool)(nil)).Elem(), iterMakerUintTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.X) bool)(nil)).Elem(), iterMakerETUintTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.Y) bool)(nil)).Elem(), iterMakerUintTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.Y) bool)(nil)).Elem(), iterMakerETUintTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*uint, *typex.Z) bool)(nil)).Elem(), iterMakerUintTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint, *typex.Z) bool)(nil)).Elem(), iterMakerETUintTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*uint8) bool)(nil)).Elem(), iterMakerUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8) bool)(nil)).Elem(), iterMakerETUint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *[]byte) bool)(nil)).Elem(), iterMakerUint8ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *[]byte) bool)(nil)).Elem(), iterMakerETUint8ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *bool) bool)(nil)).Elem(), iterMakerUint8Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *bool) bool)(nil)).Elem(), iterMakerETUint8Bool)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *string) bool)(nil)).Elem(), iterMakerUint8String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *string) bool)(nil)).Elem(), iterMakerETUint8String)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *int) bool)(nil)).Elem(), iterMakerUint8Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int) bool)(nil)).Elem(), iterMakerETUint8Int)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *int8) bool)(nil)).Elem(), iterMakerUint8Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int8) bool)(nil)).Elem(), iterMakerETUint8Int8)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *int16) bool)(nil)).Elem(), iterMakerUint8Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int16) bool)(nil)).Elem(), iterMakerETUint8Int16)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *int32) bool)(nil)).Elem(), iterMakerUint8Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int32) bool)(nil)).Elem(), iterMakerETUint8Int32)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *int64) bool)(nil)).Elem(), iterMakerUint8Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *int64) bool)(nil)).Elem(), iterMakerETUint8Int64)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *uint) bool)(nil)).Elem(), iterMakerUint8Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint) bool)(nil)).Elem(), iterMakerETUint8Uint)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *uint8) bool)(nil)).Elem(), iterMakerUint8Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint8) bool)(nil)).Elem(), iterMakerETUint8Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *uint16) bool)(nil)).Elem(), iterMakerUint8Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint16) bool)(nil)).Elem(), iterMakerETUint8Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *uint32) bool)(nil)).Elem(), iterMakerUint8Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint32) bool)(nil)).Elem(), iterMakerETUint8Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *uint64) bool)(nil)).Elem(), iterMakerUint8Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *uint64) bool)(nil)).Elem(), iterMakerETUint8Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *float32) bool)(nil)).Elem(), iterMakerUint8Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *float32) bool)(nil)).Elem(), iterMakerETUint8Float32)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *float64) bool)(nil)).Elem(), iterMakerUint8Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *float64) bool)(nil)).Elem(), iterMakerETUint8Float64)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.T) bool)(nil)).Elem(), iterMakerUint8Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.T) bool)(nil)).Elem(), iterMakerETUint8Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.U) bool)(nil)).Elem(), iterMakerUint8Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.U) bool)(nil)).Elem(), iterMakerETUint8Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.V) bool)(nil)).Elem(), iterMakerUint8Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.V) bool)(nil)).Elem(), iterMakerETUint8Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.W) bool)(nil)).Elem(), iterMakerUint8Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.W) bool)(nil)).Elem(), iterMakerETUint8Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.X) bool)(nil)).Elem(), iterMakerUint8Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.X) bool)(nil)).Elem(), iterMakerETUint8Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.Y) bool)(nil)).Elem(), iterMakerUint8Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.Y) bool)(nil)).Elem(), iterMakerETUint8Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*uint8, *typex.Z) bool)(nil)).Elem(), iterMakerUint8Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint8, *typex.Z) bool)(nil)).Elem(), iterMakerETUint8Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*uint16) bool)(nil)).Elem(), iterMakerUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16) bool)(nil)).Elem(), iterMakerETUint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *[]byte) bool)(nil)).Elem(), iterMakerUint16ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *[]byte) bool)(nil)).Elem(), iterMakerETUint16ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *bool) bool)(nil)).Elem(), iterMakerUint16Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *bool) bool)(nil)).Elem(), iterMakerETUint16Bool)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *string) bool)(nil)).Elem(), iterMakerUint16String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *string) bool)(nil)).Elem(), iterMakerETUint16String)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *int) bool)(nil)).Elem(), iterMakerUint16Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int) bool)(nil)).Elem(), iterMakerETUint16Int)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *int8) bool)(nil)).Elem(), iterMakerUint16Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int8) bool)(nil)).Elem(), iterMakerETUint16Int8)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *int16) bool)(nil)).Elem(), iterMakerUint16Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int16) bool)(nil)).Elem(), iterMakerETUint16Int16)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *int32) bool)(nil)).Elem(), iterMakerUint16Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int32) bool)(nil)).Elem(), iterMakerETUint16Int32)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *int64) bool)(nil)).Elem(), iterMakerUint16Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *int64) bool)(nil)).Elem(), iterMakerETUint16Int64)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *uint) bool)(nil)).Elem(), iterMakerUint16Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint) bool)(nil)).Elem(), iterMakerETUint16Uint)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *uint8) bool)(nil)).Elem(), iterMakerUint16Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint8) bool)(nil)).Elem(), iterMakerETUint16Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *uint16) bool)(nil)).Elem(), iterMakerUint16Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint16) bool)(nil)).Elem(), iterMakerETUint16Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *uint32) bool)(nil)).Elem(), iterMakerUint16Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint32) bool)(nil)).Elem(), iterMakerETUint16Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *uint64) bool)(nil)).Elem(), iterMakerUint16Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *uint64) bool)(nil)).Elem(), iterMakerETUint16Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *float32) bool)(nil)).Elem(), iterMakerUint16Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *float32) bool)(nil)).Elem(), iterMakerETUint16Float32)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *float64) bool)(nil)).Elem(), iterMakerUint16Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *float64) bool)(nil)).Elem(), iterMakerETUint16Float64)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.T) bool)(nil)).Elem(), iterMakerUint16Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.T) bool)(nil)).Elem(), iterMakerETUint16Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.U) bool)(nil)).Elem(), iterMakerUint16Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.U) bool)(nil)).Elem(), iterMakerETUint16Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.V) bool)(nil)).Elem(), iterMakerUint16Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.V) bool)(nil)).Elem(), iterMakerETUint16Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.W) bool)(nil)).Elem(), iterMakerUint16Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.W) bool)(nil)).Elem(), iterMakerETUint16Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.X) bool)(nil)).Elem(), iterMakerUint16Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.X) bool)(nil)).Elem(), iterMakerETUint16Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.Y) bool)(nil)).Elem(), iterMakerUint16Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.Y) bool)(nil)).Elem(), iterMakerETUint16Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*uint16, *typex.Z) bool)(nil)).Elem(), iterMakerUint16Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint16, *typex.Z) bool)(nil)).Elem(), iterMakerETUint16Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*uint32) bool)(nil)).Elem(), iterMakerUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32) bool)(nil)).Elem(), iterMakerETUint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *[]byte) bool)(nil)).Elem(), iterMakerUint32ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *[]byte) bool)(nil)).Elem(), iterMakerETUint32ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *bool) bool)(nil)).Elem(), iterMakerUint32Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *bool) bool)(nil)).Elem(), iterMakerETUint32Bool)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *string) bool)(nil)).Elem(), iterMakerUint32String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *string) bool)(nil)).Elem(), iterMakerETUint32String)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *int) bool)(nil)).Elem(), iterMakerUint32Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int) bool)(nil)).Elem(), iterMakerETUint32Int)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *int8) bool)(nil)).Elem(), iterMakerUint32Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int8) bool)(nil)).Elem(), iterMakerETUint32Int8)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *int16) bool)(nil)).Elem(), iterMakerUint32Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int16) bool)(nil)).Elem(), iterMakerETUint32Int16)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *int32) bool)(nil)).Elem(), iterMakerUint32Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int32) bool)(nil)).Elem(), iterMakerETUint32Int32)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *int64) bool)(nil)).Elem(), iterMakerUint32Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *int64) bool)(nil)).Elem(), iterMakerETUint32Int64)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *uint) bool)(nil)).Elem(), iterMakerUint32Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint) bool)(nil)).Elem(), iterMakerETUint32Uint)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *uint8) bool)(nil)).Elem(), iterMakerUint32Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint8) bool)(nil)).Elem(), iterMakerETUint32Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *uint16) bool)(nil)).Elem(), iterMakerUint32Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint16) bool)(nil)).Elem(), iterMakerETUint32Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *uint32) bool)(nil)).Elem(), iterMakerUint32Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint32) bool)(nil)).Elem(), iterMakerETUint32Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *uint64) bool)(nil)).Elem(), iterMakerUint32Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *uint64) bool)(nil)).Elem(), iterMakerETUint32Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *float32) bool)(nil)).Elem(), iterMakerUint32Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *float32) bool)(nil)).Elem(), iterMakerETUint32Float32)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *float64) bool)(nil)).Elem(), iterMakerUint32Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *float64) bool)(nil)).Elem(), iterMakerETUint32Float64)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.T) bool)(nil)).Elem(), iterMakerUint32Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.T) bool)(nil)).Elem(), iterMakerETUint32Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.U) bool)(nil)).Elem(), iterMakerUint32Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.U) bool)(nil)).Elem(), iterMakerETUint32Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.V) bool)(nil)).Elem(), iterMakerUint32Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.V) bool)(nil)).Elem(), iterMakerETUint32Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.W) bool)(nil)).Elem(), iterMakerUint32Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.W) bool)(nil)).Elem(), iterMakerETUint32Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.X) bool)(nil)).Elem(), iterMakerUint32Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.X) bool)(nil)).Elem(), iterMakerETUint32Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.Y) bool)(nil)).Elem(), iterMakerUint32Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.Y) bool)(nil)).Elem(), iterMakerETUint32Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*uint32, *typex.Z) bool)(nil)).Elem(), iterMakerUint32Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint32, *typex.Z) bool)(nil)).Elem(), iterMakerETUint32Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*uint64) bool)(nil)).Elem(), iterMakerUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64) bool)(nil)).Elem(), iterMakerETUint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *[]byte) bool)(nil)).Elem(), iterMakerUint64ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *[]byte) bool)(nil)).Elem(), iterMakerETUint64ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *bool) bool)(nil)).Elem(), iterMakerUint64Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *bool) bool)(nil)).Elem(), iterMakerETUint64Bool)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *string) bool)(nil)).Elem(), iterMakerUint64String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *string) bool)(nil)).Elem(), iterMakerETUint64String)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *int) bool)(nil)).Elem(), iterMakerUint64Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int) bool)(nil)).Elem(), iterMakerETUint64Int)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *int8) bool)(nil)).Elem(), iterMakerUint64Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int8) bool)(nil)).Elem(), iterMakerETUint64Int8)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *int16) bool)(nil)).Elem(), iterMakerUint64Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int16) bool)(nil)).Elem(), iterMakerETUint64Int16)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *int32) bool)(nil)).Elem(), iterMakerUint64Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int32) bool)(nil)).Elem(), iterMakerETUint64Int32)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *int64) bool)(nil)).Elem(), iterMakerUint64Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *int64) bool)(nil)).Elem(), iterMakerETUint64Int64)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *uint) bool)(nil)).Elem(), iterMakerUint64Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint) bool)(nil)).Elem(), iterMakerETUint64Uint)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *uint8) bool)(nil)).Elem(), iterMakerUint64Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint8) bool)(nil)).Elem(), iterMakerETUint64Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *uint16) bool)(nil)).Elem(), iterMakerUint64Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint16) bool)(nil)).Elem(), iterMakerETUint64Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *uint32) bool)(nil)).Elem(), iterMakerUint64Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint32) bool)(nil)).Elem(), iterMakerETUint64Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *uint64) bool)(nil)).Elem(), iterMakerUint64Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *uint64) bool)(nil)).Elem(), iterMakerETUint64Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *float32) bool)(nil)).Elem(), iterMakerUint64Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *float32) bool)(nil)).Elem(), iterMakerETUint64Float32)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *float64) bool)(nil)).Elem(), iterMakerUint64Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *float64) bool)(nil)).Elem(), iterMakerETUint64Float64)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.T) bool)(nil)).Elem(), iterMakerUint64Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.T) bool)(nil)).Elem(), iterMakerETUint64Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.U) bool)(nil)).Elem(), iterMakerUint64Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.U) bool)(nil)).Elem(), iterMakerETUint64Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.V) bool)(nil)).Elem(), iterMakerUint64Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.V) bool)(nil)).Elem(), iterMakerETUint64Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.W) bool)(nil)).Elem(), iterMakerUint64Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.W) bool)(nil)).Elem(), iterMakerETUint64Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.X) bool)(nil)).Elem(), iterMakerUint64Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.X) bool)(nil)).Elem(), iterMakerETUint64Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.Y) bool)(nil)).Elem(), iterMakerUint64Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.Y) bool)(nil)).Elem(), iterMakerETUint64Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*uint64, *typex.Z) bool)(nil)).Elem(), iterMakerUint64Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *uint64, *typex.Z) bool)(nil)).Elem(), iterMakerETUint64Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*float32) bool)(nil)).Elem(), iterMakerFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32) bool)(nil)).Elem(), iterMakerETFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *[]byte) bool)(nil)).Elem(), iterMakerFloat32ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *[]byte) bool)(nil)).Elem(), iterMakerETFloat32ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *bool) bool)(nil)).Elem(), iterMakerFloat32Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *bool) bool)(nil)).Elem(), iterMakerETFloat32Bool)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *string) bool)(nil)).Elem(), iterMakerFloat32String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *string) bool)(nil)).Elem(), iterMakerETFloat32String)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *int) bool)(nil)).Elem(), iterMakerFloat32Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int) bool)(nil)).Elem(), iterMakerETFloat32Int)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *int8) bool)(nil)).Elem(), iterMakerFloat32Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int8) bool)(nil)).Elem(), iterMakerETFloat32Int8)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *int16) bool)(nil)).Elem(), iterMakerFloat32Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int16) bool)(nil)).Elem(), iterMakerETFloat32Int16)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *int32) bool)(nil)).Elem(), iterMakerFloat32Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int32) bool)(nil)).Elem(), iterMakerETFloat32Int32)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *int64) bool)(nil)).Elem(), iterMakerFloat32Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *int64) bool)(nil)).Elem(), iterMakerETFloat32Int64)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *uint) bool)(nil)).Elem(), iterMakerFloat32Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint) bool)(nil)).Elem(), iterMakerETFloat32Uint)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *uint8) bool)(nil)).Elem(), iterMakerFloat32Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint8) bool)(nil)).Elem(), iterMakerETFloat32Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *uint16) bool)(nil)).Elem(), iterMakerFloat32Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint16) bool)(nil)).Elem(), iterMakerETFloat32Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *uint32) bool)(nil)).Elem(), iterMakerFloat32Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint32) bool)(nil)).Elem(), iterMakerETFloat32Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *uint64) bool)(nil)).Elem(), iterMakerFloat32Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *uint64) bool)(nil)).Elem(), iterMakerETFloat32Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *float32) bool)(nil)).Elem(), iterMakerFloat32Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *float32) bool)(nil)).Elem(), iterMakerETFloat32Float32)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *float64) bool)(nil)).Elem(), iterMakerFloat32Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *float64) bool)(nil)).Elem(), iterMakerETFloat32Float64)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.T) bool)(nil)).Elem(), iterMakerFloat32Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.T) bool)(nil)).Elem(), iterMakerETFloat32Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.U) bool)(nil)).Elem(), iterMakerFloat32Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.U) bool)(nil)).Elem(), iterMakerETFloat32Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.V) bool)(nil)).Elem(), iterMakerFloat32Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.V) bool)(nil)).Elem(), iterMakerETFloat32Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.W) bool)(nil)).Elem(), iterMakerFloat32Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.W) bool)(nil)).Elem(), iterMakerETFloat32Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.X) bool)(nil)).Elem(), iterMakerFloat32Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.X) bool)(nil)).Elem(), iterMakerETFloat32Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.Y) bool)(nil)).Elem(), iterMakerFloat32Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.Y) bool)(nil)).Elem(), iterMakerETFloat32Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*float32, *typex.Z) bool)(nil)).Elem(), iterMakerFloat32Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float32, *typex.Z) bool)(nil)).Elem(), iterMakerETFloat32Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*float64) bool)(nil)).Elem(), iterMakerFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64) bool)(nil)).Elem(), iterMakerETFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *[]byte) bool)(nil)).Elem(), iterMakerFloat64ByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *[]byte) bool)(nil)).Elem(), iterMakerETFloat64ByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *bool) bool)(nil)).Elem(), iterMakerFloat64Bool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *bool) bool)(nil)).Elem(), iterMakerETFloat64Bool)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *string) bool)(nil)).Elem(), iterMakerFloat64String)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *string) bool)(nil)).Elem(), iterMakerETFloat64String)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *int) bool)(nil)).Elem(), iterMakerFloat64Int)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int) bool)(nil)).Elem(), iterMakerETFloat64Int)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *int8) bool)(nil)).Elem(), iterMakerFloat64Int8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int8) bool)(nil)).Elem(), iterMakerETFloat64Int8)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *int16) bool)(nil)).Elem(), iterMakerFloat64Int16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int16) bool)(nil)).Elem(), iterMakerETFloat64Int16)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *int32) bool)(nil)).Elem(), iterMakerFloat64Int32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int32) bool)(nil)).Elem(), iterMakerETFloat64Int32)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *int64) bool)(nil)).Elem(), iterMakerFloat64Int64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *int64) bool)(nil)).Elem(), iterMakerETFloat64Int64)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *uint) bool)(nil)).Elem(), iterMakerFloat64Uint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint) bool)(nil)).Elem(), iterMakerETFloat64Uint)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *uint8) bool)(nil)).Elem(), iterMakerFloat64Uint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint8) bool)(nil)).Elem(), iterMakerETFloat64Uint8)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *uint16) bool)(nil)).Elem(), iterMakerFloat64Uint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint16) bool)(nil)).Elem(), iterMakerETFloat64Uint16)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *uint32) bool)(nil)).Elem(), iterMakerFloat64Uint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint32) bool)(nil)).Elem(), iterMakerETFloat64Uint32)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *uint64) bool)(nil)).Elem(), iterMakerFloat64Uint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *uint64) bool)(nil)).Elem(), iterMakerETFloat64Uint64)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *float32) bool)(nil)).Elem(), iterMakerFloat64Float32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *float32) bool)(nil)).Elem(), iterMakerETFloat64Float32)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *float64) bool)(nil)).Elem(), iterMakerFloat64Float64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *float64) bool)(nil)).Elem(), iterMakerETFloat64Float64)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.T) bool)(nil)).Elem(), iterMakerFloat64Typex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.T) bool)(nil)).Elem(), iterMakerETFloat64Typex_T)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.U) bool)(nil)).Elem(), iterMakerFloat64Typex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.U) bool)(nil)).Elem(), iterMakerETFloat64Typex_U)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.V) bool)(nil)).Elem(), iterMakerFloat64Typex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.V) bool)(nil)).Elem(), iterMakerETFloat64Typex_V)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.W) bool)(nil)).Elem(), iterMakerFloat64Typex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.W) bool)(nil)).Elem(), iterMakerETFloat64Typex_W)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.X) bool)(nil)).Elem(), iterMakerFloat64Typex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.X) bool)(nil)).Elem(), iterMakerETFloat64Typex_X)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.Y) bool)(nil)).Elem(), iterMakerFloat64Typex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.Y) bool)(nil)).Elem(), iterMakerETFloat64Typex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*float64, *typex.Z) bool)(nil)).Elem(), iterMakerFloat64Typex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *float64, *typex.Z) bool)(nil)).Elem(), iterMakerETFloat64Typex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T) bool)(nil)).Elem(), iterMakerTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *[]byte) bool)(nil)).Elem(), iterMakerTypex_TByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_TByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *bool) bool)(nil)).Elem(), iterMakerTypex_TBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *bool) bool)(nil)).Elem(), iterMakerETTypex_TBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *string) bool)(nil)).Elem(), iterMakerTypex_TString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *string) bool)(nil)).Elem(), iterMakerETTypex_TString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *int) bool)(nil)).Elem(), iterMakerTypex_TInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int) bool)(nil)).Elem(), iterMakerETTypex_TInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *int8) bool)(nil)).Elem(), iterMakerTypex_TInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int8) bool)(nil)).Elem(), iterMakerETTypex_TInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *int16) bool)(nil)).Elem(), iterMakerTypex_TInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int16) bool)(nil)).Elem(), iterMakerETTypex_TInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *int32) bool)(nil)).Elem(), iterMakerTypex_TInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int32) bool)(nil)).Elem(), iterMakerETTypex_TInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *int64) bool)(nil)).Elem(), iterMakerTypex_TInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *int64) bool)(nil)).Elem(), iterMakerETTypex_TInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *uint) bool)(nil)).Elem(), iterMakerTypex_TUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint) bool)(nil)).Elem(), iterMakerETTypex_TUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *uint8) bool)(nil)).Elem(), iterMakerTypex_TUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint8) bool)(nil)).Elem(), iterMakerETTypex_TUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *uint16) bool)(nil)).Elem(), iterMakerTypex_TUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint16) bool)(nil)).Elem(), iterMakerETTypex_TUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *uint32) bool)(nil)).Elem(), iterMakerTypex_TUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint32) bool)(nil)).Elem(), iterMakerETTypex_TUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *uint64) bool)(nil)).Elem(), iterMakerTypex_TUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *uint64) bool)(nil)).Elem(), iterMakerETTypex_TUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *float32) bool)(nil)).Elem(), iterMakerTypex_TFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *float32) bool)(nil)).Elem(), iterMakerETTypex_TFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *float64) bool)(nil)).Elem(), iterMakerTypex_TFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *float64) bool)(nil)).Elem(), iterMakerETTypex_TFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.T) bool)(nil)).Elem(), iterMakerTypex_TTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_TTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.U) bool)(nil)).Elem(), iterMakerTypex_TTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_TTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.V) bool)(nil)).Elem(), iterMakerTypex_TTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_TTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.W) bool)(nil)).Elem(), iterMakerTypex_TTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_TTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.X) bool)(nil)).Elem(), iterMakerTypex_TTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_TTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_TTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_TTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.T, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_TTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.T, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_TTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U) bool)(nil)).Elem(), iterMakerTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *[]byte) bool)(nil)).Elem(), iterMakerTypex_UByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_UByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *bool) bool)(nil)).Elem(), iterMakerTypex_UBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *bool) bool)(nil)).Elem(), iterMakerETTypex_UBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *string) bool)(nil)).Elem(), iterMakerTypex_UString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *string) bool)(nil)).Elem(), iterMakerETTypex_UString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *int) bool)(nil)).Elem(), iterMakerTypex_UInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int) bool)(nil)).Elem(), iterMakerETTypex_UInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *int8) bool)(nil)).Elem(), iterMakerTypex_UInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int8) bool)(nil)).Elem(), iterMakerETTypex_UInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *int16) bool)(nil)).Elem(), iterMakerTypex_UInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int16) bool)(nil)).Elem(), iterMakerETTypex_UInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *int32) bool)(nil)).Elem(), iterMakerTypex_UInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int32) bool)(nil)).Elem(), iterMakerETTypex_UInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *int64) bool)(nil)).Elem(), iterMakerTypex_UInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *int64) bool)(nil)).Elem(), iterMakerETTypex_UInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *uint) bool)(nil)).Elem(), iterMakerTypex_UUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint) bool)(nil)).Elem(), iterMakerETTypex_UUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *uint8) bool)(nil)).Elem(), iterMakerTypex_UUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint8) bool)(nil)).Elem(), iterMakerETTypex_UUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *uint16) bool)(nil)).Elem(), iterMakerTypex_UUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint16) bool)(nil)).Elem(), iterMakerETTypex_UUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *uint32) bool)(nil)).Elem(), iterMakerTypex_UUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint32) bool)(nil)).Elem(), iterMakerETTypex_UUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *uint64) bool)(nil)).Elem(), iterMakerTypex_UUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *uint64) bool)(nil)).Elem(), iterMakerETTypex_UUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *float32) bool)(nil)).Elem(), iterMakerTypex_UFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *float32) bool)(nil)).Elem(), iterMakerETTypex_UFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *float64) bool)(nil)).Elem(), iterMakerTypex_UFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *float64) bool)(nil)).Elem(), iterMakerETTypex_UFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.T) bool)(nil)).Elem(), iterMakerTypex_UTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_UTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.U) bool)(nil)).Elem(), iterMakerTypex_UTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_UTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.V) bool)(nil)).Elem(), iterMakerTypex_UTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_UTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.W) bool)(nil)).Elem(), iterMakerTypex_UTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_UTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.X) bool)(nil)).Elem(), iterMakerTypex_UTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_UTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_UTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_UTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.U, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_UTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.U, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_UTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V) bool)(nil)).Elem(), iterMakerTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *[]byte) bool)(nil)).Elem(), iterMakerTypex_VByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_VByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *bool) bool)(nil)).Elem(), iterMakerTypex_VBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *bool) bool)(nil)).Elem(), iterMakerETTypex_VBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *string) bool)(nil)).Elem(), iterMakerTypex_VString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *string) bool)(nil)).Elem(), iterMakerETTypex_VString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *int) bool)(nil)).Elem(), iterMakerTypex_VInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int) bool)(nil)).Elem(), iterMakerETTypex_VInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *int8) bool)(nil)).Elem(), iterMakerTypex_VInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int8) bool)(nil)).Elem(), iterMakerETTypex_VInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *int16) bool)(nil)).Elem(), iterMakerTypex_VInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int16) bool)(nil)).Elem(), iterMakerETTypex_VInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *int32) bool)(nil)).Elem(), iterMakerTypex_VInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int32) bool)(nil)).Elem(), iterMakerETTypex_VInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *int64) bool)(nil)).Elem(), iterMakerTypex_VInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *int64) bool)(nil)).Elem(), iterMakerETTypex_VInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *uint) bool)(nil)).Elem(), iterMakerTypex_VUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint) bool)(nil)).Elem(), iterMakerETTypex_VUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *uint8) bool)(nil)).Elem(), iterMakerTypex_VUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint8) bool)(nil)).Elem(), iterMakerETTypex_VUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *uint16) bool)(nil)).Elem(), iterMakerTypex_VUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint16) bool)(nil)).Elem(), iterMakerETTypex_VUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *uint32) bool)(nil)).Elem(), iterMakerTypex_VUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint32) bool)(nil)).Elem(), iterMakerETTypex_VUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *uint64) bool)(nil)).Elem(), iterMakerTypex_VUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *uint64) bool)(nil)).Elem(), iterMakerETTypex_VUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *float32) bool)(nil)).Elem(), iterMakerTypex_VFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *float32) bool)(nil)).Elem(), iterMakerETTypex_VFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *float64) bool)(nil)).Elem(), iterMakerTypex_VFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *float64) bool)(nil)).Elem(), iterMakerETTypex_VFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.T) bool)(nil)).Elem(), iterMakerTypex_VTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_VTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.U) bool)(nil)).Elem(), iterMakerTypex_VTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_VTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.V) bool)(nil)).Elem(), iterMakerTypex_VTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_VTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.W) bool)(nil)).Elem(), iterMakerTypex_VTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_VTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.X) bool)(nil)).Elem(), iterMakerTypex_VTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_VTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_VTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_VTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.V, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_VTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.V, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_VTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W) bool)(nil)).Elem(), iterMakerTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *[]byte) bool)(nil)).Elem(), iterMakerTypex_WByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_WByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *bool) bool)(nil)).Elem(), iterMakerTypex_WBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *bool) bool)(nil)).Elem(), iterMakerETTypex_WBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *string) bool)(nil)).Elem(), iterMakerTypex_WString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *string) bool)(nil)).Elem(), iterMakerETTypex_WString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *int) bool)(nil)).Elem(), iterMakerTypex_WInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int) bool)(nil)).Elem(), iterMakerETTypex_WInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *int8) bool)(nil)).Elem(), iterMakerTypex_WInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int8) bool)(nil)).Elem(), iterMakerETTypex_WInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *int16) bool)(nil)).Elem(), iterMakerTypex_WInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int16) bool)(nil)).Elem(), iterMakerETTypex_WInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *int32) bool)(nil)).Elem(), iterMakerTypex_WInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int32) bool)(nil)).Elem(), iterMakerETTypex_WInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *int64) bool)(nil)).Elem(), iterMakerTypex_WInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *int64) bool)(nil)).Elem(), iterMakerETTypex_WInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *uint) bool)(nil)).Elem(), iterMakerTypex_WUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint) bool)(nil)).Elem(), iterMakerETTypex_WUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *uint8) bool)(nil)).Elem(), iterMakerTypex_WUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint8) bool)(nil)).Elem(), iterMakerETTypex_WUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *uint16) bool)(nil)).Elem(), iterMakerTypex_WUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint16) bool)(nil)).Elem(), iterMakerETTypex_WUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *uint32) bool)(nil)).Elem(), iterMakerTypex_WUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint32) bool)(nil)).Elem(), iterMakerETTypex_WUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *uint64) bool)(nil)).Elem(), iterMakerTypex_WUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *uint64) bool)(nil)).Elem(), iterMakerETTypex_WUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *float32) bool)(nil)).Elem(), iterMakerTypex_WFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *float32) bool)(nil)).Elem(), iterMakerETTypex_WFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *float64) bool)(nil)).Elem(), iterMakerTypex_WFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *float64) bool)(nil)).Elem(), iterMakerETTypex_WFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.T) bool)(nil)).Elem(), iterMakerTypex_WTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_WTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.U) bool)(nil)).Elem(), iterMakerTypex_WTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_WTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.V) bool)(nil)).Elem(), iterMakerTypex_WTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_WTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.W) bool)(nil)).Elem(), iterMakerTypex_WTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_WTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.X) bool)(nil)).Elem(), iterMakerTypex_WTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_WTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_WTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_WTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.W, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_WTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.W, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_WTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X) bool)(nil)).Elem(), iterMakerTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *[]byte) bool)(nil)).Elem(), iterMakerTypex_XByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_XByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *bool) bool)(nil)).Elem(), iterMakerTypex_XBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *bool) bool)(nil)).Elem(), iterMakerETTypex_XBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *string) bool)(nil)).Elem(), iterMakerTypex_XString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *string) bool)(nil)).Elem(), iterMakerETTypex_XString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *int) bool)(nil)).Elem(), iterMakerTypex_XInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int) bool)(nil)).Elem(), iterMakerETTypex_XInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *int8) bool)(nil)).Elem(), iterMakerTypex_XInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int8) bool)(nil)).Elem(), iterMakerETTypex_XInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *int16) bool)(nil)).Elem(), iterMakerTypex_XInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int16) bool)(nil)).Elem(), iterMakerETTypex_XInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *int32) bool)(nil)).Elem(), iterMakerTypex_XInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int32) bool)(nil)).Elem(), iterMakerETTypex_XInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *int64) bool)(nil)).Elem(), iterMakerTypex_XInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *int64) bool)(nil)).Elem(), iterMakerETTypex_XInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *uint) bool)(nil)).Elem(), iterMakerTypex_XUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint) bool)(nil)).Elem(), iterMakerETTypex_XUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *uint8) bool)(nil)).Elem(), iterMakerTypex_XUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint8) bool)(nil)).Elem(), iterMakerETTypex_XUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *uint16) bool)(nil)).Elem(), iterMakerTypex_XUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint16) bool)(nil)).Elem(), iterMakerETTypex_XUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *uint32) bool)(nil)).Elem(), iterMakerTypex_XUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint32) bool)(nil)).Elem(), iterMakerETTypex_XUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *uint64) bool)(nil)).Elem(), iterMakerTypex_XUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *uint64) bool)(nil)).Elem(), iterMakerETTypex_XUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *float32) bool)(nil)).Elem(), iterMakerTypex_XFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *float32) bool)(nil)).Elem(), iterMakerETTypex_XFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *float64) bool)(nil)).Elem(), iterMakerTypex_XFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *float64) bool)(nil)).Elem(), iterMakerETTypex_XFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.T) bool)(nil)).Elem(), iterMakerTypex_XTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_XTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.U) bool)(nil)).Elem(), iterMakerTypex_XTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_XTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.V) bool)(nil)).Elem(), iterMakerTypex_XTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_XTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.W) bool)(nil)).Elem(), iterMakerTypex_XTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_XTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.X) bool)(nil)).Elem(), iterMakerTypex_XTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_XTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_XTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_XTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_XTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.X, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_XTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y) bool)(nil)).Elem(), iterMakerTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *[]byte) bool)(nil)).Elem(), iterMakerTypex_YByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_YByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *bool) bool)(nil)).Elem(), iterMakerTypex_YBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *bool) bool)(nil)).Elem(), iterMakerETTypex_YBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *string) bool)(nil)).Elem(), iterMakerTypex_YString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *string) bool)(nil)).Elem(), iterMakerETTypex_YString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *int) bool)(nil)).Elem(), iterMakerTypex_YInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int) bool)(nil)).Elem(), iterMakerETTypex_YInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *int8) bool)(nil)).Elem(), iterMakerTypex_YInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int8) bool)(nil)).Elem(), iterMakerETTypex_YInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *int16) bool)(nil)).Elem(), iterMakerTypex_YInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int16) bool)(nil)).Elem(), iterMakerETTypex_YInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *int32) bool)(nil)).Elem(), iterMakerTypex_YInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int32) bool)(nil)).Elem(), iterMakerETTypex_YInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *int64) bool)(nil)).Elem(), iterMakerTypex_YInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *int64) bool)(nil)).Elem(), iterMakerETTypex_YInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint) bool)(nil)).Elem(), iterMakerTypex_YUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint) bool)(nil)).Elem(), iterMakerETTypex_YUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint8) bool)(nil)).Elem(), iterMakerTypex_YUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint8) bool)(nil)).Elem(), iterMakerETTypex_YUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint16) bool)(nil)).Elem(), iterMakerTypex_YUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint16) bool)(nil)).Elem(), iterMakerETTypex_YUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint32) bool)(nil)).Elem(), iterMakerTypex_YUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint32) bool)(nil)).Elem(), iterMakerETTypex_YUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *uint64) bool)(nil)).Elem(), iterMakerTypex_YUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *uint64) bool)(nil)).Elem(), iterMakerETTypex_YUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *float32) bool)(nil)).Elem(), iterMakerTypex_YFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *float32) bool)(nil)).Elem(), iterMakerETTypex_YFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *float64) bool)(nil)).Elem(), iterMakerTypex_YFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *float64) bool)(nil)).Elem(), iterMakerETTypex_YFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.T) bool)(nil)).Elem(), iterMakerTypex_YTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_YTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.U) bool)(nil)).Elem(), iterMakerTypex_YTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_YTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.V) bool)(nil)).Elem(), iterMakerTypex_YTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_YTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.W) bool)(nil)).Elem(), iterMakerTypex_YTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_YTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.X) bool)(nil)).Elem(), iterMakerTypex_YTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_YTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_YTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_YTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Y, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_YTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Y, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_YTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z) bool)(nil)).Elem(), iterMakerTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_Z)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *[]byte) bool)(nil)).Elem(), iterMakerTypex_ZByteSlice)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *[]byte) bool)(nil)).Elem(), iterMakerETTypex_ZByteSlice)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *bool) bool)(nil)).Elem(), iterMakerTypex_ZBool)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *bool) bool)(nil)).Elem(), iterMakerETTypex_ZBool)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *string) bool)(nil)).Elem(), iterMakerTypex_ZString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *string) bool)(nil)).Elem(), iterMakerETTypex_ZString)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *int) bool)(nil)).Elem(), iterMakerTypex_ZInt)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int) bool)(nil)).Elem(), iterMakerETTypex_ZInt)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *int8) bool)(nil)).Elem(), iterMakerTypex_ZInt8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int8) bool)(nil)).Elem(), iterMakerETTypex_ZInt8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *int16) bool)(nil)).Elem(), iterMakerTypex_ZInt16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int16) bool)(nil)).Elem(), iterMakerETTypex_ZInt16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *int32) bool)(nil)).Elem(), iterMakerTypex_ZInt32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int32) bool)(nil)).Elem(), iterMakerETTypex_ZInt32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *int64) bool)(nil)).Elem(), iterMakerTypex_ZInt64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *int64) bool)(nil)).Elem(), iterMakerETTypex_ZInt64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint) bool)(nil)).Elem(), iterMakerTypex_ZUint)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint) bool)(nil)).Elem(), iterMakerETTypex_ZUint)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint8) bool)(nil)).Elem(), iterMakerTypex_ZUint8)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint8) bool)(nil)).Elem(), iterMakerETTypex_ZUint8)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint16) bool)(nil)).Elem(), iterMakerTypex_ZUint16)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint16) bool)(nil)).Elem(), iterMakerETTypex_ZUint16)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint32) bool)(nil)).Elem(), iterMakerTypex_ZUint32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint32) bool)(nil)).Elem(), iterMakerETTypex_ZUint32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *uint64) bool)(nil)).Elem(), iterMakerTypex_ZUint64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *uint64) bool)(nil)).Elem(), iterMakerETTypex_ZUint64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *float32) bool)(nil)).Elem(), iterMakerTypex_ZFloat32)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *float32) bool)(nil)).Elem(), iterMakerETTypex_ZFloat32)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *float64) bool)(nil)).Elem(), iterMakerTypex_ZFloat64)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *float64) bool)(nil)).Elem(), iterMakerETTypex_ZFloat64)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.T) bool)(nil)).Elem(), iterMakerTypex_ZTypex_T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.T) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_T)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.U) bool)(nil)).Elem(), iterMakerTypex_ZTypex_U)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.U) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_U)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.V) bool)(nil)).Elem(), iterMakerTypex_ZTypex_V)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.V) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_V)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.W) bool)(nil)).Elem(), iterMakerTypex_ZTypex_W)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.W) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_W)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.X) bool)(nil)).Elem(), iterMakerTypex_ZTypex_X)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.X) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_X)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.Y) bool)(nil)).Elem(), iterMakerTypex_ZTypex_Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.Y) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_Y)
exec.RegisterInput(reflect.TypeOf((*func(*typex.Z, *typex.Z) bool)(nil)).Elem(), iterMakerTypex_ZTypex_Z)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.EventTime, *typex.Z, *typex.Z) bool)(nil)).Elem(), iterMakerETTypex_ZTypex_Z)
}
type iterNative struct {
@@ -1088,7 +582,7 @@ func iterMakerByteSlice(s exec.ReStream) exec.ReusableInput {
return ret
}
-func (v *iterNative) readETByteSlice(et *typex.EventTime, val *[]byte) bool {
+func (v *iterNative) readByteSliceByteSlice(key *[]byte, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1096,19 +590,18 @@ func (v *iterNative) readETByteSlice(et *typex.EventTime, val *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.([]byte)
+ *key = elm.Elm.([]byte)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSlice
+ ret.fn = ret.readByteSliceByteSlice
return ret
}
-func (v *iterNative) readByteSliceByteSlice(key *[]byte, value *[]byte) bool {
+func (v *iterNative) readByteSliceBool(key *[]byte, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1117,17 +610,17 @@ func (v *iterNative) readByteSliceByteSlice(key *[]byte, value *[]byte) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.([]byte)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerByteSliceByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceByteSlice
+ ret.fn = ret.readByteSliceBool
return ret
}
-func (v *iterNative) readETByteSliceByteSlice(et *typex.EventTime, key *[]byte, value *[]byte) bool {
+func (v *iterNative) readByteSliceString(key *[]byte, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1135,20 +628,18 @@ func (v *iterNative) readETByteSliceByteSlice(et *typex.EventTime, key *[]byte,
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.([]byte)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETByteSliceByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceByteSlice
+ ret.fn = ret.readByteSliceString
return ret
}
-func (v *iterNative) readByteSliceBool(key *[]byte, value *bool) bool {
+func (v *iterNative) readByteSliceInt(key *[]byte, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1157,17 +648,17 @@ func (v *iterNative) readByteSliceBool(key *[]byte, value *bool) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(bool)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerByteSliceBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceBool
+ ret.fn = ret.readByteSliceInt
return ret
}
-func (v *iterNative) readETByteSliceBool(et *typex.EventTime, key *[]byte, value *bool) bool {
+func (v *iterNative) readByteSliceInt8(key *[]byte, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1175,20 +666,18 @@ func (v *iterNative) readETByteSliceBool(et *typex.EventTime, key *[]byte, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(bool)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETByteSliceBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceBool
+ ret.fn = ret.readByteSliceInt8
return ret
}
-func (v *iterNative) readByteSliceString(key *[]byte, value *string) bool {
+func (v *iterNative) readByteSliceInt16(key *[]byte, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1197,17 +686,17 @@ func (v *iterNative) readByteSliceString(key *[]byte, value *string) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(string)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerByteSliceString(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceString
+ ret.fn = ret.readByteSliceInt16
return ret
}
-func (v *iterNative) readETByteSliceString(et *typex.EventTime, key *[]byte, value *string) bool {
+func (v *iterNative) readByteSliceInt32(key *[]byte, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1215,20 +704,18 @@ func (v *iterNative) readETByteSliceString(et *typex.EventTime, key *[]byte, val
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(string)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETByteSliceString(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceString
+ ret.fn = ret.readByteSliceInt32
return ret
}
-func (v *iterNative) readByteSliceInt(key *[]byte, value *int) bool {
+func (v *iterNative) readByteSliceInt64(key *[]byte, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1237,17 +724,17 @@ func (v *iterNative) readByteSliceInt(key *[]byte, value *int) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerByteSliceInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceInt
+ ret.fn = ret.readByteSliceInt64
return ret
}
-func (v *iterNative) readETByteSliceInt(et *typex.EventTime, key *[]byte, value *int) bool {
+func (v *iterNative) readByteSliceUint(key *[]byte, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1255,20 +742,18 @@ func (v *iterNative) readETByteSliceInt(et *typex.EventTime, key *[]byte, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETByteSliceInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceInt
+ ret.fn = ret.readByteSliceUint
return ret
}
-func (v *iterNative) readByteSliceInt8(key *[]byte, value *int8) bool {
+func (v *iterNative) readByteSliceUint8(key *[]byte, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1277,17 +762,17 @@ func (v *iterNative) readByteSliceInt8(key *[]byte, value *int8) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int8)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerByteSliceInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceInt8
+ ret.fn = ret.readByteSliceUint8
return ret
}
-func (v *iterNative) readETByteSliceInt8(et *typex.EventTime, key *[]byte, value *int8) bool {
+func (v *iterNative) readByteSliceUint16(key *[]byte, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1295,20 +780,18 @@ func (v *iterNative) readETByteSliceInt8(et *typex.EventTime, key *[]byte, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int8)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETByteSliceInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceInt8
+ ret.fn = ret.readByteSliceUint16
return ret
}
-func (v *iterNative) readByteSliceInt16(key *[]byte, value *int16) bool {
+func (v *iterNative) readByteSliceUint32(key *[]byte, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1317,17 +800,17 @@ func (v *iterNative) readByteSliceInt16(key *[]byte, value *int16) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int16)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerByteSliceInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceInt16
+ ret.fn = ret.readByteSliceUint32
return ret
}
-func (v *iterNative) readETByteSliceInt16(et *typex.EventTime, key *[]byte, value *int16) bool {
+func (v *iterNative) readByteSliceUint64(key *[]byte, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1335,20 +818,18 @@ func (v *iterNative) readETByteSliceInt16(et *typex.EventTime, key *[]byte, valu
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int16)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETByteSliceInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceInt16
+ ret.fn = ret.readByteSliceUint64
return ret
}
-func (v *iterNative) readByteSliceInt32(key *[]byte, value *int32) bool {
+func (v *iterNative) readByteSliceFloat32(key *[]byte, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1357,17 +838,17 @@ func (v *iterNative) readByteSliceInt32(key *[]byte, value *int32) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int32)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerByteSliceInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceInt32
+ ret.fn = ret.readByteSliceFloat32
return ret
}
-func (v *iterNative) readETByteSliceInt32(et *typex.EventTime, key *[]byte, value *int32) bool {
+func (v *iterNative) readByteSliceFloat64(key *[]byte, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1375,20 +856,18 @@ func (v *iterNative) readETByteSliceInt32(et *typex.EventTime, key *[]byte, valu
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int32)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETByteSliceInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceInt32
+ ret.fn = ret.readByteSliceFloat64
return ret
}
-func (v *iterNative) readByteSliceInt64(key *[]byte, value *int64) bool {
+func (v *iterNative) readByteSliceTypex_T(key *[]byte, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1397,17 +876,17 @@ func (v *iterNative) readByteSliceInt64(key *[]byte, value *int64) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int64)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerByteSliceInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceInt64
+ ret.fn = ret.readByteSliceTypex_T
return ret
}
-func (v *iterNative) readETByteSliceInt64(et *typex.EventTime, key *[]byte, value *int64) bool {
+func (v *iterNative) readByteSliceTypex_U(key *[]byte, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1415,20 +894,18 @@ func (v *iterNative) readETByteSliceInt64(et *typex.EventTime, key *[]byte, valu
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(int64)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETByteSliceInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceInt64
+ ret.fn = ret.readByteSliceTypex_U
return ret
}
-func (v *iterNative) readByteSliceUint(key *[]byte, value *uint) bool {
+func (v *iterNative) readByteSliceTypex_V(key *[]byte, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1437,17 +914,17 @@ func (v *iterNative) readByteSliceUint(key *[]byte, value *uint) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerByteSliceUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceUint
+ ret.fn = ret.readByteSliceTypex_V
return ret
}
-func (v *iterNative) readETByteSliceUint(et *typex.EventTime, key *[]byte, value *uint) bool {
+func (v *iterNative) readByteSliceTypex_W(key *[]byte, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1455,20 +932,18 @@ func (v *iterNative) readETByteSliceUint(et *typex.EventTime, key *[]byte, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETByteSliceUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceUint
+ ret.fn = ret.readByteSliceTypex_W
return ret
}
-func (v *iterNative) readByteSliceUint8(key *[]byte, value *uint8) bool {
+func (v *iterNative) readByteSliceTypex_X(key *[]byte, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1477,17 +952,17 @@ func (v *iterNative) readByteSliceUint8(key *[]byte, value *uint8) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint8)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerByteSliceUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceUint8
+ ret.fn = ret.readByteSliceTypex_X
return ret
}
-func (v *iterNative) readETByteSliceUint8(et *typex.EventTime, key *[]byte, value *uint8) bool {
+func (v *iterNative) readByteSliceTypex_Y(key *[]byte, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1495,20 +970,18 @@ func (v *iterNative) readETByteSliceUint8(et *typex.EventTime, key *[]byte, valu
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint8)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETByteSliceUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceUint8
+ ret.fn = ret.readByteSliceTypex_Y
return ret
}
-func (v *iterNative) readByteSliceUint16(key *[]byte, value *uint16) bool {
+func (v *iterNative) readByteSliceTypex_Z(key *[]byte, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1517,17 +990,17 @@ func (v *iterNative) readByteSliceUint16(key *[]byte, value *uint16) bool {
panic(fmt.Sprintf("broken stream: %v", err))
}
*key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint16)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerByteSliceUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerByteSliceTypex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceUint16
+ ret.fn = ret.readByteSliceTypex_Z
return ret
}
-func (v *iterNative) readETByteSliceUint16(et *typex.EventTime, key *[]byte, value *uint16) bool {
+func (v *iterNative) readBool(val *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1535,20 +1008,17 @@ func (v *iterNative) readETByteSliceUint16(et *typex.EventTime, key *[]byte, val
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(bool)
return true
}
-func iterMakerETByteSliceUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceUint16
+ ret.fn = ret.readBool
return ret
}
-func (v *iterNative) readByteSliceUint32(key *[]byte, value *uint32) bool {
+func (v *iterNative) readBoolByteSlice(key *bool, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1556,18 +1026,18 @@ func (v *iterNative) readByteSliceUint32(key *[]byte, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerByteSliceUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceUint32
+ ret.fn = ret.readBoolByteSlice
return ret
}
-func (v *iterNative) readETByteSliceUint32(et *typex.EventTime, key *[]byte, value *uint32) bool {
+func (v *iterNative) readBoolBool(key *bool, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1575,20 +1045,18 @@ func (v *iterNative) readETByteSliceUint32(et *typex.EventTime, key *[]byte, val
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETByteSliceUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceUint32
+ ret.fn = ret.readBoolBool
return ret
}
-func (v *iterNative) readByteSliceUint64(key *[]byte, value *uint64) bool {
+func (v *iterNative) readBoolString(key *bool, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1596,18 +1064,18 @@ func (v *iterNative) readByteSliceUint64(key *[]byte, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerByteSliceUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceUint64
+ ret.fn = ret.readBoolString
return ret
}
-func (v *iterNative) readETByteSliceUint64(et *typex.EventTime, key *[]byte, value *uint64) bool {
+func (v *iterNative) readBoolInt(key *bool, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1615,20 +1083,18 @@ func (v *iterNative) readETByteSliceUint64(et *typex.EventTime, key *[]byte, val
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETByteSliceUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceUint64
+ ret.fn = ret.readBoolInt
return ret
}
-func (v *iterNative) readByteSliceFloat32(key *[]byte, value *float32) bool {
+func (v *iterNative) readBoolInt8(key *bool, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1636,18 +1102,18 @@ func (v *iterNative) readByteSliceFloat32(key *[]byte, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerByteSliceFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceFloat32
+ ret.fn = ret.readBoolInt8
return ret
}
-func (v *iterNative) readETByteSliceFloat32(et *typex.EventTime, key *[]byte, value *float32) bool {
+func (v *iterNative) readBoolInt16(key *bool, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1655,20 +1121,18 @@ func (v *iterNative) readETByteSliceFloat32(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETByteSliceFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceFloat32
+ ret.fn = ret.readBoolInt16
return ret
}
-func (v *iterNative) readByteSliceFloat64(key *[]byte, value *float64) bool {
+func (v *iterNative) readBoolInt32(key *bool, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1676,18 +1140,18 @@ func (v *iterNative) readByteSliceFloat64(key *[]byte, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerByteSliceFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceFloat64
+ ret.fn = ret.readBoolInt32
return ret
}
-func (v *iterNative) readETByteSliceFloat64(et *typex.EventTime, key *[]byte, value *float64) bool {
+func (v *iterNative) readBoolInt64(key *bool, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1695,20 +1159,18 @@ func (v *iterNative) readETByteSliceFloat64(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETByteSliceFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceFloat64
+ ret.fn = ret.readBoolInt64
return ret
}
-func (v *iterNative) readByteSliceTypex_T(key *[]byte, value *typex.T) bool {
+func (v *iterNative) readBoolUint(key *bool, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1716,18 +1178,18 @@ func (v *iterNative) readByteSliceTypex_T(key *[]byte, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerByteSliceTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_T
+ ret.fn = ret.readBoolUint
return ret
}
-func (v *iterNative) readETByteSliceTypex_T(et *typex.EventTime, key *[]byte, value *typex.T) bool {
+func (v *iterNative) readBoolUint8(key *bool, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1735,20 +1197,18 @@ func (v *iterNative) readETByteSliceTypex_T(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETByteSliceTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_T
+ ret.fn = ret.readBoolUint8
return ret
}
-func (v *iterNative) readByteSliceTypex_U(key *[]byte, value *typex.U) bool {
+func (v *iterNative) readBoolUint16(key *bool, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1756,18 +1216,18 @@ func (v *iterNative) readByteSliceTypex_U(key *[]byte, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerByteSliceTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_U
+ ret.fn = ret.readBoolUint16
return ret
}
-func (v *iterNative) readETByteSliceTypex_U(et *typex.EventTime, key *[]byte, value *typex.U) bool {
+func (v *iterNative) readBoolUint32(key *bool, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1775,20 +1235,18 @@ func (v *iterNative) readETByteSliceTypex_U(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETByteSliceTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_U
+ ret.fn = ret.readBoolUint32
return ret
}
-func (v *iterNative) readByteSliceTypex_V(key *[]byte, value *typex.V) bool {
+func (v *iterNative) readBoolUint64(key *bool, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1796,18 +1254,18 @@ func (v *iterNative) readByteSliceTypex_V(key *[]byte, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerByteSliceTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_V
+ ret.fn = ret.readBoolUint64
return ret
}
-func (v *iterNative) readETByteSliceTypex_V(et *typex.EventTime, key *[]byte, value *typex.V) bool {
+func (v *iterNative) readBoolFloat32(key *bool, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1815,20 +1273,18 @@ func (v *iterNative) readETByteSliceTypex_V(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETByteSliceTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_V
+ ret.fn = ret.readBoolFloat32
return ret
}
-func (v *iterNative) readByteSliceTypex_W(key *[]byte, value *typex.W) bool {
+func (v *iterNative) readBoolFloat64(key *bool, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1836,18 +1292,18 @@ func (v *iterNative) readByteSliceTypex_W(key *[]byte, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerByteSliceTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_W
+ ret.fn = ret.readBoolFloat64
return ret
}
-func (v *iterNative) readETByteSliceTypex_W(et *typex.EventTime, key *[]byte, value *typex.W) bool {
+func (v *iterNative) readBoolTypex_T(key *bool, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1855,20 +1311,18 @@ func (v *iterNative) readETByteSliceTypex_W(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETByteSliceTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_W
+ ret.fn = ret.readBoolTypex_T
return ret
}
-func (v *iterNative) readByteSliceTypex_X(key *[]byte, value *typex.X) bool {
+func (v *iterNative) readBoolTypex_U(key *bool, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1876,18 +1330,18 @@ func (v *iterNative) readByteSliceTypex_X(key *[]byte, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerByteSliceTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_X
+ ret.fn = ret.readBoolTypex_U
return ret
}
-func (v *iterNative) readETByteSliceTypex_X(et *typex.EventTime, key *[]byte, value *typex.X) bool {
+func (v *iterNative) readBoolTypex_V(key *bool, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1895,20 +1349,18 @@ func (v *iterNative) readETByteSliceTypex_X(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETByteSliceTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_X
+ ret.fn = ret.readBoolTypex_V
return ret
}
-func (v *iterNative) readByteSliceTypex_Y(key *[]byte, value *typex.Y) bool {
+func (v *iterNative) readBoolTypex_W(key *bool, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1916,18 +1368,18 @@ func (v *iterNative) readByteSliceTypex_Y(key *[]byte, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerByteSliceTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_Y
+ ret.fn = ret.readBoolTypex_W
return ret
}
-func (v *iterNative) readETByteSliceTypex_Y(et *typex.EventTime, key *[]byte, value *typex.Y) bool {
+func (v *iterNative) readBoolTypex_X(key *bool, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1935,20 +1387,18 @@ func (v *iterNative) readETByteSliceTypex_Y(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETByteSliceTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_Y
+ ret.fn = ret.readBoolTypex_X
return ret
}
-func (v *iterNative) readByteSliceTypex_Z(key *[]byte, value *typex.Z) bool {
+func (v *iterNative) readBoolTypex_Y(key *bool, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1956,18 +1406,18 @@ func (v *iterNative) readByteSliceTypex_Z(key *[]byte, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.([]byte)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(bool)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerByteSliceTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readByteSliceTypex_Z
+ ret.fn = ret.readBoolTypex_Y
return ret
}
-func (v *iterNative) readETByteSliceTypex_Z(et *typex.EventTime, key *[]byte, value *typex.Z) bool {
+func (v *iterNative) readBoolTypex_Z(key *bool, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1975,20 +1425,18 @@ func (v *iterNative) readETByteSliceTypex_Z(et *typex.EventTime, key *[]byte, va
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.([]byte)
+ *key = elm.Elm.(bool)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETByteSliceTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerBoolTypex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETByteSliceTypex_Z
+ ret.fn = ret.readBoolTypex_Z
return ret
}
-func (v *iterNative) readBool(val *bool) bool {
+func (v *iterNative) readString(val *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -1996,17 +1444,17 @@ func (v *iterNative) readBool(val *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(bool)
+ *val = elm.Elm.(string)
return true
}
-func iterMakerBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBool
+ ret.fn = ret.readString
return ret
}
-func (v *iterNative) readETBool(et *typex.EventTime, val *bool) bool {
+func (v *iterNative) readStringByteSlice(key *string, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2014,19 +1462,18 @@ func (v *iterNative) readETBool(et *typex.EventTime, val *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(bool)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBool
+ ret.fn = ret.readStringByteSlice
return ret
}
-func (v *iterNative) readBoolByteSlice(key *bool, value *[]byte) bool {
+func (v *iterNative) readStringBool(key *string, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2034,18 +1481,18 @@ func (v *iterNative) readBoolByteSlice(key *bool, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerBoolByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolByteSlice
+ ret.fn = ret.readStringBool
return ret
}
-func (v *iterNative) readETBoolByteSlice(et *typex.EventTime, key *bool, value *[]byte) bool {
+func (v *iterNative) readStringString(key *string, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2053,20 +1500,18 @@ func (v *iterNative) readETBoolByteSlice(et *typex.EventTime, key *bool, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETBoolByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolByteSlice
+ ret.fn = ret.readStringString
return ret
}
-func (v *iterNative) readBoolBool(key *bool, value *bool) bool {
+func (v *iterNative) readStringInt(key *string, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2074,18 +1519,18 @@ func (v *iterNative) readBoolBool(key *bool, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerBoolBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolBool
+ ret.fn = ret.readStringInt
return ret
}
-func (v *iterNative) readETBoolBool(et *typex.EventTime, key *bool, value *bool) bool {
+func (v *iterNative) readStringInt8(key *string, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2093,20 +1538,18 @@ func (v *iterNative) readETBoolBool(et *typex.EventTime, key *bool, value *bool)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETBoolBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolBool
+ ret.fn = ret.readStringInt8
return ret
}
-func (v *iterNative) readBoolString(key *bool, value *string) bool {
+func (v *iterNative) readStringInt16(key *string, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2114,18 +1557,18 @@ func (v *iterNative) readBoolString(key *bool, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerBoolString(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolString
+ ret.fn = ret.readStringInt16
return ret
}
-func (v *iterNative) readETBoolString(et *typex.EventTime, key *bool, value *string) bool {
+func (v *iterNative) readStringInt32(key *string, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2133,20 +1576,18 @@ func (v *iterNative) readETBoolString(et *typex.EventTime, key *bool, value *str
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETBoolString(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolString
+ ret.fn = ret.readStringInt32
return ret
}
-func (v *iterNative) readBoolInt(key *bool, value *int) bool {
+func (v *iterNative) readStringInt64(key *string, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2154,18 +1595,18 @@ func (v *iterNative) readBoolInt(key *bool, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerBoolInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolInt
+ ret.fn = ret.readStringInt64
return ret
}
-func (v *iterNative) readETBoolInt(et *typex.EventTime, key *bool, value *int) bool {
+func (v *iterNative) readStringUint(key *string, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2173,20 +1614,18 @@ func (v *iterNative) readETBoolInt(et *typex.EventTime, key *bool, value *int) b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETBoolInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolInt
+ ret.fn = ret.readStringUint
return ret
}
-func (v *iterNative) readBoolInt8(key *bool, value *int8) bool {
+func (v *iterNative) readStringUint8(key *string, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2194,18 +1633,18 @@ func (v *iterNative) readBoolInt8(key *bool, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerBoolInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolInt8
+ ret.fn = ret.readStringUint8
return ret
}
-func (v *iterNative) readETBoolInt8(et *typex.EventTime, key *bool, value *int8) bool {
+func (v *iterNative) readStringUint16(key *string, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2213,20 +1652,18 @@ func (v *iterNative) readETBoolInt8(et *typex.EventTime, key *bool, value *int8)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETBoolInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolInt8
+ ret.fn = ret.readStringUint16
return ret
}
-func (v *iterNative) readBoolInt16(key *bool, value *int16) bool {
+func (v *iterNative) readStringUint32(key *string, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2234,18 +1671,18 @@ func (v *iterNative) readBoolInt16(key *bool, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerBoolInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolInt16
+ ret.fn = ret.readStringUint32
return ret
}
-func (v *iterNative) readETBoolInt16(et *typex.EventTime, key *bool, value *int16) bool {
+func (v *iterNative) readStringUint64(key *string, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2253,20 +1690,18 @@ func (v *iterNative) readETBoolInt16(et *typex.EventTime, key *bool, value *int1
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETBoolInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolInt16
+ ret.fn = ret.readStringUint64
return ret
}
-func (v *iterNative) readBoolInt32(key *bool, value *int32) bool {
+func (v *iterNative) readStringFloat32(key *string, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2274,18 +1709,18 @@ func (v *iterNative) readBoolInt32(key *bool, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerBoolInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolInt32
+ ret.fn = ret.readStringFloat32
return ret
}
-func (v *iterNative) readETBoolInt32(et *typex.EventTime, key *bool, value *int32) bool {
+func (v *iterNative) readStringFloat64(key *string, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2293,20 +1728,18 @@ func (v *iterNative) readETBoolInt32(et *typex.EventTime, key *bool, value *int3
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETBoolInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolInt32
+ ret.fn = ret.readStringFloat64
return ret
}
-func (v *iterNative) readBoolInt64(key *bool, value *int64) bool {
+func (v *iterNative) readStringTypex_T(key *string, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2314,18 +1747,18 @@ func (v *iterNative) readBoolInt64(key *bool, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerBoolInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolInt64
+ ret.fn = ret.readStringTypex_T
return ret
}
-func (v *iterNative) readETBoolInt64(et *typex.EventTime, key *bool, value *int64) bool {
+func (v *iterNative) readStringTypex_U(key *string, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2333,20 +1766,18 @@ func (v *iterNative) readETBoolInt64(et *typex.EventTime, key *bool, value *int6
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETBoolInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolInt64
+ ret.fn = ret.readStringTypex_U
return ret
}
-func (v *iterNative) readBoolUint(key *bool, value *uint) bool {
+func (v *iterNative) readStringTypex_V(key *string, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2354,18 +1785,18 @@ func (v *iterNative) readBoolUint(key *bool, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerBoolUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolUint
+ ret.fn = ret.readStringTypex_V
return ret
}
-func (v *iterNative) readETBoolUint(et *typex.EventTime, key *bool, value *uint) bool {
+func (v *iterNative) readStringTypex_W(key *string, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2373,20 +1804,18 @@ func (v *iterNative) readETBoolUint(et *typex.EventTime, key *bool, value *uint)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETBoolUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolUint
+ ret.fn = ret.readStringTypex_W
return ret
}
-func (v *iterNative) readBoolUint8(key *bool, value *uint8) bool {
+func (v *iterNative) readStringTypex_X(key *string, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2394,18 +1823,18 @@ func (v *iterNative) readBoolUint8(key *bool, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerBoolUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolUint8
+ ret.fn = ret.readStringTypex_X
return ret
}
-func (v *iterNative) readETBoolUint8(et *typex.EventTime, key *bool, value *uint8) bool {
+func (v *iterNative) readStringTypex_Y(key *string, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2413,20 +1842,18 @@ func (v *iterNative) readETBoolUint8(et *typex.EventTime, key *bool, value *uint
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETBoolUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolUint8
+ ret.fn = ret.readStringTypex_Y
return ret
}
-func (v *iterNative) readBoolUint16(key *bool, value *uint16) bool {
+func (v *iterNative) readStringTypex_Z(key *string, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2434,18 +1861,18 @@ func (v *iterNative) readBoolUint16(key *bool, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(string)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerBoolUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerStringTypex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolUint16
+ ret.fn = ret.readStringTypex_Z
return ret
}
-func (v *iterNative) readETBoolUint16(et *typex.EventTime, key *bool, value *uint16) bool {
+func (v *iterNative) readInt(val *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2453,20 +1880,17 @@ func (v *iterNative) readETBoolUint16(et *typex.EventTime, key *bool, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(int)
return true
}
-func iterMakerETBoolUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolUint16
+ ret.fn = ret.readInt
return ret
}
-func (v *iterNative) readBoolUint32(key *bool, value *uint32) bool {
+func (v *iterNative) readIntByteSlice(key *int, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2474,18 +1898,18 @@ func (v *iterNative) readBoolUint32(key *bool, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerBoolUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolUint32
+ ret.fn = ret.readIntByteSlice
return ret
}
-func (v *iterNative) readETBoolUint32(et *typex.EventTime, key *bool, value *uint32) bool {
+func (v *iterNative) readIntBool(key *int, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2493,20 +1917,18 @@ func (v *iterNative) readETBoolUint32(et *typex.EventTime, key *bool, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETBoolUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolUint32
+ ret.fn = ret.readIntBool
return ret
}
-func (v *iterNative) readBoolUint64(key *bool, value *uint64) bool {
+func (v *iterNative) readIntString(key *int, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2514,18 +1936,18 @@ func (v *iterNative) readBoolUint64(key *bool, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerBoolUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolUint64
+ ret.fn = ret.readIntString
return ret
}
-func (v *iterNative) readETBoolUint64(et *typex.EventTime, key *bool, value *uint64) bool {
+func (v *iterNative) readIntInt(key *int, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2533,20 +1955,18 @@ func (v *iterNative) readETBoolUint64(et *typex.EventTime, key *bool, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETBoolUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolUint64
+ ret.fn = ret.readIntInt
return ret
}
-func (v *iterNative) readBoolFloat32(key *bool, value *float32) bool {
+func (v *iterNative) readIntInt8(key *int, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2554,18 +1974,18 @@ func (v *iterNative) readBoolFloat32(key *bool, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerBoolFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolFloat32
+ ret.fn = ret.readIntInt8
return ret
}
-func (v *iterNative) readETBoolFloat32(et *typex.EventTime, key *bool, value *float32) bool {
+func (v *iterNative) readIntInt16(key *int, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2573,20 +1993,18 @@ func (v *iterNative) readETBoolFloat32(et *typex.EventTime, key *bool, value *fl
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETBoolFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolFloat32
+ ret.fn = ret.readIntInt16
return ret
}
-func (v *iterNative) readBoolFloat64(key *bool, value *float64) bool {
+func (v *iterNative) readIntInt32(key *int, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2594,18 +2012,18 @@ func (v *iterNative) readBoolFloat64(key *bool, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerBoolFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolFloat64
+ ret.fn = ret.readIntInt32
return ret
}
-func (v *iterNative) readETBoolFloat64(et *typex.EventTime, key *bool, value *float64) bool {
+func (v *iterNative) readIntInt64(key *int, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2613,20 +2031,18 @@ func (v *iterNative) readETBoolFloat64(et *typex.EventTime, key *bool, value *fl
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETBoolFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolFloat64
+ ret.fn = ret.readIntInt64
return ret
}
-func (v *iterNative) readBoolTypex_T(key *bool, value *typex.T) bool {
+func (v *iterNative) readIntUint(key *int, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2634,18 +2050,18 @@ func (v *iterNative) readBoolTypex_T(key *bool, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerBoolTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_T
+ ret.fn = ret.readIntUint
return ret
}
-func (v *iterNative) readETBoolTypex_T(et *typex.EventTime, key *bool, value *typex.T) bool {
+func (v *iterNative) readIntUint8(key *int, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2653,20 +2069,18 @@ func (v *iterNative) readETBoolTypex_T(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETBoolTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_T
+ ret.fn = ret.readIntUint8
return ret
}
-func (v *iterNative) readBoolTypex_U(key *bool, value *typex.U) bool {
+func (v *iterNative) readIntUint16(key *int, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2674,18 +2088,18 @@ func (v *iterNative) readBoolTypex_U(key *bool, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerBoolTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_U
+ ret.fn = ret.readIntUint16
return ret
}
-func (v *iterNative) readETBoolTypex_U(et *typex.EventTime, key *bool, value *typex.U) bool {
+func (v *iterNative) readIntUint32(key *int, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2693,20 +2107,18 @@ func (v *iterNative) readETBoolTypex_U(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETBoolTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_U
+ ret.fn = ret.readIntUint32
return ret
}
-func (v *iterNative) readBoolTypex_V(key *bool, value *typex.V) bool {
+func (v *iterNative) readIntUint64(key *int, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2714,18 +2126,18 @@ func (v *iterNative) readBoolTypex_V(key *bool, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerBoolTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_V
+ ret.fn = ret.readIntUint64
return ret
}
-func (v *iterNative) readETBoolTypex_V(et *typex.EventTime, key *bool, value *typex.V) bool {
+func (v *iterNative) readIntFloat32(key *int, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2733,20 +2145,18 @@ func (v *iterNative) readETBoolTypex_V(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETBoolTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_V
+ ret.fn = ret.readIntFloat32
return ret
}
-func (v *iterNative) readBoolTypex_W(key *bool, value *typex.W) bool {
+func (v *iterNative) readIntFloat64(key *int, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2754,18 +2164,18 @@ func (v *iterNative) readBoolTypex_W(key *bool, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerBoolTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_W
+ ret.fn = ret.readIntFloat64
return ret
}
-func (v *iterNative) readETBoolTypex_W(et *typex.EventTime, key *bool, value *typex.W) bool {
+func (v *iterNative) readIntTypex_T(key *int, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2773,20 +2183,18 @@ func (v *iterNative) readETBoolTypex_W(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETBoolTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_W
+ ret.fn = ret.readIntTypex_T
return ret
}
-func (v *iterNative) readBoolTypex_X(key *bool, value *typex.X) bool {
+func (v *iterNative) readIntTypex_U(key *int, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2794,18 +2202,18 @@ func (v *iterNative) readBoolTypex_X(key *bool, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerBoolTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_X
+ ret.fn = ret.readIntTypex_U
return ret
}
-func (v *iterNative) readETBoolTypex_X(et *typex.EventTime, key *bool, value *typex.X) bool {
+func (v *iterNative) readIntTypex_V(key *int, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2813,20 +2221,18 @@ func (v *iterNative) readETBoolTypex_X(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETBoolTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_X
+ ret.fn = ret.readIntTypex_V
return ret
}
-func (v *iterNative) readBoolTypex_Y(key *bool, value *typex.Y) bool {
+func (v *iterNative) readIntTypex_W(key *int, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2834,18 +2240,18 @@ func (v *iterNative) readBoolTypex_Y(key *bool, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerBoolTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_Y
+ ret.fn = ret.readIntTypex_W
return ret
}
-func (v *iterNative) readETBoolTypex_Y(et *typex.EventTime, key *bool, value *typex.Y) bool {
+func (v *iterNative) readIntTypex_X(key *int, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2853,20 +2259,18 @@ func (v *iterNative) readETBoolTypex_Y(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETBoolTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_Y
+ ret.fn = ret.readIntTypex_X
return ret
}
-func (v *iterNative) readBoolTypex_Z(key *bool, value *typex.Z) bool {
+func (v *iterNative) readIntTypex_Y(key *int, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2874,18 +2278,18 @@ func (v *iterNative) readBoolTypex_Z(key *bool, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(bool)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(int)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerBoolTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readBoolTypex_Z
+ ret.fn = ret.readIntTypex_Y
return ret
}
-func (v *iterNative) readETBoolTypex_Z(et *typex.EventTime, key *bool, value *typex.Z) bool {
+func (v *iterNative) readIntTypex_Z(key *int, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2893,20 +2297,18 @@ func (v *iterNative) readETBoolTypex_Z(et *typex.EventTime, key *bool, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(bool)
+ *key = elm.Elm.(int)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETBoolTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerIntTypex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETBoolTypex_Z
+ ret.fn = ret.readIntTypex_Z
return ret
}
-func (v *iterNative) readString(val *string) bool {
+func (v *iterNative) readInt8(val *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2914,17 +2316,17 @@ func (v *iterNative) readString(val *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(string)
+ *val = elm.Elm.(int8)
return true
}
-func iterMakerString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readString
+ ret.fn = ret.readInt8
return ret
}
-func (v *iterNative) readETString(et *typex.EventTime, val *string) bool {
+func (v *iterNative) readInt8ByteSlice(key *int8, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2932,19 +2334,18 @@ func (v *iterNative) readETString(et *typex.EventTime, val *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(string)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETString
+ ret.fn = ret.readInt8ByteSlice
return ret
}
-func (v *iterNative) readStringByteSlice(key *string, value *[]byte) bool {
+func (v *iterNative) readInt8Bool(key *int8, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2952,18 +2353,18 @@ func (v *iterNative) readStringByteSlice(key *string, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerStringByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringByteSlice
+ ret.fn = ret.readInt8Bool
return ret
}
-func (v *iterNative) readETStringByteSlice(et *typex.EventTime, key *string, value *[]byte) bool {
+func (v *iterNative) readInt8String(key *int8, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2971,20 +2372,18 @@ func (v *iterNative) readETStringByteSlice(et *typex.EventTime, key *string, val
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETStringByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringByteSlice
+ ret.fn = ret.readInt8String
return ret
}
-func (v *iterNative) readStringBool(key *string, value *bool) bool {
+func (v *iterNative) readInt8Int(key *int8, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -2992,18 +2391,18 @@ func (v *iterNative) readStringBool(key *string, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerStringBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringBool
+ ret.fn = ret.readInt8Int
return ret
}
-func (v *iterNative) readETStringBool(et *typex.EventTime, key *string, value *bool) bool {
+func (v *iterNative) readInt8Int8(key *int8, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3011,20 +2410,18 @@ func (v *iterNative) readETStringBool(et *typex.EventTime, key *string, value *b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETStringBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringBool
+ ret.fn = ret.readInt8Int8
return ret
}
-func (v *iterNative) readStringString(key *string, value *string) bool {
+func (v *iterNative) readInt8Int16(key *int8, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3032,18 +2429,18 @@ func (v *iterNative) readStringString(key *string, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerStringString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringString
+ ret.fn = ret.readInt8Int16
return ret
}
-func (v *iterNative) readETStringString(et *typex.EventTime, key *string, value *string) bool {
+func (v *iterNative) readInt8Int32(key *int8, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3051,20 +2448,18 @@ func (v *iterNative) readETStringString(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETStringString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringString
+ ret.fn = ret.readInt8Int32
return ret
}
-func (v *iterNative) readStringInt(key *string, value *int) bool {
+func (v *iterNative) readInt8Int64(key *int8, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3072,18 +2467,18 @@ func (v *iterNative) readStringInt(key *string, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerStringInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringInt
+ ret.fn = ret.readInt8Int64
return ret
}
-func (v *iterNative) readETStringInt(et *typex.EventTime, key *string, value *int) bool {
+func (v *iterNative) readInt8Uint(key *int8, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3091,20 +2486,18 @@ func (v *iterNative) readETStringInt(et *typex.EventTime, key *string, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETStringInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringInt
+ ret.fn = ret.readInt8Uint
return ret
}
-func (v *iterNative) readStringInt8(key *string, value *int8) bool {
+func (v *iterNative) readInt8Uint8(key *int8, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3112,18 +2505,18 @@ func (v *iterNative) readStringInt8(key *string, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerStringInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringInt8
+ ret.fn = ret.readInt8Uint8
return ret
}
-func (v *iterNative) readETStringInt8(et *typex.EventTime, key *string, value *int8) bool {
+func (v *iterNative) readInt8Uint16(key *int8, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3131,20 +2524,18 @@ func (v *iterNative) readETStringInt8(et *typex.EventTime, key *string, value *i
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETStringInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringInt8
+ ret.fn = ret.readInt8Uint16
return ret
}
-func (v *iterNative) readStringInt16(key *string, value *int16) bool {
+func (v *iterNative) readInt8Uint32(key *int8, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3152,18 +2543,18 @@ func (v *iterNative) readStringInt16(key *string, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerStringInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringInt16
+ ret.fn = ret.readInt8Uint32
return ret
}
-func (v *iterNative) readETStringInt16(et *typex.EventTime, key *string, value *int16) bool {
+func (v *iterNative) readInt8Uint64(key *int8, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3171,20 +2562,18 @@ func (v *iterNative) readETStringInt16(et *typex.EventTime, key *string, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETStringInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringInt16
+ ret.fn = ret.readInt8Uint64
return ret
}
-func (v *iterNative) readStringInt32(key *string, value *int32) bool {
+func (v *iterNative) readInt8Float32(key *int8, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3192,18 +2581,18 @@ func (v *iterNative) readStringInt32(key *string, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerStringInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringInt32
+ ret.fn = ret.readInt8Float32
return ret
}
-func (v *iterNative) readETStringInt32(et *typex.EventTime, key *string, value *int32) bool {
+func (v *iterNative) readInt8Float64(key *int8, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3211,20 +2600,18 @@ func (v *iterNative) readETStringInt32(et *typex.EventTime, key *string, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETStringInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringInt32
+ ret.fn = ret.readInt8Float64
return ret
}
-func (v *iterNative) readStringInt64(key *string, value *int64) bool {
+func (v *iterNative) readInt8Typex_T(key *int8, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3232,18 +2619,18 @@ func (v *iterNative) readStringInt64(key *string, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerStringInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringInt64
+ ret.fn = ret.readInt8Typex_T
return ret
}
-func (v *iterNative) readETStringInt64(et *typex.EventTime, key *string, value *int64) bool {
+func (v *iterNative) readInt8Typex_U(key *int8, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3251,20 +2638,18 @@ func (v *iterNative) readETStringInt64(et *typex.EventTime, key *string, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETStringInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringInt64
+ ret.fn = ret.readInt8Typex_U
return ret
}
-func (v *iterNative) readStringUint(key *string, value *uint) bool {
+func (v *iterNative) readInt8Typex_V(key *int8, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3272,18 +2657,18 @@ func (v *iterNative) readStringUint(key *string, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerStringUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringUint
+ ret.fn = ret.readInt8Typex_V
return ret
}
-func (v *iterNative) readETStringUint(et *typex.EventTime, key *string, value *uint) bool {
+func (v *iterNative) readInt8Typex_W(key *int8, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3291,20 +2676,18 @@ func (v *iterNative) readETStringUint(et *typex.EventTime, key *string, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETStringUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringUint
+ ret.fn = ret.readInt8Typex_W
return ret
}
-func (v *iterNative) readStringUint8(key *string, value *uint8) bool {
+func (v *iterNative) readInt8Typex_X(key *int8, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3312,18 +2695,18 @@ func (v *iterNative) readStringUint8(key *string, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerStringUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringUint8
+ ret.fn = ret.readInt8Typex_X
return ret
}
-func (v *iterNative) readETStringUint8(et *typex.EventTime, key *string, value *uint8) bool {
+func (v *iterNative) readInt8Typex_Y(key *int8, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3331,20 +2714,18 @@ func (v *iterNative) readETStringUint8(et *typex.EventTime, key *string, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETStringUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringUint8
+ ret.fn = ret.readInt8Typex_Y
return ret
}
-func (v *iterNative) readStringUint16(key *string, value *uint16) bool {
+func (v *iterNative) readInt8Typex_Z(key *int8, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3352,18 +2733,18 @@ func (v *iterNative) readStringUint16(key *string, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(int8)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerStringUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt8Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringUint16
+ ret.fn = ret.readInt8Typex_Z
return ret
}
-func (v *iterNative) readETStringUint16(et *typex.EventTime, key *string, value *uint16) bool {
+func (v *iterNative) readInt16(val *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3371,20 +2752,17 @@ func (v *iterNative) readETStringUint16(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(int16)
return true
}
-func iterMakerETStringUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringUint16
+ ret.fn = ret.readInt16
return ret
}
-func (v *iterNative) readStringUint32(key *string, value *uint32) bool {
+func (v *iterNative) readInt16ByteSlice(key *int16, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3392,18 +2770,18 @@ func (v *iterNative) readStringUint32(key *string, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerStringUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringUint32
+ ret.fn = ret.readInt16ByteSlice
return ret
}
-func (v *iterNative) readETStringUint32(et *typex.EventTime, key *string, value *uint32) bool {
+func (v *iterNative) readInt16Bool(key *int16, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3411,20 +2789,18 @@ func (v *iterNative) readETStringUint32(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETStringUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringUint32
+ ret.fn = ret.readInt16Bool
return ret
}
-func (v *iterNative) readStringUint64(key *string, value *uint64) bool {
+func (v *iterNative) readInt16String(key *int16, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3432,18 +2808,18 @@ func (v *iterNative) readStringUint64(key *string, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerStringUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringUint64
+ ret.fn = ret.readInt16String
return ret
}
-func (v *iterNative) readETStringUint64(et *typex.EventTime, key *string, value *uint64) bool {
+func (v *iterNative) readInt16Int(key *int16, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3451,20 +2827,18 @@ func (v *iterNative) readETStringUint64(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETStringUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringUint64
+ ret.fn = ret.readInt16Int
return ret
}
-func (v *iterNative) readStringFloat32(key *string, value *float32) bool {
+func (v *iterNative) readInt16Int8(key *int16, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3472,18 +2846,18 @@ func (v *iterNative) readStringFloat32(key *string, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerStringFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringFloat32
+ ret.fn = ret.readInt16Int8
return ret
}
-func (v *iterNative) readETStringFloat32(et *typex.EventTime, key *string, value *float32) bool {
+func (v *iterNative) readInt16Int16(key *int16, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3491,20 +2865,18 @@ func (v *iterNative) readETStringFloat32(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETStringFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringFloat32
+ ret.fn = ret.readInt16Int16
return ret
}
-func (v *iterNative) readStringFloat64(key *string, value *float64) bool {
+func (v *iterNative) readInt16Int32(key *int16, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3512,18 +2884,18 @@ func (v *iterNative) readStringFloat64(key *string, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerStringFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringFloat64
+ ret.fn = ret.readInt16Int32
return ret
}
-func (v *iterNative) readETStringFloat64(et *typex.EventTime, key *string, value *float64) bool {
+func (v *iterNative) readInt16Int64(key *int16, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3531,20 +2903,18 @@ func (v *iterNative) readETStringFloat64(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETStringFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringFloat64
+ ret.fn = ret.readInt16Int64
return ret
}
-func (v *iterNative) readStringTypex_T(key *string, value *typex.T) bool {
+func (v *iterNative) readInt16Uint(key *int16, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3552,18 +2922,18 @@ func (v *iterNative) readStringTypex_T(key *string, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerStringTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_T
+ ret.fn = ret.readInt16Uint
return ret
}
-func (v *iterNative) readETStringTypex_T(et *typex.EventTime, key *string, value *typex.T) bool {
+func (v *iterNative) readInt16Uint8(key *int16, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3571,20 +2941,18 @@ func (v *iterNative) readETStringTypex_T(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETStringTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_T
+ ret.fn = ret.readInt16Uint8
return ret
}
-func (v *iterNative) readStringTypex_U(key *string, value *typex.U) bool {
+func (v *iterNative) readInt16Uint16(key *int16, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3592,18 +2960,18 @@ func (v *iterNative) readStringTypex_U(key *string, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerStringTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_U
+ ret.fn = ret.readInt16Uint16
return ret
}
-func (v *iterNative) readETStringTypex_U(et *typex.EventTime, key *string, value *typex.U) bool {
+func (v *iterNative) readInt16Uint32(key *int16, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3611,20 +2979,18 @@ func (v *iterNative) readETStringTypex_U(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETStringTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_U
+ ret.fn = ret.readInt16Uint32
return ret
}
-func (v *iterNative) readStringTypex_V(key *string, value *typex.V) bool {
+func (v *iterNative) readInt16Uint64(key *int16, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3632,18 +2998,18 @@ func (v *iterNative) readStringTypex_V(key *string, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerStringTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_V
+ ret.fn = ret.readInt16Uint64
return ret
}
-func (v *iterNative) readETStringTypex_V(et *typex.EventTime, key *string, value *typex.V) bool {
+func (v *iterNative) readInt16Float32(key *int16, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3651,20 +3017,18 @@ func (v *iterNative) readETStringTypex_V(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETStringTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_V
+ ret.fn = ret.readInt16Float32
return ret
}
-func (v *iterNative) readStringTypex_W(key *string, value *typex.W) bool {
+func (v *iterNative) readInt16Float64(key *int16, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3672,18 +3036,18 @@ func (v *iterNative) readStringTypex_W(key *string, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerStringTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_W
+ ret.fn = ret.readInt16Float64
return ret
}
-func (v *iterNative) readETStringTypex_W(et *typex.EventTime, key *string, value *typex.W) bool {
+func (v *iterNative) readInt16Typex_T(key *int16, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3691,20 +3055,18 @@ func (v *iterNative) readETStringTypex_W(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETStringTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_W
+ ret.fn = ret.readInt16Typex_T
return ret
}
-func (v *iterNative) readStringTypex_X(key *string, value *typex.X) bool {
+func (v *iterNative) readInt16Typex_U(key *int16, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3712,18 +3074,18 @@ func (v *iterNative) readStringTypex_X(key *string, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerStringTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_X
+ ret.fn = ret.readInt16Typex_U
return ret
}
-func (v *iterNative) readETStringTypex_X(et *typex.EventTime, key *string, value *typex.X) bool {
+func (v *iterNative) readInt16Typex_V(key *int16, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3731,20 +3093,18 @@ func (v *iterNative) readETStringTypex_X(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETStringTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_X
+ ret.fn = ret.readInt16Typex_V
return ret
}
-func (v *iterNative) readStringTypex_Y(key *string, value *typex.Y) bool {
+func (v *iterNative) readInt16Typex_W(key *int16, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3752,18 +3112,18 @@ func (v *iterNative) readStringTypex_Y(key *string, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerStringTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_Y
+ ret.fn = ret.readInt16Typex_W
return ret
}
-func (v *iterNative) readETStringTypex_Y(et *typex.EventTime, key *string, value *typex.Y) bool {
+func (v *iterNative) readInt16Typex_X(key *int16, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3771,20 +3131,18 @@ func (v *iterNative) readETStringTypex_Y(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETStringTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_Y
+ ret.fn = ret.readInt16Typex_X
return ret
}
-func (v *iterNative) readStringTypex_Z(key *string, value *typex.Z) bool {
+func (v *iterNative) readInt16Typex_Y(key *int16, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3792,18 +3150,18 @@ func (v *iterNative) readStringTypex_Z(key *string, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(string)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(int16)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerStringTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readStringTypex_Z
+ ret.fn = ret.readInt16Typex_Y
return ret
}
-func (v *iterNative) readETStringTypex_Z(et *typex.EventTime, key *string, value *typex.Z) bool {
+func (v *iterNative) readInt16Typex_Z(key *int16, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3811,20 +3169,18 @@ func (v *iterNative) readETStringTypex_Z(et *typex.EventTime, key *string, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(string)
+ *key = elm.Elm.(int16)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETStringTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt16Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETStringTypex_Z
+ ret.fn = ret.readInt16Typex_Z
return ret
}
-func (v *iterNative) readInt(val *int) bool {
+func (v *iterNative) readInt32(val *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3832,17 +3188,17 @@ func (v *iterNative) readInt(val *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(int)
+ *val = elm.Elm.(int32)
return true
}
-func iterMakerInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt
+ ret.fn = ret.readInt32
return ret
}
-func (v *iterNative) readETInt(et *typex.EventTime, val *int) bool {
+func (v *iterNative) readInt32ByteSlice(key *int32, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3850,19 +3206,18 @@ func (v *iterNative) readETInt(et *typex.EventTime, val *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(int)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt
+ ret.fn = ret.readInt32ByteSlice
return ret
}
-func (v *iterNative) readIntByteSlice(key *int, value *[]byte) bool {
+func (v *iterNative) readInt32Bool(key *int32, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3870,18 +3225,18 @@ func (v *iterNative) readIntByteSlice(key *int, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerIntByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntByteSlice
+ ret.fn = ret.readInt32Bool
return ret
}
-func (v *iterNative) readETIntByteSlice(et *typex.EventTime, key *int, value *[]byte) bool {
+func (v *iterNative) readInt32String(key *int32, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3889,20 +3244,18 @@ func (v *iterNative) readETIntByteSlice(et *typex.EventTime, key *int, value *[]
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETIntByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntByteSlice
+ ret.fn = ret.readInt32String
return ret
}
-func (v *iterNative) readIntBool(key *int, value *bool) bool {
+func (v *iterNative) readInt32Int(key *int32, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3910,18 +3263,18 @@ func (v *iterNative) readIntBool(key *int, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerIntBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntBool
+ ret.fn = ret.readInt32Int
return ret
}
-func (v *iterNative) readETIntBool(et *typex.EventTime, key *int, value *bool) bool {
+func (v *iterNative) readInt32Int8(key *int32, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3929,20 +3282,18 @@ func (v *iterNative) readETIntBool(et *typex.EventTime, key *int, value *bool) b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETIntBool(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntBool
+ ret.fn = ret.readInt32Int8
return ret
}
-func (v *iterNative) readIntString(key *int, value *string) bool {
+func (v *iterNative) readInt32Int16(key *int32, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3950,18 +3301,18 @@ func (v *iterNative) readIntString(key *int, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerIntString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntString
+ ret.fn = ret.readInt32Int16
return ret
}
-func (v *iterNative) readETIntString(et *typex.EventTime, key *int, value *string) bool {
+func (v *iterNative) readInt32Int32(key *int32, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3969,20 +3320,18 @@ func (v *iterNative) readETIntString(et *typex.EventTime, key *int, value *strin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETIntString(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntString
+ ret.fn = ret.readInt32Int32
return ret
}
-func (v *iterNative) readIntInt(key *int, value *int) bool {
+func (v *iterNative) readInt32Int64(key *int32, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -3990,18 +3339,18 @@ func (v *iterNative) readIntInt(key *int, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerIntInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntInt
+ ret.fn = ret.readInt32Int64
return ret
}
-func (v *iterNative) readETIntInt(et *typex.EventTime, key *int, value *int) bool {
+func (v *iterNative) readInt32Uint(key *int32, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4009,20 +3358,18 @@ func (v *iterNative) readETIntInt(et *typex.EventTime, key *int, value *int) boo
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETIntInt(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntInt
+ ret.fn = ret.readInt32Uint
return ret
}
-func (v *iterNative) readIntInt8(key *int, value *int8) bool {
+func (v *iterNative) readInt32Uint8(key *int32, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4030,18 +3377,18 @@ func (v *iterNative) readIntInt8(key *int, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerIntInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntInt8
+ ret.fn = ret.readInt32Uint8
return ret
}
-func (v *iterNative) readETIntInt8(et *typex.EventTime, key *int, value *int8) bool {
+func (v *iterNative) readInt32Uint16(key *int32, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4049,20 +3396,18 @@ func (v *iterNative) readETIntInt8(et *typex.EventTime, key *int, value *int8) b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETIntInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntInt8
+ ret.fn = ret.readInt32Uint16
return ret
}
-func (v *iterNative) readIntInt16(key *int, value *int16) bool {
+func (v *iterNative) readInt32Uint32(key *int32, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4070,18 +3415,18 @@ func (v *iterNative) readIntInt16(key *int, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerIntInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntInt16
+ ret.fn = ret.readInt32Uint32
return ret
}
-func (v *iterNative) readETIntInt16(et *typex.EventTime, key *int, value *int16) bool {
+func (v *iterNative) readInt32Uint64(key *int32, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4089,20 +3434,18 @@ func (v *iterNative) readETIntInt16(et *typex.EventTime, key *int, value *int16)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETIntInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntInt16
+ ret.fn = ret.readInt32Uint64
return ret
}
-func (v *iterNative) readIntInt32(key *int, value *int32) bool {
+func (v *iterNative) readInt32Float32(key *int32, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4110,18 +3453,18 @@ func (v *iterNative) readIntInt32(key *int, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerIntInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntInt32
+ ret.fn = ret.readInt32Float32
return ret
}
-func (v *iterNative) readETIntInt32(et *typex.EventTime, key *int, value *int32) bool {
+func (v *iterNative) readInt32Float64(key *int32, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4129,20 +3472,18 @@ func (v *iterNative) readETIntInt32(et *typex.EventTime, key *int, value *int32)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETIntInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntInt32
+ ret.fn = ret.readInt32Float64
return ret
}
-func (v *iterNative) readIntInt64(key *int, value *int64) bool {
+func (v *iterNative) readInt32Typex_T(key *int32, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4150,18 +3491,18 @@ func (v *iterNative) readIntInt64(key *int, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerIntInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntInt64
+ ret.fn = ret.readInt32Typex_T
return ret
}
-func (v *iterNative) readETIntInt64(et *typex.EventTime, key *int, value *int64) bool {
+func (v *iterNative) readInt32Typex_U(key *int32, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4169,20 +3510,18 @@ func (v *iterNative) readETIntInt64(et *typex.EventTime, key *int, value *int64)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETIntInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntInt64
+ ret.fn = ret.readInt32Typex_U
return ret
}
-func (v *iterNative) readIntUint(key *int, value *uint) bool {
+func (v *iterNative) readInt32Typex_V(key *int32, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4190,18 +3529,18 @@ func (v *iterNative) readIntUint(key *int, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerIntUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntUint
+ ret.fn = ret.readInt32Typex_V
return ret
}
-func (v *iterNative) readETIntUint(et *typex.EventTime, key *int, value *uint) bool {
+func (v *iterNative) readInt32Typex_W(key *int32, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4209,20 +3548,18 @@ func (v *iterNative) readETIntUint(et *typex.EventTime, key *int, value *uint) b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETIntUint(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntUint
+ ret.fn = ret.readInt32Typex_W
return ret
}
-func (v *iterNative) readIntUint8(key *int, value *uint8) bool {
+func (v *iterNative) readInt32Typex_X(key *int32, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4230,18 +3567,18 @@ func (v *iterNative) readIntUint8(key *int, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerIntUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntUint8
+ ret.fn = ret.readInt32Typex_X
return ret
}
-func (v *iterNative) readETIntUint8(et *typex.EventTime, key *int, value *uint8) bool {
+func (v *iterNative) readInt32Typex_Y(key *int32, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4249,20 +3586,18 @@ func (v *iterNative) readETIntUint8(et *typex.EventTime, key *int, value *uint8)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETIntUint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntUint8
+ ret.fn = ret.readInt32Typex_Y
return ret
}
-func (v *iterNative) readIntUint16(key *int, value *uint16) bool {
+func (v *iterNative) readInt32Typex_Z(key *int32, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4270,18 +3605,18 @@ func (v *iterNative) readIntUint16(key *int, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(int32)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerIntUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt32Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntUint16
+ ret.fn = ret.readInt32Typex_Z
return ret
}
-func (v *iterNative) readETIntUint16(et *typex.EventTime, key *int, value *uint16) bool {
+func (v *iterNative) readInt64(val *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4289,20 +3624,17 @@ func (v *iterNative) readETIntUint16(et *typex.EventTime, key *int, value *uint1
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(int64)
return true
}
-func iterMakerETIntUint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntUint16
+ ret.fn = ret.readInt64
return ret
}
-func (v *iterNative) readIntUint32(key *int, value *uint32) bool {
+func (v *iterNative) readInt64ByteSlice(key *int64, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4310,18 +3642,18 @@ func (v *iterNative) readIntUint32(key *int, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerIntUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntUint32
+ ret.fn = ret.readInt64ByteSlice
return ret
}
-func (v *iterNative) readETIntUint32(et *typex.EventTime, key *int, value *uint32) bool {
+func (v *iterNative) readInt64Bool(key *int64, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4329,20 +3661,18 @@ func (v *iterNative) readETIntUint32(et *typex.EventTime, key *int, value *uint3
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETIntUint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntUint32
+ ret.fn = ret.readInt64Bool
return ret
}
-func (v *iterNative) readIntUint64(key *int, value *uint64) bool {
+func (v *iterNative) readInt64String(key *int64, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4350,18 +3680,18 @@ func (v *iterNative) readIntUint64(key *int, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerIntUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntUint64
+ ret.fn = ret.readInt64String
return ret
}
-func (v *iterNative) readETIntUint64(et *typex.EventTime, key *int, value *uint64) bool {
+func (v *iterNative) readInt64Int(key *int64, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4369,20 +3699,18 @@ func (v *iterNative) readETIntUint64(et *typex.EventTime, key *int, value *uint6
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETIntUint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntUint64
+ ret.fn = ret.readInt64Int
return ret
}
-func (v *iterNative) readIntFloat32(key *int, value *float32) bool {
+func (v *iterNative) readInt64Int8(key *int64, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4390,18 +3718,18 @@ func (v *iterNative) readIntFloat32(key *int, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerIntFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntFloat32
+ ret.fn = ret.readInt64Int8
return ret
}
-func (v *iterNative) readETIntFloat32(et *typex.EventTime, key *int, value *float32) bool {
+func (v *iterNative) readInt64Int16(key *int64, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4409,20 +3737,18 @@ func (v *iterNative) readETIntFloat32(et *typex.EventTime, key *int, value *floa
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETIntFloat32(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntFloat32
+ ret.fn = ret.readInt64Int16
return ret
}
-func (v *iterNative) readIntFloat64(key *int, value *float64) bool {
+func (v *iterNative) readInt64Int32(key *int64, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4430,18 +3756,18 @@ func (v *iterNative) readIntFloat64(key *int, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerIntFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntFloat64
+ ret.fn = ret.readInt64Int32
return ret
}
-func (v *iterNative) readETIntFloat64(et *typex.EventTime, key *int, value *float64) bool {
+func (v *iterNative) readInt64Int64(key *int64, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4449,20 +3775,18 @@ func (v *iterNative) readETIntFloat64(et *typex.EventTime, key *int, value *floa
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETIntFloat64(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntFloat64
+ ret.fn = ret.readInt64Int64
return ret
}
-func (v *iterNative) readIntTypex_T(key *int, value *typex.T) bool {
+func (v *iterNative) readInt64Uint(key *int64, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4470,18 +3794,18 @@ func (v *iterNative) readIntTypex_T(key *int, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerIntTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_T
+ ret.fn = ret.readInt64Uint
return ret
}
-func (v *iterNative) readETIntTypex_T(et *typex.EventTime, key *int, value *typex.T) bool {
+func (v *iterNative) readInt64Uint8(key *int64, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4489,20 +3813,18 @@ func (v *iterNative) readETIntTypex_T(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETIntTypex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_T
+ ret.fn = ret.readInt64Uint8
return ret
}
-func (v *iterNative) readIntTypex_U(key *int, value *typex.U) bool {
+func (v *iterNative) readInt64Uint16(key *int64, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4510,18 +3832,18 @@ func (v *iterNative) readIntTypex_U(key *int, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerIntTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_U
+ ret.fn = ret.readInt64Uint16
return ret
}
-func (v *iterNative) readETIntTypex_U(et *typex.EventTime, key *int, value *typex.U) bool {
+func (v *iterNative) readInt64Uint32(key *int64, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4529,20 +3851,18 @@ func (v *iterNative) readETIntTypex_U(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETIntTypex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_U
+ ret.fn = ret.readInt64Uint32
return ret
}
-func (v *iterNative) readIntTypex_V(key *int, value *typex.V) bool {
+func (v *iterNative) readInt64Uint64(key *int64, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4550,18 +3870,18 @@ func (v *iterNative) readIntTypex_V(key *int, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerIntTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_V
+ ret.fn = ret.readInt64Uint64
return ret
}
-func (v *iterNative) readETIntTypex_V(et *typex.EventTime, key *int, value *typex.V) bool {
+func (v *iterNative) readInt64Float32(key *int64, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4569,20 +3889,18 @@ func (v *iterNative) readETIntTypex_V(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETIntTypex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_V
+ ret.fn = ret.readInt64Float32
return ret
}
-func (v *iterNative) readIntTypex_W(key *int, value *typex.W) bool {
+func (v *iterNative) readInt64Float64(key *int64, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4590,18 +3908,18 @@ func (v *iterNative) readIntTypex_W(key *int, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerIntTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_W
+ ret.fn = ret.readInt64Float64
return ret
}
-func (v *iterNative) readETIntTypex_W(et *typex.EventTime, key *int, value *typex.W) bool {
+func (v *iterNative) readInt64Typex_T(key *int64, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4609,20 +3927,18 @@ func (v *iterNative) readETIntTypex_W(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETIntTypex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_W
+ ret.fn = ret.readInt64Typex_T
return ret
}
-func (v *iterNative) readIntTypex_X(key *int, value *typex.X) bool {
+func (v *iterNative) readInt64Typex_U(key *int64, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4630,18 +3946,18 @@ func (v *iterNative) readIntTypex_X(key *int, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerIntTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_X
+ ret.fn = ret.readInt64Typex_U
return ret
}
-func (v *iterNative) readETIntTypex_X(et *typex.EventTime, key *int, value *typex.X) bool {
+func (v *iterNative) readInt64Typex_V(key *int64, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4649,20 +3965,18 @@ func (v *iterNative) readETIntTypex_X(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETIntTypex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_X
+ ret.fn = ret.readInt64Typex_V
return ret
}
-func (v *iterNative) readIntTypex_Y(key *int, value *typex.Y) bool {
+func (v *iterNative) readInt64Typex_W(key *int64, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4670,18 +3984,18 @@ func (v *iterNative) readIntTypex_Y(key *int, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerIntTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_Y
+ ret.fn = ret.readInt64Typex_W
return ret
}
-func (v *iterNative) readETIntTypex_Y(et *typex.EventTime, key *int, value *typex.Y) bool {
+func (v *iterNative) readInt64Typex_X(key *int64, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4689,20 +4003,18 @@ func (v *iterNative) readETIntTypex_Y(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETIntTypex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_Y
+ ret.fn = ret.readInt64Typex_X
return ret
}
-func (v *iterNative) readIntTypex_Z(key *int, value *typex.Z) bool {
+func (v *iterNative) readInt64Typex_Y(key *int64, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4710,18 +4022,18 @@ func (v *iterNative) readIntTypex_Z(key *int, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(int64)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerIntTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readIntTypex_Z
+ ret.fn = ret.readInt64Typex_Y
return ret
}
-func (v *iterNative) readETIntTypex_Z(et *typex.EventTime, key *int, value *typex.Z) bool {
+func (v *iterNative) readInt64Typex_Z(key *int64, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4729,20 +4041,18 @@ func (v *iterNative) readETIntTypex_Z(et *typex.EventTime, key *int, value *type
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int)
+ *key = elm.Elm.(int64)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETIntTypex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerInt64Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETIntTypex_Z
+ ret.fn = ret.readInt64Typex_Z
return ret
}
-func (v *iterNative) readInt8(val *int8) bool {
+func (v *iterNative) readUint(val *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4750,17 +4060,17 @@ func (v *iterNative) readInt8(val *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(int8)
+ *val = elm.Elm.(uint)
return true
}
-func iterMakerInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8
+ ret.fn = ret.readUint
return ret
}
-func (v *iterNative) readETInt8(et *typex.EventTime, val *int8) bool {
+func (v *iterNative) readUintByteSlice(key *uint, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4768,19 +4078,18 @@ func (v *iterNative) readETInt8(et *typex.EventTime, val *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(int8)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETInt8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8
+ ret.fn = ret.readUintByteSlice
return ret
}
-func (v *iterNative) readInt8ByteSlice(key *int8, value *[]byte) bool {
+func (v *iterNative) readUintBool(key *uint, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4788,18 +4097,18 @@ func (v *iterNative) readInt8ByteSlice(key *int8, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerInt8ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8ByteSlice
+ ret.fn = ret.readUintBool
return ret
}
-func (v *iterNative) readETInt8ByteSlice(et *typex.EventTime, key *int8, value *[]byte) bool {
+func (v *iterNative) readUintString(key *uint, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4807,20 +4116,18 @@ func (v *iterNative) readETInt8ByteSlice(et *typex.EventTime, key *int8, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETInt8ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8ByteSlice
+ ret.fn = ret.readUintString
return ret
}
-func (v *iterNative) readInt8Bool(key *int8, value *bool) bool {
+func (v *iterNative) readUintInt(key *uint, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4828,18 +4135,18 @@ func (v *iterNative) readInt8Bool(key *int8, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerInt8Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Bool
+ ret.fn = ret.readUintInt
return ret
}
-func (v *iterNative) readETInt8Bool(et *typex.EventTime, key *int8, value *bool) bool {
+func (v *iterNative) readUintInt8(key *uint, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4847,20 +4154,18 @@ func (v *iterNative) readETInt8Bool(et *typex.EventTime, key *int8, value *bool)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETInt8Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Bool
+ ret.fn = ret.readUintInt8
return ret
}
-func (v *iterNative) readInt8String(key *int8, value *string) bool {
+func (v *iterNative) readUintInt16(key *uint, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4868,18 +4173,18 @@ func (v *iterNative) readInt8String(key *int8, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerInt8String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8String
+ ret.fn = ret.readUintInt16
return ret
}
-func (v *iterNative) readETInt8String(et *typex.EventTime, key *int8, value *string) bool {
+func (v *iterNative) readUintInt32(key *uint, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4887,20 +4192,18 @@ func (v *iterNative) readETInt8String(et *typex.EventTime, key *int8, value *str
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETInt8String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintInt32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8String
+ ret.fn = ret.readUintInt32
return ret
}
-func (v *iterNative) readInt8Int(key *int8, value *int) bool {
+func (v *iterNative) readUintInt64(key *uint, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4908,18 +4211,18 @@ func (v *iterNative) readInt8Int(key *int8, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerInt8Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintInt64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Int
+ ret.fn = ret.readUintInt64
return ret
}
-func (v *iterNative) readETInt8Int(et *typex.EventTime, key *int8, value *int) bool {
+func (v *iterNative) readUintUint(key *uint, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4927,20 +4230,18 @@ func (v *iterNative) readETInt8Int(et *typex.EventTime, key *int8, value *int) b
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETInt8Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintUint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Int
+ ret.fn = ret.readUintUint
return ret
}
-func (v *iterNative) readInt8Int8(key *int8, value *int8) bool {
+func (v *iterNative) readUintUint8(key *uint, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4948,18 +4249,18 @@ func (v *iterNative) readInt8Int8(key *int8, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerInt8Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Int8
+ ret.fn = ret.readUintUint8
return ret
}
-func (v *iterNative) readETInt8Int8(et *typex.EventTime, key *int8, value *int8) bool {
+func (v *iterNative) readUintUint16(key *uint, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4967,20 +4268,18 @@ func (v *iterNative) readETInt8Int8(et *typex.EventTime, key *int8, value *int8)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETInt8Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Int8
+ ret.fn = ret.readUintUint16
return ret
}
-func (v *iterNative) readInt8Int16(key *int8, value *int16) bool {
+func (v *iterNative) readUintUint32(key *uint, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -4988,18 +4287,18 @@ func (v *iterNative) readInt8Int16(key *int8, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerInt8Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Int16
+ ret.fn = ret.readUintUint32
return ret
}
-func (v *iterNative) readETInt8Int16(et *typex.EventTime, key *int8, value *int16) bool {
+func (v *iterNative) readUintUint64(key *uint, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5007,20 +4306,18 @@ func (v *iterNative) readETInt8Int16(et *typex.EventTime, key *int8, value *int1
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETInt8Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Int16
+ ret.fn = ret.readUintUint64
return ret
}
-func (v *iterNative) readInt8Int32(key *int8, value *int32) bool {
+func (v *iterNative) readUintFloat32(key *uint, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5028,18 +4325,18 @@ func (v *iterNative) readInt8Int32(key *int8, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerInt8Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Int32
+ ret.fn = ret.readUintFloat32
return ret
}
-func (v *iterNative) readETInt8Int32(et *typex.EventTime, key *int8, value *int32) bool {
+func (v *iterNative) readUintFloat64(key *uint, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5047,20 +4344,18 @@ func (v *iterNative) readETInt8Int32(et *typex.EventTime, key *int8, value *int3
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETInt8Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Int32
+ ret.fn = ret.readUintFloat64
return ret
}
-func (v *iterNative) readInt8Int64(key *int8, value *int64) bool {
+func (v *iterNative) readUintTypex_T(key *uint, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5068,18 +4363,18 @@ func (v *iterNative) readInt8Int64(key *int8, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerInt8Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Int64
+ ret.fn = ret.readUintTypex_T
return ret
}
-func (v *iterNative) readETInt8Int64(et *typex.EventTime, key *int8, value *int64) bool {
+func (v *iterNative) readUintTypex_U(key *uint, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5087,20 +4382,18 @@ func (v *iterNative) readETInt8Int64(et *typex.EventTime, key *int8, value *int6
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETInt8Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Int64
+ ret.fn = ret.readUintTypex_U
return ret
}
-func (v *iterNative) readInt8Uint(key *int8, value *uint) bool {
+func (v *iterNative) readUintTypex_V(key *uint, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5108,18 +4401,18 @@ func (v *iterNative) readInt8Uint(key *int8, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerInt8Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Uint
+ ret.fn = ret.readUintTypex_V
return ret
}
-func (v *iterNative) readETInt8Uint(et *typex.EventTime, key *int8, value *uint) bool {
+func (v *iterNative) readUintTypex_W(key *uint, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5127,20 +4420,18 @@ func (v *iterNative) readETInt8Uint(et *typex.EventTime, key *int8, value *uint)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETInt8Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Uint
+ ret.fn = ret.readUintTypex_W
return ret
}
-func (v *iterNative) readInt8Uint8(key *int8, value *uint8) bool {
+func (v *iterNative) readUintTypex_X(key *uint, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5148,18 +4439,18 @@ func (v *iterNative) readInt8Uint8(key *int8, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerInt8Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Uint8
+ ret.fn = ret.readUintTypex_X
return ret
}
-func (v *iterNative) readETInt8Uint8(et *typex.EventTime, key *int8, value *uint8) bool {
+func (v *iterNative) readUintTypex_Y(key *uint, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5167,20 +4458,18 @@ func (v *iterNative) readETInt8Uint8(et *typex.EventTime, key *int8, value *uint
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETInt8Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Uint8
+ ret.fn = ret.readUintTypex_Y
return ret
}
-func (v *iterNative) readInt8Uint16(key *int8, value *uint16) bool {
+func (v *iterNative) readUintTypex_Z(key *uint, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5188,18 +4477,18 @@ func (v *iterNative) readInt8Uint16(key *int8, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(uint)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerInt8Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUintTypex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Uint16
+ ret.fn = ret.readUintTypex_Z
return ret
}
-func (v *iterNative) readETInt8Uint16(et *typex.EventTime, key *int8, value *uint16) bool {
+func (v *iterNative) readUint8(val *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5207,20 +4496,17 @@ func (v *iterNative) readETInt8Uint16(et *typex.EventTime, key *int8, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(uint8)
return true
}
-func iterMakerETInt8Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Uint16
+ ret.fn = ret.readUint8
return ret
}
-func (v *iterNative) readInt8Uint32(key *int8, value *uint32) bool {
+func (v *iterNative) readUint8ByteSlice(key *uint8, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5228,18 +4514,18 @@ func (v *iterNative) readInt8Uint32(key *int8, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerInt8Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Uint32
+ ret.fn = ret.readUint8ByteSlice
return ret
}
-func (v *iterNative) readETInt8Uint32(et *typex.EventTime, key *int8, value *uint32) bool {
+func (v *iterNative) readUint8Bool(key *uint8, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5247,20 +4533,18 @@ func (v *iterNative) readETInt8Uint32(et *typex.EventTime, key *int8, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETInt8Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Uint32
+ ret.fn = ret.readUint8Bool
return ret
}
-func (v *iterNative) readInt8Uint64(key *int8, value *uint64) bool {
+func (v *iterNative) readUint8String(key *uint8, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5268,18 +4552,18 @@ func (v *iterNative) readInt8Uint64(key *int8, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerInt8Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Uint64
+ ret.fn = ret.readUint8String
return ret
}
-func (v *iterNative) readETInt8Uint64(et *typex.EventTime, key *int8, value *uint64) bool {
+func (v *iterNative) readUint8Int(key *uint8, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5287,20 +4571,18 @@ func (v *iterNative) readETInt8Uint64(et *typex.EventTime, key *int8, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETInt8Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Uint64
+ ret.fn = ret.readUint8Int
return ret
}
-func (v *iterNative) readInt8Float32(key *int8, value *float32) bool {
+func (v *iterNative) readUint8Int8(key *uint8, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5308,18 +4590,18 @@ func (v *iterNative) readInt8Float32(key *int8, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerInt8Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Float32
+ ret.fn = ret.readUint8Int8
return ret
}
-func (v *iterNative) readETInt8Float32(et *typex.EventTime, key *int8, value *float32) bool {
+func (v *iterNative) readUint8Int16(key *uint8, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5327,20 +4609,18 @@ func (v *iterNative) readETInt8Float32(et *typex.EventTime, key *int8, value *fl
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETInt8Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Float32
+ ret.fn = ret.readUint8Int16
return ret
}
-func (v *iterNative) readInt8Float64(key *int8, value *float64) bool {
+func (v *iterNative) readUint8Int32(key *uint8, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5348,18 +4628,18 @@ func (v *iterNative) readInt8Float64(key *int8, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerInt8Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Float64
+ ret.fn = ret.readUint8Int32
return ret
}
-func (v *iterNative) readETInt8Float64(et *typex.EventTime, key *int8, value *float64) bool {
+func (v *iterNative) readUint8Int64(key *uint8, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5367,20 +4647,18 @@ func (v *iterNative) readETInt8Float64(et *typex.EventTime, key *int8, value *fl
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETInt8Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Float64
+ ret.fn = ret.readUint8Int64
return ret
}
-func (v *iterNative) readInt8Typex_T(key *int8, value *typex.T) bool {
+func (v *iterNative) readUint8Uint(key *uint8, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5388,18 +4666,18 @@ func (v *iterNative) readInt8Typex_T(key *int8, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerInt8Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_T
+ ret.fn = ret.readUint8Uint
return ret
}
-func (v *iterNative) readETInt8Typex_T(et *typex.EventTime, key *int8, value *typex.T) bool {
+func (v *iterNative) readUint8Uint8(key *uint8, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5407,20 +4685,18 @@ func (v *iterNative) readETInt8Typex_T(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETInt8Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_T
+ ret.fn = ret.readUint8Uint8
return ret
}
-func (v *iterNative) readInt8Typex_U(key *int8, value *typex.U) bool {
+func (v *iterNative) readUint8Uint16(key *uint8, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5428,18 +4704,18 @@ func (v *iterNative) readInt8Typex_U(key *int8, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerInt8Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_U
+ ret.fn = ret.readUint8Uint16
return ret
}
-func (v *iterNative) readETInt8Typex_U(et *typex.EventTime, key *int8, value *typex.U) bool {
+func (v *iterNative) readUint8Uint32(key *uint8, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5447,20 +4723,18 @@ func (v *iterNative) readETInt8Typex_U(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETInt8Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_U
+ ret.fn = ret.readUint8Uint32
return ret
}
-func (v *iterNative) readInt8Typex_V(key *int8, value *typex.V) bool {
+func (v *iterNative) readUint8Uint64(key *uint8, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5468,18 +4742,18 @@ func (v *iterNative) readInt8Typex_V(key *int8, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerInt8Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_V
+ ret.fn = ret.readUint8Uint64
return ret
}
-func (v *iterNative) readETInt8Typex_V(et *typex.EventTime, key *int8, value *typex.V) bool {
+func (v *iterNative) readUint8Float32(key *uint8, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5487,20 +4761,18 @@ func (v *iterNative) readETInt8Typex_V(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETInt8Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_V
+ ret.fn = ret.readUint8Float32
return ret
}
-func (v *iterNative) readInt8Typex_W(key *int8, value *typex.W) bool {
+func (v *iterNative) readUint8Float64(key *uint8, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5508,18 +4780,18 @@ func (v *iterNative) readInt8Typex_W(key *int8, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerInt8Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_W
+ ret.fn = ret.readUint8Float64
return ret
}
-func (v *iterNative) readETInt8Typex_W(et *typex.EventTime, key *int8, value *typex.W) bool {
+func (v *iterNative) readUint8Typex_T(key *uint8, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5527,20 +4799,18 @@ func (v *iterNative) readETInt8Typex_W(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETInt8Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_W
+ ret.fn = ret.readUint8Typex_T
return ret
}
-func (v *iterNative) readInt8Typex_X(key *int8, value *typex.X) bool {
+func (v *iterNative) readUint8Typex_U(key *uint8, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5548,18 +4818,18 @@ func (v *iterNative) readInt8Typex_X(key *int8, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerInt8Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_X
+ ret.fn = ret.readUint8Typex_U
return ret
}
-func (v *iterNative) readETInt8Typex_X(et *typex.EventTime, key *int8, value *typex.X) bool {
+func (v *iterNative) readUint8Typex_V(key *uint8, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5567,20 +4837,18 @@ func (v *iterNative) readETInt8Typex_X(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETInt8Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_X
+ ret.fn = ret.readUint8Typex_V
return ret
}
-func (v *iterNative) readInt8Typex_Y(key *int8, value *typex.Y) bool {
+func (v *iterNative) readUint8Typex_W(key *uint8, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5588,18 +4856,18 @@ func (v *iterNative) readInt8Typex_Y(key *int8, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerInt8Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_Y
+ ret.fn = ret.readUint8Typex_W
return ret
}
-func (v *iterNative) readETInt8Typex_Y(et *typex.EventTime, key *int8, value *typex.Y) bool {
+func (v *iterNative) readUint8Typex_X(key *uint8, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5607,20 +4875,18 @@ func (v *iterNative) readETInt8Typex_Y(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETInt8Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_Y
+ ret.fn = ret.readUint8Typex_X
return ret
}
-func (v *iterNative) readInt8Typex_Z(key *int8, value *typex.Z) bool {
+func (v *iterNative) readUint8Typex_Y(key *uint8, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5628,18 +4894,18 @@ func (v *iterNative) readInt8Typex_Z(key *int8, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int8)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(uint8)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerInt8Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt8Typex_Z
+ ret.fn = ret.readUint8Typex_Y
return ret
}
-func (v *iterNative) readETInt8Typex_Z(et *typex.EventTime, key *int8, value *typex.Z) bool {
+func (v *iterNative) readUint8Typex_Z(key *uint8, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5647,20 +4913,18 @@ func (v *iterNative) readETInt8Typex_Z(et *typex.EventTime, key *int8, value *ty
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int8)
+ *key = elm.Elm.(uint8)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETInt8Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint8Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt8Typex_Z
+ ret.fn = ret.readUint8Typex_Z
return ret
}
-func (v *iterNative) readInt16(val *int16) bool {
+func (v *iterNative) readUint16(val *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5668,17 +4932,17 @@ func (v *iterNative) readInt16(val *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(int16)
+ *val = elm.Elm.(uint16)
return true
}
-func iterMakerInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16
+ ret.fn = ret.readUint16
return ret
}
-func (v *iterNative) readETInt16(et *typex.EventTime, val *int16) bool {
+func (v *iterNative) readUint16ByteSlice(key *uint16, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5686,19 +4950,18 @@ func (v *iterNative) readETInt16(et *typex.EventTime, val *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(int16)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETInt16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16
+ ret.fn = ret.readUint16ByteSlice
return ret
}
-func (v *iterNative) readInt16ByteSlice(key *int16, value *[]byte) bool {
+func (v *iterNative) readUint16Bool(key *uint16, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5706,18 +4969,18 @@ func (v *iterNative) readInt16ByteSlice(key *int16, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerInt16ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16ByteSlice
+ ret.fn = ret.readUint16Bool
return ret
}
-func (v *iterNative) readETInt16ByteSlice(et *typex.EventTime, key *int16, value *[]byte) bool {
+func (v *iterNative) readUint16String(key *uint16, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5725,20 +4988,18 @@ func (v *iterNative) readETInt16ByteSlice(et *typex.EventTime, key *int16, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETInt16ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16ByteSlice
+ ret.fn = ret.readUint16String
return ret
}
-func (v *iterNative) readInt16Bool(key *int16, value *bool) bool {
+func (v *iterNative) readUint16Int(key *uint16, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5746,18 +5007,18 @@ func (v *iterNative) readInt16Bool(key *int16, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerInt16Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Bool
+ ret.fn = ret.readUint16Int
return ret
}
-func (v *iterNative) readETInt16Bool(et *typex.EventTime, key *int16, value *bool) bool {
+func (v *iterNative) readUint16Int8(key *uint16, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5765,20 +5026,18 @@ func (v *iterNative) readETInt16Bool(et *typex.EventTime, key *int16, value *boo
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETInt16Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Bool
+ ret.fn = ret.readUint16Int8
return ret
}
-func (v *iterNative) readInt16String(key *int16, value *string) bool {
+func (v *iterNative) readUint16Int16(key *uint16, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5786,18 +5045,18 @@ func (v *iterNative) readInt16String(key *int16, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerInt16String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16String
+ ret.fn = ret.readUint16Int16
return ret
}
-func (v *iterNative) readETInt16String(et *typex.EventTime, key *int16, value *string) bool {
+func (v *iterNative) readUint16Int32(key *uint16, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5805,20 +5064,18 @@ func (v *iterNative) readETInt16String(et *typex.EventTime, key *int16, value *s
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETInt16String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16String
+ ret.fn = ret.readUint16Int32
return ret
}
-func (v *iterNative) readInt16Int(key *int16, value *int) bool {
+func (v *iterNative) readUint16Int64(key *uint16, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5826,18 +5083,18 @@ func (v *iterNative) readInt16Int(key *int16, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerInt16Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Int
+ ret.fn = ret.readUint16Int64
return ret
}
-func (v *iterNative) readETInt16Int(et *typex.EventTime, key *int16, value *int) bool {
+func (v *iterNative) readUint16Uint(key *uint16, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5845,20 +5102,18 @@ func (v *iterNative) readETInt16Int(et *typex.EventTime, key *int16, value *int)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETInt16Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Int
+ ret.fn = ret.readUint16Uint
return ret
}
-func (v *iterNative) readInt16Int8(key *int16, value *int8) bool {
+func (v *iterNative) readUint16Uint8(key *uint16, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5866,18 +5121,18 @@ func (v *iterNative) readInt16Int8(key *int16, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerInt16Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Int8
+ ret.fn = ret.readUint16Uint8
return ret
}
-func (v *iterNative) readETInt16Int8(et *typex.EventTime, key *int16, value *int8) bool {
+func (v *iterNative) readUint16Uint16(key *uint16, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5885,20 +5140,18 @@ func (v *iterNative) readETInt16Int8(et *typex.EventTime, key *int16, value *int
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETInt16Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Int8
+ ret.fn = ret.readUint16Uint16
return ret
}
-func (v *iterNative) readInt16Int16(key *int16, value *int16) bool {
+func (v *iterNative) readUint16Uint32(key *uint16, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5906,18 +5159,18 @@ func (v *iterNative) readInt16Int16(key *int16, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerInt16Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Int16
+ ret.fn = ret.readUint16Uint32
return ret
}
-func (v *iterNative) readETInt16Int16(et *typex.EventTime, key *int16, value *int16) bool {
+func (v *iterNative) readUint16Uint64(key *uint16, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5925,20 +5178,18 @@ func (v *iterNative) readETInt16Int16(et *typex.EventTime, key *int16, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETInt16Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Int16
+ ret.fn = ret.readUint16Uint64
return ret
}
-func (v *iterNative) readInt16Int32(key *int16, value *int32) bool {
+func (v *iterNative) readUint16Float32(key *uint16, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5946,18 +5197,18 @@ func (v *iterNative) readInt16Int32(key *int16, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerInt16Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Int32
+ ret.fn = ret.readUint16Float32
return ret
}
-func (v *iterNative) readETInt16Int32(et *typex.EventTime, key *int16, value *int32) bool {
+func (v *iterNative) readUint16Float64(key *uint16, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5965,20 +5216,18 @@ func (v *iterNative) readETInt16Int32(et *typex.EventTime, key *int16, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETInt16Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Int32
+ ret.fn = ret.readUint16Float64
return ret
}
-func (v *iterNative) readInt16Int64(key *int16, value *int64) bool {
+func (v *iterNative) readUint16Typex_T(key *uint16, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -5986,18 +5235,18 @@ func (v *iterNative) readInt16Int64(key *int16, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerInt16Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Int64
+ ret.fn = ret.readUint16Typex_T
return ret
}
-func (v *iterNative) readETInt16Int64(et *typex.EventTime, key *int16, value *int64) bool {
+func (v *iterNative) readUint16Typex_U(key *uint16, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6005,20 +5254,18 @@ func (v *iterNative) readETInt16Int64(et *typex.EventTime, key *int16, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETInt16Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Int64
+ ret.fn = ret.readUint16Typex_U
return ret
}
-func (v *iterNative) readInt16Uint(key *int16, value *uint) bool {
+func (v *iterNative) readUint16Typex_V(key *uint16, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6026,18 +5273,18 @@ func (v *iterNative) readInt16Uint(key *int16, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerInt16Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Uint
+ ret.fn = ret.readUint16Typex_V
return ret
}
-func (v *iterNative) readETInt16Uint(et *typex.EventTime, key *int16, value *uint) bool {
+func (v *iterNative) readUint16Typex_W(key *uint16, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6045,20 +5292,18 @@ func (v *iterNative) readETInt16Uint(et *typex.EventTime, key *int16, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETInt16Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Uint
+ ret.fn = ret.readUint16Typex_W
return ret
}
-func (v *iterNative) readInt16Uint8(key *int16, value *uint8) bool {
+func (v *iterNative) readUint16Typex_X(key *uint16, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6066,18 +5311,18 @@ func (v *iterNative) readInt16Uint8(key *int16, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerInt16Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Uint8
+ ret.fn = ret.readUint16Typex_X
return ret
}
-func (v *iterNative) readETInt16Uint8(et *typex.EventTime, key *int16, value *uint8) bool {
+func (v *iterNative) readUint16Typex_Y(key *uint16, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6085,20 +5330,18 @@ func (v *iterNative) readETInt16Uint8(et *typex.EventTime, key *int16, value *ui
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETInt16Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Uint8
+ ret.fn = ret.readUint16Typex_Y
return ret
}
-func (v *iterNative) readInt16Uint16(key *int16, value *uint16) bool {
+func (v *iterNative) readUint16Typex_Z(key *uint16, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6106,18 +5349,18 @@ func (v *iterNative) readInt16Uint16(key *int16, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(uint16)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerInt16Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint16Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Uint16
+ ret.fn = ret.readUint16Typex_Z
return ret
}
-func (v *iterNative) readETInt16Uint16(et *typex.EventTime, key *int16, value *uint16) bool {
+func (v *iterNative) readUint32(val *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6125,20 +5368,17 @@ func (v *iterNative) readETInt16Uint16(et *typex.EventTime, key *int16, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(uint32)
return true
}
-func iterMakerETInt16Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Uint16
+ ret.fn = ret.readUint32
return ret
}
-func (v *iterNative) readInt16Uint32(key *int16, value *uint32) bool {
+func (v *iterNative) readUint32ByteSlice(key *uint32, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6146,18 +5386,18 @@ func (v *iterNative) readInt16Uint32(key *int16, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerInt16Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Uint32
+ ret.fn = ret.readUint32ByteSlice
return ret
}
-func (v *iterNative) readETInt16Uint32(et *typex.EventTime, key *int16, value *uint32) bool {
+func (v *iterNative) readUint32Bool(key *uint32, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6165,20 +5405,18 @@ func (v *iterNative) readETInt16Uint32(et *typex.EventTime, key *int16, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETInt16Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Uint32
+ ret.fn = ret.readUint32Bool
return ret
}
-func (v *iterNative) readInt16Uint64(key *int16, value *uint64) bool {
+func (v *iterNative) readUint32String(key *uint32, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6186,18 +5424,18 @@ func (v *iterNative) readInt16Uint64(key *int16, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerInt16Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Uint64
+ ret.fn = ret.readUint32String
return ret
}
-func (v *iterNative) readETInt16Uint64(et *typex.EventTime, key *int16, value *uint64) bool {
+func (v *iterNative) readUint32Int(key *uint32, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6205,20 +5443,18 @@ func (v *iterNative) readETInt16Uint64(et *typex.EventTime, key *int16, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETInt16Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Uint64
+ ret.fn = ret.readUint32Int
return ret
}
-func (v *iterNative) readInt16Float32(key *int16, value *float32) bool {
+func (v *iterNative) readUint32Int8(key *uint32, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6226,18 +5462,18 @@ func (v *iterNative) readInt16Float32(key *int16, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerInt16Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Float32
+ ret.fn = ret.readUint32Int8
return ret
}
-func (v *iterNative) readETInt16Float32(et *typex.EventTime, key *int16, value *float32) bool {
+func (v *iterNative) readUint32Int16(key *uint32, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6245,20 +5481,18 @@ func (v *iterNative) readETInt16Float32(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETInt16Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Float32
+ ret.fn = ret.readUint32Int16
return ret
}
-func (v *iterNative) readInt16Float64(key *int16, value *float64) bool {
+func (v *iterNative) readUint32Int32(key *uint32, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6266,18 +5500,18 @@ func (v *iterNative) readInt16Float64(key *int16, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerInt16Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Float64
+ ret.fn = ret.readUint32Int32
return ret
}
-func (v *iterNative) readETInt16Float64(et *typex.EventTime, key *int16, value *float64) bool {
+func (v *iterNative) readUint32Int64(key *uint32, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6285,20 +5519,18 @@ func (v *iterNative) readETInt16Float64(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETInt16Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Float64
+ ret.fn = ret.readUint32Int64
return ret
}
-func (v *iterNative) readInt16Typex_T(key *int16, value *typex.T) bool {
+func (v *iterNative) readUint32Uint(key *uint32, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6306,18 +5538,18 @@ func (v *iterNative) readInt16Typex_T(key *int16, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerInt16Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_T
+ ret.fn = ret.readUint32Uint
return ret
}
-func (v *iterNative) readETInt16Typex_T(et *typex.EventTime, key *int16, value *typex.T) bool {
+func (v *iterNative) readUint32Uint8(key *uint32, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6325,20 +5557,18 @@ func (v *iterNative) readETInt16Typex_T(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETInt16Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_T
+ ret.fn = ret.readUint32Uint8
return ret
}
-func (v *iterNative) readInt16Typex_U(key *int16, value *typex.U) bool {
+func (v *iterNative) readUint32Uint16(key *uint32, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6346,18 +5576,18 @@ func (v *iterNative) readInt16Typex_U(key *int16, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerInt16Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_U
+ ret.fn = ret.readUint32Uint16
return ret
}
-func (v *iterNative) readETInt16Typex_U(et *typex.EventTime, key *int16, value *typex.U) bool {
+func (v *iterNative) readUint32Uint32(key *uint32, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6365,20 +5595,18 @@ func (v *iterNative) readETInt16Typex_U(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETInt16Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_U
+ ret.fn = ret.readUint32Uint32
return ret
}
-func (v *iterNative) readInt16Typex_V(key *int16, value *typex.V) bool {
+func (v *iterNative) readUint32Uint64(key *uint32, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6386,18 +5614,18 @@ func (v *iterNative) readInt16Typex_V(key *int16, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerInt16Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_V
+ ret.fn = ret.readUint32Uint64
return ret
}
-func (v *iterNative) readETInt16Typex_V(et *typex.EventTime, key *int16, value *typex.V) bool {
+func (v *iterNative) readUint32Float32(key *uint32, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6405,20 +5633,18 @@ func (v *iterNative) readETInt16Typex_V(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETInt16Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_V
+ ret.fn = ret.readUint32Float32
return ret
}
-func (v *iterNative) readInt16Typex_W(key *int16, value *typex.W) bool {
+func (v *iterNative) readUint32Float64(key *uint32, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6426,18 +5652,18 @@ func (v *iterNative) readInt16Typex_W(key *int16, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerInt16Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_W
+ ret.fn = ret.readUint32Float64
return ret
}
-func (v *iterNative) readETInt16Typex_W(et *typex.EventTime, key *int16, value *typex.W) bool {
+func (v *iterNative) readUint32Typex_T(key *uint32, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6445,20 +5671,18 @@ func (v *iterNative) readETInt16Typex_W(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETInt16Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_W
+ ret.fn = ret.readUint32Typex_T
return ret
}
-func (v *iterNative) readInt16Typex_X(key *int16, value *typex.X) bool {
+func (v *iterNative) readUint32Typex_U(key *uint32, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6466,18 +5690,18 @@ func (v *iterNative) readInt16Typex_X(key *int16, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerInt16Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_X
+ ret.fn = ret.readUint32Typex_U
return ret
}
-func (v *iterNative) readETInt16Typex_X(et *typex.EventTime, key *int16, value *typex.X) bool {
+func (v *iterNative) readUint32Typex_V(key *uint32, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6485,20 +5709,18 @@ func (v *iterNative) readETInt16Typex_X(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETInt16Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_X
+ ret.fn = ret.readUint32Typex_V
return ret
}
-func (v *iterNative) readInt16Typex_Y(key *int16, value *typex.Y) bool {
+func (v *iterNative) readUint32Typex_W(key *uint32, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6506,18 +5728,18 @@ func (v *iterNative) readInt16Typex_Y(key *int16, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerInt16Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_Y
+ ret.fn = ret.readUint32Typex_W
return ret
}
-func (v *iterNative) readETInt16Typex_Y(et *typex.EventTime, key *int16, value *typex.Y) bool {
+func (v *iterNative) readUint32Typex_X(key *uint32, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6525,20 +5747,18 @@ func (v *iterNative) readETInt16Typex_Y(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETInt16Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_Y
+ ret.fn = ret.readUint32Typex_X
return ret
}
-func (v *iterNative) readInt16Typex_Z(key *int16, value *typex.Z) bool {
+func (v *iterNative) readUint32Typex_Y(key *uint32, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6546,18 +5766,18 @@ func (v *iterNative) readInt16Typex_Z(key *int16, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int16)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(uint32)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerInt16Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt16Typex_Z
+ ret.fn = ret.readUint32Typex_Y
return ret
}
-func (v *iterNative) readETInt16Typex_Z(et *typex.EventTime, key *int16, value *typex.Z) bool {
+func (v *iterNative) readUint32Typex_Z(key *uint32, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6565,20 +5785,18 @@ func (v *iterNative) readETInt16Typex_Z(et *typex.EventTime, key *int16, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int16)
+ *key = elm.Elm.(uint32)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETInt16Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint32Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt16Typex_Z
+ ret.fn = ret.readUint32Typex_Z
return ret
}
-func (v *iterNative) readInt32(val *int32) bool {
+func (v *iterNative) readUint64(val *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6586,17 +5804,17 @@ func (v *iterNative) readInt32(val *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(int32)
+ *val = elm.Elm.(uint64)
return true
}
-func iterMakerInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32
+ ret.fn = ret.readUint64
return ret
}
-func (v *iterNative) readETInt32(et *typex.EventTime, val *int32) bool {
+func (v *iterNative) readUint64ByteSlice(key *uint64, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6604,19 +5822,18 @@ func (v *iterNative) readETInt32(et *typex.EventTime, val *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(int32)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETInt32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32
+ ret.fn = ret.readUint64ByteSlice
return ret
}
-func (v *iterNative) readInt32ByteSlice(key *int32, value *[]byte) bool {
+func (v *iterNative) readUint64Bool(key *uint64, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6624,18 +5841,18 @@ func (v *iterNative) readInt32ByteSlice(key *int32, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerInt32ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32ByteSlice
+ ret.fn = ret.readUint64Bool
return ret
}
-func (v *iterNative) readETInt32ByteSlice(et *typex.EventTime, key *int32, value *[]byte) bool {
+func (v *iterNative) readUint64String(key *uint64, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6643,20 +5860,18 @@ func (v *iterNative) readETInt32ByteSlice(et *typex.EventTime, key *int32, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETInt32ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32ByteSlice
+ ret.fn = ret.readUint64String
return ret
}
-func (v *iterNative) readInt32Bool(key *int32, value *bool) bool {
+func (v *iterNative) readUint64Int(key *uint64, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6664,18 +5879,18 @@ func (v *iterNative) readInt32Bool(key *int32, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerInt32Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Bool
+ ret.fn = ret.readUint64Int
return ret
}
-func (v *iterNative) readETInt32Bool(et *typex.EventTime, key *int32, value *bool) bool {
+func (v *iterNative) readUint64Int8(key *uint64, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6683,20 +5898,18 @@ func (v *iterNative) readETInt32Bool(et *typex.EventTime, key *int32, value *boo
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETInt32Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Bool
+ ret.fn = ret.readUint64Int8
return ret
}
-func (v *iterNative) readInt32String(key *int32, value *string) bool {
+func (v *iterNative) readUint64Int16(key *uint64, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6704,18 +5917,18 @@ func (v *iterNative) readInt32String(key *int32, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerInt32String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32String
+ ret.fn = ret.readUint64Int16
return ret
}
-func (v *iterNative) readETInt32String(et *typex.EventTime, key *int32, value *string) bool {
+func (v *iterNative) readUint64Int32(key *uint64, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6723,20 +5936,18 @@ func (v *iterNative) readETInt32String(et *typex.EventTime, key *int32, value *s
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETInt32String(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32String
+ ret.fn = ret.readUint64Int32
return ret
}
-func (v *iterNative) readInt32Int(key *int32, value *int) bool {
+func (v *iterNative) readUint64Int64(key *uint64, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6744,18 +5955,18 @@ func (v *iterNative) readInt32Int(key *int32, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerInt32Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Int
+ ret.fn = ret.readUint64Int64
return ret
}
-func (v *iterNative) readETInt32Int(et *typex.EventTime, key *int32, value *int) bool {
+func (v *iterNative) readUint64Uint(key *uint64, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6763,20 +5974,18 @@ func (v *iterNative) readETInt32Int(et *typex.EventTime, key *int32, value *int)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETInt32Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Int
+ ret.fn = ret.readUint64Uint
return ret
}
-func (v *iterNative) readInt32Int8(key *int32, value *int8) bool {
+func (v *iterNative) readUint64Uint8(key *uint64, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6784,18 +5993,18 @@ func (v *iterNative) readInt32Int8(key *int32, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerInt32Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Int8
+ ret.fn = ret.readUint64Uint8
return ret
}
-func (v *iterNative) readETInt32Int8(et *typex.EventTime, key *int32, value *int8) bool {
+func (v *iterNative) readUint64Uint16(key *uint64, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6803,20 +6012,18 @@ func (v *iterNative) readETInt32Int8(et *typex.EventTime, key *int32, value *int
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETInt32Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Int8
+ ret.fn = ret.readUint64Uint16
return ret
}
-func (v *iterNative) readInt32Int16(key *int32, value *int16) bool {
+func (v *iterNative) readUint64Uint32(key *uint64, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6824,18 +6031,18 @@ func (v *iterNative) readInt32Int16(key *int32, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerInt32Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Int16
+ ret.fn = ret.readUint64Uint32
return ret
}
-func (v *iterNative) readETInt32Int16(et *typex.EventTime, key *int32, value *int16) bool {
+func (v *iterNative) readUint64Uint64(key *uint64, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6843,20 +6050,18 @@ func (v *iterNative) readETInt32Int16(et *typex.EventTime, key *int32, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETInt32Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Int16
+ ret.fn = ret.readUint64Uint64
return ret
}
-func (v *iterNative) readInt32Int32(key *int32, value *int32) bool {
+func (v *iterNative) readUint64Float32(key *uint64, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6864,18 +6069,18 @@ func (v *iterNative) readInt32Int32(key *int32, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerInt32Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Int32
+ ret.fn = ret.readUint64Float32
return ret
}
-func (v *iterNative) readETInt32Int32(et *typex.EventTime, key *int32, value *int32) bool {
+func (v *iterNative) readUint64Float64(key *uint64, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6883,20 +6088,18 @@ func (v *iterNative) readETInt32Int32(et *typex.EventTime, key *int32, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETInt32Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Int32
+ ret.fn = ret.readUint64Float64
return ret
}
-func (v *iterNative) readInt32Int64(key *int32, value *int64) bool {
+func (v *iterNative) readUint64Typex_T(key *uint64, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6904,18 +6107,18 @@ func (v *iterNative) readInt32Int64(key *int32, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerInt32Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Int64
+ ret.fn = ret.readUint64Typex_T
return ret
}
-func (v *iterNative) readETInt32Int64(et *typex.EventTime, key *int32, value *int64) bool {
+func (v *iterNative) readUint64Typex_U(key *uint64, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6923,20 +6126,18 @@ func (v *iterNative) readETInt32Int64(et *typex.EventTime, key *int32, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETInt32Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Int64
+ ret.fn = ret.readUint64Typex_U
return ret
}
-func (v *iterNative) readInt32Uint(key *int32, value *uint) bool {
+func (v *iterNative) readUint64Typex_V(key *uint64, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6944,18 +6145,18 @@ func (v *iterNative) readInt32Uint(key *int32, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerInt32Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Uint
+ ret.fn = ret.readUint64Typex_V
return ret
}
-func (v *iterNative) readETInt32Uint(et *typex.EventTime, key *int32, value *uint) bool {
+func (v *iterNative) readUint64Typex_W(key *uint64, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6963,20 +6164,18 @@ func (v *iterNative) readETInt32Uint(et *typex.EventTime, key *int32, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETInt32Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Uint
+ ret.fn = ret.readUint64Typex_W
return ret
}
-func (v *iterNative) readInt32Uint8(key *int32, value *uint8) bool {
+func (v *iterNative) readUint64Typex_X(key *uint64, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -6984,18 +6183,18 @@ func (v *iterNative) readInt32Uint8(key *int32, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerInt32Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Uint8
+ ret.fn = ret.readUint64Typex_X
return ret
}
-func (v *iterNative) readETInt32Uint8(et *typex.EventTime, key *int32, value *uint8) bool {
+func (v *iterNative) readUint64Typex_Y(key *uint64, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7003,20 +6202,18 @@ func (v *iterNative) readETInt32Uint8(et *typex.EventTime, key *int32, value *ui
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETInt32Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Uint8
+ ret.fn = ret.readUint64Typex_Y
return ret
}
-func (v *iterNative) readInt32Uint16(key *int32, value *uint16) bool {
+func (v *iterNative) readUint64Typex_Z(key *uint64, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7024,18 +6221,18 @@ func (v *iterNative) readInt32Uint16(key *int32, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(uint64)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerInt32Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerUint64Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Uint16
+ ret.fn = ret.readUint64Typex_Z
return ret
}
-func (v *iterNative) readETInt32Uint16(et *typex.EventTime, key *int32, value *uint16) bool {
+func (v *iterNative) readFloat32(val *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7043,20 +6240,17 @@ func (v *iterNative) readETInt32Uint16(et *typex.EventTime, key *int32, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(float32)
return true
}
-func iterMakerETInt32Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Uint16
+ ret.fn = ret.readFloat32
return ret
}
-func (v *iterNative) readInt32Uint32(key *int32, value *uint32) bool {
+func (v *iterNative) readFloat32ByteSlice(key *float32, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7064,18 +6258,18 @@ func (v *iterNative) readInt32Uint32(key *int32, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerInt32Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Uint32
+ ret.fn = ret.readFloat32ByteSlice
return ret
}
-func (v *iterNative) readETInt32Uint32(et *typex.EventTime, key *int32, value *uint32) bool {
+func (v *iterNative) readFloat32Bool(key *float32, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7083,20 +6277,18 @@ func (v *iterNative) readETInt32Uint32(et *typex.EventTime, key *int32, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETInt32Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Uint32
+ ret.fn = ret.readFloat32Bool
return ret
}
-func (v *iterNative) readInt32Uint64(key *int32, value *uint64) bool {
+func (v *iterNative) readFloat32String(key *float32, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7104,18 +6296,18 @@ func (v *iterNative) readInt32Uint64(key *int32, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerInt32Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Uint64
+ ret.fn = ret.readFloat32String
return ret
}
-func (v *iterNative) readETInt32Uint64(et *typex.EventTime, key *int32, value *uint64) bool {
+func (v *iterNative) readFloat32Int(key *float32, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7123,20 +6315,18 @@ func (v *iterNative) readETInt32Uint64(et *typex.EventTime, key *int32, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETInt32Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Uint64
+ ret.fn = ret.readFloat32Int
return ret
}
-func (v *iterNative) readInt32Float32(key *int32, value *float32) bool {
+func (v *iterNative) readFloat32Int8(key *float32, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7144,18 +6334,18 @@ func (v *iterNative) readInt32Float32(key *int32, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerInt32Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Float32
+ ret.fn = ret.readFloat32Int8
return ret
}
-func (v *iterNative) readETInt32Float32(et *typex.EventTime, key *int32, value *float32) bool {
+func (v *iterNative) readFloat32Int16(key *float32, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7163,20 +6353,18 @@ func (v *iterNative) readETInt32Float32(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETInt32Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Float32
+ ret.fn = ret.readFloat32Int16
return ret
}
-func (v *iterNative) readInt32Float64(key *int32, value *float64) bool {
+func (v *iterNative) readFloat32Int32(key *float32, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7184,18 +6372,18 @@ func (v *iterNative) readInt32Float64(key *int32, value *float64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerInt32Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Float64
+ ret.fn = ret.readFloat32Int32
return ret
}
-func (v *iterNative) readETInt32Float64(et *typex.EventTime, key *int32, value *float64) bool {
+func (v *iterNative) readFloat32Int64(key *float32, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7203,20 +6391,18 @@ func (v *iterNative) readETInt32Float64(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(float64)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerETInt32Float64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Float64
+ ret.fn = ret.readFloat32Int64
return ret
}
-func (v *iterNative) readInt32Typex_T(key *int32, value *typex.T) bool {
+func (v *iterNative) readFloat32Uint(key *float32, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7224,18 +6410,18 @@ func (v *iterNative) readInt32Typex_T(key *int32, value *typex.T) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerInt32Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_T
+ ret.fn = ret.readFloat32Uint
return ret
}
-func (v *iterNative) readETInt32Typex_T(et *typex.EventTime, key *int32, value *typex.T) bool {
+func (v *iterNative) readFloat32Uint8(key *float32, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7243,20 +6429,18 @@ func (v *iterNative) readETInt32Typex_T(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.T)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerETInt32Typex_T(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_T
+ ret.fn = ret.readFloat32Uint8
return ret
}
-func (v *iterNative) readInt32Typex_U(key *int32, value *typex.U) bool {
+func (v *iterNative) readFloat32Uint16(key *float32, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7264,18 +6448,18 @@ func (v *iterNative) readInt32Typex_U(key *int32, value *typex.U) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerInt32Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_U
+ ret.fn = ret.readFloat32Uint16
return ret
}
-func (v *iterNative) readETInt32Typex_U(et *typex.EventTime, key *int32, value *typex.U) bool {
+func (v *iterNative) readFloat32Uint32(key *float32, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7283,20 +6467,18 @@ func (v *iterNative) readETInt32Typex_U(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.U)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerETInt32Typex_U(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_U
+ ret.fn = ret.readFloat32Uint32
return ret
}
-func (v *iterNative) readInt32Typex_V(key *int32, value *typex.V) bool {
+func (v *iterNative) readFloat32Uint64(key *float32, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7304,18 +6486,18 @@ func (v *iterNative) readInt32Typex_V(key *int32, value *typex.V) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerInt32Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_V
+ ret.fn = ret.readFloat32Uint64
return ret
}
-func (v *iterNative) readETInt32Typex_V(et *typex.EventTime, key *int32, value *typex.V) bool {
+func (v *iterNative) readFloat32Float32(key *float32, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7323,20 +6505,18 @@ func (v *iterNative) readETInt32Typex_V(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.V)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerETInt32Typex_V(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_V
+ ret.fn = ret.readFloat32Float32
return ret
}
-func (v *iterNative) readInt32Typex_W(key *int32, value *typex.W) bool {
+func (v *iterNative) readFloat32Float64(key *float32, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7344,18 +6524,18 @@ func (v *iterNative) readInt32Typex_W(key *int32, value *typex.W) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerInt32Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_W
+ ret.fn = ret.readFloat32Float64
return ret
}
-func (v *iterNative) readETInt32Typex_W(et *typex.EventTime, key *int32, value *typex.W) bool {
+func (v *iterNative) readFloat32Typex_T(key *float32, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7363,20 +6543,18 @@ func (v *iterNative) readETInt32Typex_W(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.W)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerETInt32Typex_W(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_W
+ ret.fn = ret.readFloat32Typex_T
return ret
}
-func (v *iterNative) readInt32Typex_X(key *int32, value *typex.X) bool {
+func (v *iterNative) readFloat32Typex_U(key *float32, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7384,18 +6562,18 @@ func (v *iterNative) readInt32Typex_X(key *int32, value *typex.X) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerInt32Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_X
+ ret.fn = ret.readFloat32Typex_U
return ret
}
-func (v *iterNative) readETInt32Typex_X(et *typex.EventTime, key *int32, value *typex.X) bool {
+func (v *iterNative) readFloat32Typex_V(key *float32, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7403,20 +6581,18 @@ func (v *iterNative) readETInt32Typex_X(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.X)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerETInt32Typex_X(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_X
+ ret.fn = ret.readFloat32Typex_V
return ret
}
-func (v *iterNative) readInt32Typex_Y(key *int32, value *typex.Y) bool {
+func (v *iterNative) readFloat32Typex_W(key *float32, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7424,18 +6600,18 @@ func (v *iterNative) readInt32Typex_Y(key *int32, value *typex.Y) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerInt32Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_Y
+ ret.fn = ret.readFloat32Typex_W
return ret
}
-func (v *iterNative) readETInt32Typex_Y(et *typex.EventTime, key *int32, value *typex.Y) bool {
+func (v *iterNative) readFloat32Typex_X(key *float32, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7443,20 +6619,18 @@ func (v *iterNative) readETInt32Typex_Y(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.Y)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerETInt32Typex_Y(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_Y
+ ret.fn = ret.readFloat32Typex_X
return ret
}
-func (v *iterNative) readInt32Typex_Z(key *int32, value *typex.Z) bool {
+func (v *iterNative) readFloat32Typex_Y(key *float32, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7464,18 +6638,18 @@ func (v *iterNative) readInt32Typex_Z(key *int32, value *typex.Z) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int32)
- *value = elm.Elm2.(typex.Z)
+ *key = elm.Elm.(float32)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerInt32Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt32Typex_Z
+ ret.fn = ret.readFloat32Typex_Y
return ret
}
-func (v *iterNative) readETInt32Typex_Z(et *typex.EventTime, key *int32, value *typex.Z) bool {
+func (v *iterNative) readFloat32Typex_Z(key *float32, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7483,20 +6657,18 @@ func (v *iterNative) readETInt32Typex_Z(et *typex.EventTime, key *int32, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int32)
+ *key = elm.Elm.(float32)
*value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerETInt32Typex_Z(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat32Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt32Typex_Z
+ ret.fn = ret.readFloat32Typex_Z
return ret
}
-func (v *iterNative) readInt64(val *int64) bool {
+func (v *iterNative) readFloat64(val *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7504,17 +6676,17 @@ func (v *iterNative) readInt64(val *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *val = elm.Elm.(int64)
+ *val = elm.Elm.(float64)
return true
}
-func iterMakerInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64
+ ret.fn = ret.readFloat64
return ret
}
-func (v *iterNative) readETInt64(et *typex.EventTime, val *int64) bool {
+func (v *iterNative) readFloat64ByteSlice(key *float64, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7522,19 +6694,18 @@ func (v *iterNative) readETInt64(et *typex.EventTime, val *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *val = elm.Elm.(int64)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerETInt64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64ByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64
+ ret.fn = ret.readFloat64ByteSlice
return ret
}
-func (v *iterNative) readInt64ByteSlice(key *int64, value *[]byte) bool {
+func (v *iterNative) readFloat64Bool(key *float64, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7542,18 +6713,18 @@ func (v *iterNative) readInt64ByteSlice(key *int64, value *[]byte) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerInt64ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Bool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64ByteSlice
+ ret.fn = ret.readFloat64Bool
return ret
}
-func (v *iterNative) readETInt64ByteSlice(et *typex.EventTime, key *int64, value *[]byte) bool {
+func (v *iterNative) readFloat64String(key *float64, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7561,20 +6732,18 @@ func (v *iterNative) readETInt64ByteSlice(et *typex.EventTime, key *int64, value
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.([]byte)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerETInt64ByteSlice(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64String(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64ByteSlice
+ ret.fn = ret.readFloat64String
return ret
}
-func (v *iterNative) readInt64Bool(key *int64, value *bool) bool {
+func (v *iterNative) readFloat64Int(key *float64, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7582,18 +6751,18 @@ func (v *iterNative) readInt64Bool(key *int64, value *bool) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerInt64Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Int(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Bool
+ ret.fn = ret.readFloat64Int
return ret
}
-func (v *iterNative) readETInt64Bool(et *typex.EventTime, key *int64, value *bool) bool {
+func (v *iterNative) readFloat64Int8(key *float64, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7601,20 +6770,18 @@ func (v *iterNative) readETInt64Bool(et *typex.EventTime, key *int64, value *boo
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(bool)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerETInt64Bool(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Int8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Bool
+ ret.fn = ret.readFloat64Int8
return ret
}
-func (v *iterNative) readInt64String(key *int64, value *string) bool {
+func (v *iterNative) readFloat64Int16(key *float64, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7622,18 +6789,18 @@ func (v *iterNative) readInt64String(key *int64, value *string) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerInt64String(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Int16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64String
+ ret.fn = ret.readFloat64Int16
return ret
}
-func (v *iterNative) readETInt64String(et *typex.EventTime, key *int64, value *string) bool {
+func (v *iterNative) readFloat64Int32(key *float64, value *int32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7641,20 +6808,18 @@ func (v *iterNative) readETInt64String(et *typex.EventTime, key *int64, value *s
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(string)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(int32)
return true
}
-func iterMakerETInt64String(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Int32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64String
+ ret.fn = ret.readFloat64Int32
return ret
}
-func (v *iterNative) readInt64Int(key *int64, value *int) bool {
+func (v *iterNative) readFloat64Int64(key *float64, value *int64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7662,18 +6827,18 @@ func (v *iterNative) readInt64Int(key *int64, value *int) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(int64)
return true
}
-func iterMakerInt64Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Int64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Int
+ ret.fn = ret.readFloat64Int64
return ret
}
-func (v *iterNative) readETInt64Int(et *typex.EventTime, key *int64, value *int) bool {
+func (v *iterNative) readFloat64Uint(key *float64, value *uint) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7681,20 +6846,18 @@ func (v *iterNative) readETInt64Int(et *typex.EventTime, key *int64, value *int)
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(uint)
return true
}
-func iterMakerETInt64Int(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Uint(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Int
+ ret.fn = ret.readFloat64Uint
return ret
}
-func (v *iterNative) readInt64Int8(key *int64, value *int8) bool {
+func (v *iterNative) readFloat64Uint8(key *float64, value *uint8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7702,18 +6865,18 @@ func (v *iterNative) readInt64Int8(key *int64, value *int8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(uint8)
return true
}
-func iterMakerInt64Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Uint8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Int8
+ ret.fn = ret.readFloat64Uint8
return ret
}
-func (v *iterNative) readETInt64Int8(et *typex.EventTime, key *int64, value *int8) bool {
+func (v *iterNative) readFloat64Uint16(key *float64, value *uint16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7721,20 +6884,18 @@ func (v *iterNative) readETInt64Int8(et *typex.EventTime, key *int64, value *int
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int8)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(uint16)
return true
}
-func iterMakerETInt64Int8(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Uint16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Int8
+ ret.fn = ret.readFloat64Uint16
return ret
}
-func (v *iterNative) readInt64Int16(key *int64, value *int16) bool {
+func (v *iterNative) readFloat64Uint32(key *float64, value *uint32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7742,18 +6903,18 @@ func (v *iterNative) readInt64Int16(key *int64, value *int16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(uint32)
return true
}
-func iterMakerInt64Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Uint32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Int16
+ ret.fn = ret.readFloat64Uint32
return ret
}
-func (v *iterNative) readETInt64Int16(et *typex.EventTime, key *int64, value *int16) bool {
+func (v *iterNative) readFloat64Uint64(key *float64, value *uint64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7761,20 +6922,18 @@ func (v *iterNative) readETInt64Int16(et *typex.EventTime, key *int64, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int16)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(uint64)
return true
}
-func iterMakerETInt64Int16(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Uint64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Int16
+ ret.fn = ret.readFloat64Uint64
return ret
}
-func (v *iterNative) readInt64Int32(key *int64, value *int32) bool {
+func (v *iterNative) readFloat64Float32(key *float64, value *float32) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7782,18 +6941,18 @@ func (v *iterNative) readInt64Int32(key *int64, value *int32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(float32)
return true
}
-func iterMakerInt64Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Float32(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Int32
+ ret.fn = ret.readFloat64Float32
return ret
}
-func (v *iterNative) readETInt64Int32(et *typex.EventTime, key *int64, value *int32) bool {
+func (v *iterNative) readFloat64Float64(key *float64, value *float64) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7801,20 +6960,18 @@ func (v *iterNative) readETInt64Int32(et *typex.EventTime, key *int64, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int32)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(float64)
return true
}
-func iterMakerETInt64Int32(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Float64(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Int32
+ ret.fn = ret.readFloat64Float64
return ret
}
-func (v *iterNative) readInt64Int64(key *int64, value *int64) bool {
+func (v *iterNative) readFloat64Typex_T(key *float64, value *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7822,18 +6979,18 @@ func (v *iterNative) readInt64Int64(key *int64, value *int64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.T)
return true
}
-func iterMakerInt64Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Int64
+ ret.fn = ret.readFloat64Typex_T
return ret
}
-func (v *iterNative) readETInt64Int64(et *typex.EventTime, key *int64, value *int64) bool {
+func (v *iterNative) readFloat64Typex_U(key *float64, value *typex.U) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7841,20 +6998,18 @@ func (v *iterNative) readETInt64Int64(et *typex.EventTime, key *int64, value *in
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(int64)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.U)
return true
}
-func iterMakerETInt64Int64(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_U(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Int64
+ ret.fn = ret.readFloat64Typex_U
return ret
}
-func (v *iterNative) readInt64Uint(key *int64, value *uint) bool {
+func (v *iterNative) readFloat64Typex_V(key *float64, value *typex.V) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7862,18 +7017,18 @@ func (v *iterNative) readInt64Uint(key *int64, value *uint) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.V)
return true
}
-func iterMakerInt64Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_V(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Uint
+ ret.fn = ret.readFloat64Typex_V
return ret
}
-func (v *iterNative) readETInt64Uint(et *typex.EventTime, key *int64, value *uint) bool {
+func (v *iterNative) readFloat64Typex_W(key *float64, value *typex.W) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7881,20 +7036,18 @@ func (v *iterNative) readETInt64Uint(et *typex.EventTime, key *int64, value *uin
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.W)
return true
}
-func iterMakerETInt64Uint(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_W(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Uint
+ ret.fn = ret.readFloat64Typex_W
return ret
}
-func (v *iterNative) readInt64Uint8(key *int64, value *uint8) bool {
+func (v *iterNative) readFloat64Typex_X(key *float64, value *typex.X) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7902,18 +7055,18 @@ func (v *iterNative) readInt64Uint8(key *int64, value *uint8) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.X)
return true
}
-func iterMakerInt64Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_X(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Uint8
+ ret.fn = ret.readFloat64Typex_X
return ret
}
-func (v *iterNative) readETInt64Uint8(et *typex.EventTime, key *int64, value *uint8) bool {
+func (v *iterNative) readFloat64Typex_Y(key *float64, value *typex.Y) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7921,20 +7074,18 @@ func (v *iterNative) readETInt64Uint8(et *typex.EventTime, key *int64, value *ui
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint8)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.Y)
return true
}
-func iterMakerETInt64Uint8(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_Y(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Uint8
+ ret.fn = ret.readFloat64Typex_Y
return ret
}
-func (v *iterNative) readInt64Uint16(key *int64, value *uint16) bool {
+func (v *iterNative) readFloat64Typex_Z(key *float64, value *typex.Z) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7942,18 +7093,18 @@ func (v *iterNative) readInt64Uint16(key *int64, value *uint16) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint16)
+ *key = elm.Elm.(float64)
+ *value = elm.Elm2.(typex.Z)
return true
}
-func iterMakerInt64Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerFloat64Typex_Z(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Uint16
+ ret.fn = ret.readFloat64Typex_Z
return ret
}
-func (v *iterNative) readETInt64Uint16(et *typex.EventTime, key *int64, value *uint16) bool {
+func (v *iterNative) readTypex_T(val *typex.T) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7961,20 +7112,17 @@ func (v *iterNative) readETInt64Uint16(et *typex.EventTime, key *int64, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint16)
+ *val = elm.Elm.(typex.T)
return true
}
-func iterMakerETInt64Uint16(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_T(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Uint16
+ ret.fn = ret.readTypex_T
return ret
}
-func (v *iterNative) readInt64Uint32(key *int64, value *uint32) bool {
+func (v *iterNative) readTypex_TByteSlice(key *typex.T, value *[]byte) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -7982,18 +7130,18 @@ func (v *iterNative) readInt64Uint32(key *int64, value *uint32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.([]byte)
return true
}
-func iterMakerInt64Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TByteSlice(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Uint32
+ ret.fn = ret.readTypex_TByteSlice
return ret
}
-func (v *iterNative) readETInt64Uint32(et *typex.EventTime, key *int64, value *uint32) bool {
+func (v *iterNative) readTypex_TBool(key *typex.T, value *bool) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -8001,20 +7149,18 @@ func (v *iterNative) readETInt64Uint32(et *typex.EventTime, key *int64, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint32)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.(bool)
return true
}
-func iterMakerETInt64Uint32(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TBool(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Uint32
+ ret.fn = ret.readTypex_TBool
return ret
}
-func (v *iterNative) readInt64Uint64(key *int64, value *uint64) bool {
+func (v *iterNative) readTypex_TString(key *typex.T, value *string) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -8022,18 +7168,18 @@ func (v *iterNative) readInt64Uint64(key *int64, value *uint64) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.(string)
return true
}
-func iterMakerInt64Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TString(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Uint64
+ ret.fn = ret.readTypex_TString
return ret
}
-func (v *iterNative) readETInt64Uint64(et *typex.EventTime, key *int64, value *uint64) bool {
+func (v *iterNative) readTypex_TInt(key *typex.T, value *int) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -8041,20 +7187,18 @@ func (v *iterNative) readETInt64Uint64(et *typex.EventTime, key *int64, value *u
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(uint64)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.(int)
return true
}
-func iterMakerETInt64Uint64(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TInt(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Uint64
+ ret.fn = ret.readTypex_TInt
return ret
}
-func (v *iterNative) readInt64Float32(key *int64, value *float32) bool {
+func (v *iterNative) readTypex_TInt8(key *typex.T, value *int8) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -8062,18 +7206,18 @@ func (v *iterNative) readInt64Float32(key *int64, value *float32) bool {
}
panic(fmt.Sprintf("broken stream: %v", err))
}
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.(int8)
return true
}
-func iterMakerInt64Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TInt8(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readInt64Float32
+ ret.fn = ret.readTypex_TInt8
return ret
}
-func (v *iterNative) readETInt64Float32(et *typex.EventTime, key *int64, value *float32) bool {
+func (v *iterNative) readTypex_TInt16(key *typex.T, value *int16) bool {
elm, err := v.cur.Read()
if err != nil {
if err == io.EOF {
@@ -8081,9878 +7225,18 @@ func (v *iterNative) readETInt64Float32(et *typex.EventTime, key *int64, value *
}
panic(fmt.Sprintf("broken stream: %v", err))
}
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(float32)
+ *key = elm.Elm.(typex.T)
+ *value = elm.Elm2.(int16)
return true
}
-func iterMakerETInt64Float32(s exec.ReStream) exec.ReusableInput {
+func iterMakerTypex_TInt16(s exec.ReStream) exec.ReusableInput {
ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Float32
+ ret.fn = ret.readTypex_TInt16
return ret
}
-func (v *iterNative) readInt64Float64(key *int64, value *float64) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(float64)
- return true
-}
-
-func iterMakerInt64Float64(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readInt64Float64
- return ret
-}
-
-func (v *iterNative) readETInt64Float64(et *typex.EventTime, key *int64, value *float64) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(float64)
- return true
-}
-
-func iterMakerETInt64Float64(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Float64
- return ret
-}
-
-func (v *iterNative) readInt64Typex_T(key *int64, value *typex.T) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(typex.T)
- return true
-}
-
-func iterMakerInt64Typex_T(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readInt64Typex_T
- return ret
-}
-
-func (v *iterNative) readETInt64Typex_T(et *typex.EventTime, key *int64, value *typex.T) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(typex.T)
- return true
-}
-
-func iterMakerETInt64Typex_T(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Typex_T
- return ret
-}
-
-func (v *iterNative) readInt64Typex_U(key *int64, value *typex.U) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(typex.U)
- return true
-}
-
-func iterMakerInt64Typex_U(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readInt64Typex_U
- return ret
-}
-
-func (v *iterNative) readETInt64Typex_U(et *typex.EventTime, key *int64, value *typex.U) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
-
- *et = elm.Timestamp
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(typex.U)
- return true
-}
-
-func iterMakerETInt64Typex_U(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readETInt64Typex_U
- return ret
-}
-
-func (v *iterNative) readInt64Typex_V(key *int64, value *typex.V) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
- }
- panic(fmt.Sprintf("broken stream: %v", err))
- }
- *key = elm.Elm.(int64)
- *value = elm.Elm2.(typex.V)
- return true
-}
-
-func iterMakerInt64Typex_V(s exec.ReStream) exec.ReusableInput {
- ret := &iterNative{s: s}
- ret.fn = ret.readInt64Typex_V
- return ret
-}
-
-func (v *iterNative) readETInt64Typex_V(et *typex.EventTime, key *int64, value *typex.V) bool {
- elm, err := v.cur.Read()
- if err != nil {
- if err == io.EOF {
- return false
... 13822 lines suppressed ...