You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@beam.apache.org by lc...@apache.org on 2018/01/19 23:52:52 UTC
[beam] branch go-sdk updated (c5a3ce0 -> e019f19)
This is an automated email from the ASF dual-hosted git repository.
lcwik pushed a change to branch go-sdk
in repository https://gitbox.apache.org/repos/asf/beam.git.
from c5a3ce0 Add initialization of active plans map.
new c67de93 Renamed Go runtime Caller to Func and added name
new 09e98e4 Use reflectx.Func as the fundamental function representation
new 8a9d916 CR: fix DynFn comments
new e019f19 CR: fix comments
The 4 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
Summary of changes:
sdks/go/cmd/symtab/main.go | 4 +-
sdks/go/pkg/beam/core/funcx/fn.go | 37 +-
sdks/go/pkg/beam/core/funcx/fn_test.go | 3 +-
sdks/go/pkg/beam/core/graph/bind_test.go | 4 +-
sdks/go/pkg/beam/core/graph/coder/coder.go | 8 +-
sdks/go/pkg/beam/core/graph/edge.go | 4 +-
sdks/go/pkg/beam/core/graph/fn.go | 34 +-
sdks/go/pkg/beam/core/runtime/exec/callers.go | 544 -
sdks/go/pkg/beam/core/runtime/exec/coder.go | 8 +-
sdks/go/pkg/beam/core/runtime/exec/combine.go | 4 +-
sdks/go/pkg/beam/core/runtime/exec/decode.go | 108 +-
sdks/go/pkg/beam/core/runtime/exec/decoders.go | 1347 --
sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl | 89 -
sdks/go/pkg/beam/core/runtime/exec/emit.go | 2 -
sdks/go/pkg/beam/core/runtime/exec/emitters.go | 14214 ------------------
sdks/go/pkg/beam/core/runtime/exec/encode.go | 109 +-
sdks/go/pkg/beam/core/runtime/exec/encoders.go | 1171 --
sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl | 81 -
sdks/go/pkg/beam/core/runtime/exec/fn.go | 19 +-
sdks/go/pkg/beam/core/runtime/exec/fn_test.go | 15 +-
sdks/go/pkg/beam/core/runtime/exec/input.go | 2 -
.../beam/core/runtime/exec/optimized/callers.go | 632 +
.../core/runtime/exec/{ => optimized}/callers.tmpl | 24 +-
.../beam/core/runtime/exec/optimized/decoders.go | 2407 ++++
.../beam/core/runtime/exec/optimized/decoders.tmpl | 146 +
.../beam/core/runtime/exec/optimized/emitters.go | 14215 +++++++++++++++++++
.../runtime/exec/{ => optimized}/emitters.tmpl | 32 +-
.../beam/core/runtime/exec/optimized/encoders.go | 2299 +++
.../beam/core/runtime/exec/optimized/encoders.tmpl | 146 +
.../scope.go => runtime/exec/optimized/gen.go} | 30 +-
.../core/runtime/exec/{ => optimized}/inputs.go | 4055 +++---
.../core/runtime/exec/{ => optimized}/inputs.tmpl | 26 +-
sdks/go/pkg/beam/core/runtime/exec/util.go | 11 -
sdks/go/pkg/beam/core/runtime/graphx/serialize.go | 11 +-
sdks/go/pkg/beam/core/runtime/graphx/translate.go | 2 +-
sdks/go/pkg/beam/core/runtime/graphx/user.go | 11 +-
sdks/go/pkg/beam/core/util/reflectx/call.go | 64 +-
sdks/go/pkg/beam/core/util/reflectx/calls.go | 968 +-
sdks/go/pkg/beam/core/util/reflectx/calls.tmpl | 38 +-
sdks/go/pkg/beam/core/util/reflectx/json.go | 2 +-
sdks/go/pkg/beam/encoding.go | 23 +-
sdks/go/pkg/beam/partition.go | 62 +-
sdks/go/pkg/beam/transforms/filter/filter.go | 10 +-
sdks/go/pkg/beam/transforms/top/top.go | 33 +-
sdks/go/pkg/beam/transforms/top/top_test.go | 7 +-
sdks/go/pkg/beam/x/beamx/run.go | 2 +
46 files changed, 22823 insertions(+), 20240 deletions(-)
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/callers.go
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/decoders.go
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/emitters.go
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/encoders.go
delete mode 100644 sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/callers.go
rename sdks/go/pkg/beam/core/runtime/exec/{ => optimized}/callers.tmpl (72%)
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/decoders.go
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/decoders.tmpl
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/emitters.go
rename sdks/go/pkg/beam/core/runtime/exec/{ => optimized}/emitters.tmpl (64%)
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/encoders.go
create mode 100644 sdks/go/pkg/beam/core/runtime/exec/optimized/encoders.tmpl
copy sdks/go/pkg/beam/core/{graph/scope.go => runtime/exec/optimized/gen.go} (51%)
rename sdks/go/pkg/beam/core/runtime/exec/{ => optimized}/inputs.go (70%)
rename sdks/go/pkg/beam/core/runtime/exec/{ => optimized}/inputs.tmpl (76%)
--
To stop receiving notification emails like this one, please contact
['"commits@beam.apache.org" <co...@beam.apache.org>'].
[beam] 01/04: Renamed Go runtime Caller to Func and added name
Posted by lc...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lcwik pushed a commit to branch go-sdk
in repository https://gitbox.apache.org/repos/asf/beam.git
commit c67de937c7d732d68ef363ff46c18b77916938d5
Author: Henning Rohde <he...@google.com>
AuthorDate: Fri Jan 12 15:13:26 2018 -0800
Renamed Go runtime Caller to Func and added name
---
sdks/go/pkg/beam/core/runtime/exec/callers.go | 400 ++++++----
sdks/go/pkg/beam/core/runtime/exec/callers.tmpl | 18 +-
sdks/go/pkg/beam/core/runtime/exec/combine.go | 4 +-
sdks/go/pkg/beam/core/util/reflectx/call.go | 51 +-
sdks/go/pkg/beam/core/util/reflectx/calls.go | 968 ++++++++++++++----------
sdks/go/pkg/beam/core/util/reflectx/calls.tmpl | 38 +-
sdks/go/pkg/beam/core/util/reflectx/json.go | 2 +-
sdks/go/pkg/beam/transforms/filter/filter.go | 4 +-
8 files changed, 858 insertions(+), 627 deletions(-)
diff --git a/sdks/go/pkg/beam/core/runtime/exec/callers.go b/sdks/go/pkg/beam/core/runtime/exec/callers.go
index 8c374bf..b47751d 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/callers.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/callers.go
@@ -35,510 +35,598 @@ import (
// For now, we just do #2.
func init() {
- reflectx.RegisterCaller(reflect.TypeOf((*func([]byte, []byte) []byte)(nil)).Elem(), callMakerByteSliceM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(bool, bool) bool)(nil)).Elem(), callMakerBoolM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(string, string) string)(nil)).Elem(), callMakerStringM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(int, int) int)(nil)).Elem(), callMakerIntM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(int8, int8) int8)(nil)).Elem(), callMakerInt8M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(int16, int16) int16)(nil)).Elem(), callMakerInt16M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(int32, int32) int32)(nil)).Elem(), callMakerInt32M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(int64, int64) int64)(nil)).Elem(), callMakerInt64M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(uint, uint) uint)(nil)).Elem(), callMakerUintM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(uint8, uint8) uint8)(nil)).Elem(), callMakerUint8M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(uint16, uint16) uint16)(nil)).Elem(), callMakerUint16M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(uint32, uint32) uint32)(nil)).Elem(), callMakerUint32M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(uint64, uint64) uint64)(nil)).Elem(), callMakerUint64M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(float32, float32) float32)(nil)).Elem(), callMakerFloat32M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(float64, float64) float64)(nil)).Elem(), callMakerFloat64M)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.T, typex.T) typex.T)(nil)).Elem(), callMakerTypex_TM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.U, typex.U) typex.U)(nil)).Elem(), callMakerTypex_UM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.V, typex.V) typex.V)(nil)).Elem(), callMakerTypex_VM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.W, typex.W) typex.W)(nil)).Elem(), callMakerTypex_WM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.X, typex.X) typex.X)(nil)).Elem(), callMakerTypex_XM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.Y, typex.Y) typex.Y)(nil)).Elem(), callMakerTypex_YM)
- reflectx.RegisterCaller(reflect.TypeOf((*func(typex.Z, typex.Z) typex.Z)(nil)).Elem(), callMakerTypex_ZM)
-}
-
-type nativeByteSliceMCaller struct {
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte, []byte) []byte)(nil)).Elem(), funcMakerByteSliceM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(bool, bool) bool)(nil)).Elem(), funcMakerBoolM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(string, string) string)(nil)).Elem(), funcMakerStringM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int, int) int)(nil)).Elem(), funcMakerIntM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int8, int8) int8)(nil)).Elem(), funcMakerInt8M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int16, int16) int16)(nil)).Elem(), funcMakerInt16M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int32, int32) int32)(nil)).Elem(), funcMakerInt32M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int64, int64) int64)(nil)).Elem(), funcMakerInt64M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint, uint) uint)(nil)).Elem(), funcMakerUintM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint8, uint8) uint8)(nil)).Elem(), funcMakerUint8M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint16, uint16) uint16)(nil)).Elem(), funcMakerUint16M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint32, uint32) uint32)(nil)).Elem(), funcMakerUint32M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint64, uint64) uint64)(nil)).Elem(), funcMakerUint64M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(float32, float32) float32)(nil)).Elem(), funcMakerFloat32M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(float64, float64) float64)(nil)).Elem(), funcMakerFloat64M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T, typex.T) typex.T)(nil)).Elem(), funcMakerTypex_TM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.U, typex.U) typex.U)(nil)).Elem(), funcMakerTypex_UM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.V, typex.V) typex.V)(nil)).Elem(), funcMakerTypex_VM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.W, typex.W) typex.W)(nil)).Elem(), funcMakerTypex_WM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, typex.X) typex.X)(nil)).Elem(), funcMakerTypex_XM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.Y, typex.Y) typex.Y)(nil)).Elem(), funcMakerTypex_YM)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.Z, typex.Z) typex.Z)(nil)).Elem(), funcMakerTypex_ZM)
+}
+
+type nativeByteSliceMFunc struct {
fn func([]byte, []byte) []byte
}
-func callMakerByteSliceM(fn interface{}) reflectx.Caller {
+func funcMakerByteSliceM(fn interface{}) reflectx.Func {
f := fn.(func([]byte, []byte) []byte)
- return &nativeByteSliceMCaller{fn: f}
+ return &nativeByteSliceMFunc{fn: f}
}
-func (c *nativeByteSliceMCaller) Type() reflect.Type {
+func (c *nativeByteSliceMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeByteSliceMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeByteSliceMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeByteSliceMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].([]byte), args[1].([]byte))
return []interface{}{out}
}
-func (c *nativeByteSliceMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeByteSliceMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.([]byte), b.([]byte))
}
-type nativeBoolMCaller struct {
+type nativeBoolMFunc struct {
fn func(bool, bool) bool
}
-func callMakerBoolM(fn interface{}) reflectx.Caller {
+func funcMakerBoolM(fn interface{}) reflectx.Func {
f := fn.(func(bool, bool) bool)
- return &nativeBoolMCaller{fn: f}
+ return &nativeBoolMFunc{fn: f}
+}
+
+func (c *nativeBoolMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeBoolMCaller) Type() reflect.Type {
+func (c *nativeBoolMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeBoolMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeBoolMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(bool), args[1].(bool))
return []interface{}{out}
}
-func (c *nativeBoolMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeBoolMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(bool), b.(bool))
}
-type nativeStringMCaller struct {
+type nativeStringMFunc struct {
fn func(string, string) string
}
-func callMakerStringM(fn interface{}) reflectx.Caller {
+func funcMakerStringM(fn interface{}) reflectx.Func {
f := fn.(func(string, string) string)
- return &nativeStringMCaller{fn: f}
+ return &nativeStringMFunc{fn: f}
+}
+
+func (c *nativeStringMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeStringMCaller) Type() reflect.Type {
+func (c *nativeStringMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeStringMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeStringMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(string), args[1].(string))
return []interface{}{out}
}
-func (c *nativeStringMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeStringMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(string), b.(string))
}
-type nativeIntMCaller struct {
+type nativeIntMFunc struct {
fn func(int, int) int
}
-func callMakerIntM(fn interface{}) reflectx.Caller {
+func funcMakerIntM(fn interface{}) reflectx.Func {
f := fn.(func(int, int) int)
- return &nativeIntMCaller{fn: f}
+ return &nativeIntMFunc{fn: f}
}
-func (c *nativeIntMCaller) Type() reflect.Type {
+func (c *nativeIntMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeIntMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeIntMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeIntMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(int), args[1].(int))
return []interface{}{out}
}
-func (c *nativeIntMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeIntMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(int), b.(int))
}
-type nativeInt8MCaller struct {
+type nativeInt8MFunc struct {
fn func(int8, int8) int8
}
-func callMakerInt8M(fn interface{}) reflectx.Caller {
+func funcMakerInt8M(fn interface{}) reflectx.Func {
f := fn.(func(int8, int8) int8)
- return &nativeInt8MCaller{fn: f}
+ return &nativeInt8MFunc{fn: f}
}
-func (c *nativeInt8MCaller) Type() reflect.Type {
+func (c *nativeInt8MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeInt8MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeInt8MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeInt8MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(int8), args[1].(int8))
return []interface{}{out}
}
-func (c *nativeInt8MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeInt8MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(int8), b.(int8))
}
-type nativeInt16MCaller struct {
+type nativeInt16MFunc struct {
fn func(int16, int16) int16
}
-func callMakerInt16M(fn interface{}) reflectx.Caller {
+func funcMakerInt16M(fn interface{}) reflectx.Func {
f := fn.(func(int16, int16) int16)
- return &nativeInt16MCaller{fn: f}
+ return &nativeInt16MFunc{fn: f}
+}
+
+func (c *nativeInt16MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeInt16MCaller) Type() reflect.Type {
+func (c *nativeInt16MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeInt16MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeInt16MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(int16), args[1].(int16))
return []interface{}{out}
}
-func (c *nativeInt16MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeInt16MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(int16), b.(int16))
}
-type nativeInt32MCaller struct {
+type nativeInt32MFunc struct {
fn func(int32, int32) int32
}
-func callMakerInt32M(fn interface{}) reflectx.Caller {
+func funcMakerInt32M(fn interface{}) reflectx.Func {
f := fn.(func(int32, int32) int32)
- return &nativeInt32MCaller{fn: f}
+ return &nativeInt32MFunc{fn: f}
+}
+
+func (c *nativeInt32MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeInt32MCaller) Type() reflect.Type {
+func (c *nativeInt32MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeInt32MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeInt32MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(int32), args[1].(int32))
return []interface{}{out}
}
-func (c *nativeInt32MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeInt32MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(int32), b.(int32))
}
-type nativeInt64MCaller struct {
+type nativeInt64MFunc struct {
fn func(int64, int64) int64
}
-func callMakerInt64M(fn interface{}) reflectx.Caller {
+func funcMakerInt64M(fn interface{}) reflectx.Func {
f := fn.(func(int64, int64) int64)
- return &nativeInt64MCaller{fn: f}
+ return &nativeInt64MFunc{fn: f}
}
-func (c *nativeInt64MCaller) Type() reflect.Type {
+func (c *nativeInt64MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeInt64MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeInt64MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeInt64MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(int64), args[1].(int64))
return []interface{}{out}
}
-func (c *nativeInt64MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeInt64MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(int64), b.(int64))
}
-type nativeUintMCaller struct {
+type nativeUintMFunc struct {
fn func(uint, uint) uint
}
-func callMakerUintM(fn interface{}) reflectx.Caller {
+func funcMakerUintM(fn interface{}) reflectx.Func {
f := fn.(func(uint, uint) uint)
- return &nativeUintMCaller{fn: f}
+ return &nativeUintMFunc{fn: f}
}
-func (c *nativeUintMCaller) Type() reflect.Type {
+func (c *nativeUintMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeUintMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeUintMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeUintMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(uint), args[1].(uint))
return []interface{}{out}
}
-func (c *nativeUintMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeUintMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(uint), b.(uint))
}
-type nativeUint8MCaller struct {
+type nativeUint8MFunc struct {
fn func(uint8, uint8) uint8
}
-func callMakerUint8M(fn interface{}) reflectx.Caller {
+func funcMakerUint8M(fn interface{}) reflectx.Func {
f := fn.(func(uint8, uint8) uint8)
- return &nativeUint8MCaller{fn: f}
+ return &nativeUint8MFunc{fn: f}
+}
+
+func (c *nativeUint8MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeUint8MCaller) Type() reflect.Type {
+func (c *nativeUint8MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeUint8MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeUint8MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(uint8), args[1].(uint8))
return []interface{}{out}
}
-func (c *nativeUint8MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeUint8MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(uint8), b.(uint8))
}
-type nativeUint16MCaller struct {
+type nativeUint16MFunc struct {
fn func(uint16, uint16) uint16
}
-func callMakerUint16M(fn interface{}) reflectx.Caller {
+func funcMakerUint16M(fn interface{}) reflectx.Func {
f := fn.(func(uint16, uint16) uint16)
- return &nativeUint16MCaller{fn: f}
+ return &nativeUint16MFunc{fn: f}
+}
+
+func (c *nativeUint16MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeUint16MCaller) Type() reflect.Type {
+func (c *nativeUint16MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeUint16MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeUint16MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(uint16), args[1].(uint16))
return []interface{}{out}
}
-func (c *nativeUint16MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeUint16MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(uint16), b.(uint16))
}
-type nativeUint32MCaller struct {
+type nativeUint32MFunc struct {
fn func(uint32, uint32) uint32
}
-func callMakerUint32M(fn interface{}) reflectx.Caller {
+func funcMakerUint32M(fn interface{}) reflectx.Func {
f := fn.(func(uint32, uint32) uint32)
- return &nativeUint32MCaller{fn: f}
+ return &nativeUint32MFunc{fn: f}
}
-func (c *nativeUint32MCaller) Type() reflect.Type {
+func (c *nativeUint32MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeUint32MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeUint32MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeUint32MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(uint32), args[1].(uint32))
return []interface{}{out}
}
-func (c *nativeUint32MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeUint32MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(uint32), b.(uint32))
}
-type nativeUint64MCaller struct {
+type nativeUint64MFunc struct {
fn func(uint64, uint64) uint64
}
-func callMakerUint64M(fn interface{}) reflectx.Caller {
+func funcMakerUint64M(fn interface{}) reflectx.Func {
f := fn.(func(uint64, uint64) uint64)
- return &nativeUint64MCaller{fn: f}
+ return &nativeUint64MFunc{fn: f}
+}
+
+func (c *nativeUint64MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeUint64MCaller) Type() reflect.Type {
+func (c *nativeUint64MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeUint64MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeUint64MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(uint64), args[1].(uint64))
return []interface{}{out}
}
-func (c *nativeUint64MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeUint64MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(uint64), b.(uint64))
}
-type nativeFloat32MCaller struct {
+type nativeFloat32MFunc struct {
fn func(float32, float32) float32
}
-func callMakerFloat32M(fn interface{}) reflectx.Caller {
+func funcMakerFloat32M(fn interface{}) reflectx.Func {
f := fn.(func(float32, float32) float32)
- return &nativeFloat32MCaller{fn: f}
+ return &nativeFloat32MFunc{fn: f}
+}
+
+func (c *nativeFloat32MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeFloat32MCaller) Type() reflect.Type {
+func (c *nativeFloat32MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeFloat32MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeFloat32MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(float32), args[1].(float32))
return []interface{}{out}
}
-func (c *nativeFloat32MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeFloat32MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(float32), b.(float32))
}
-type nativeFloat64MCaller struct {
+type nativeFloat64MFunc struct {
fn func(float64, float64) float64
}
-func callMakerFloat64M(fn interface{}) reflectx.Caller {
+func funcMakerFloat64M(fn interface{}) reflectx.Func {
f := fn.(func(float64, float64) float64)
- return &nativeFloat64MCaller{fn: f}
+ return &nativeFloat64MFunc{fn: f}
}
-func (c *nativeFloat64MCaller) Type() reflect.Type {
+func (c *nativeFloat64MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeFloat64MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeFloat64MCaller) Call(args []interface{}) []interface{} {
+func (c *nativeFloat64MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(float64), args[1].(float64))
return []interface{}{out}
}
-func (c *nativeFloat64MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeFloat64MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(float64), b.(float64))
}
-type nativeTypex_TMCaller struct {
+type nativeTypex_TMFunc struct {
fn func(typex.T, typex.T) typex.T
}
-func callMakerTypex_TM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_TM(fn interface{}) reflectx.Func {
f := fn.(func(typex.T, typex.T) typex.T)
- return &nativeTypex_TMCaller{fn: f}
+ return &nativeTypex_TMFunc{fn: f}
}
-func (c *nativeTypex_TMCaller) Type() reflect.Type {
+func (c *nativeTypex_TMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeTypex_TMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_TMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_TMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.T), args[1].(typex.T))
return []interface{}{out}
}
-func (c *nativeTypex_TMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_TMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.T), b.(typex.T))
}
-type nativeTypex_UMCaller struct {
+type nativeTypex_UMFunc struct {
fn func(typex.U, typex.U) typex.U
}
-func callMakerTypex_UM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_UM(fn interface{}) reflectx.Func {
f := fn.(func(typex.U, typex.U) typex.U)
- return &nativeTypex_UMCaller{fn: f}
+ return &nativeTypex_UMFunc{fn: f}
+}
+
+func (c *nativeTypex_UMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeTypex_UMCaller) Type() reflect.Type {
+func (c *nativeTypex_UMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_UMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_UMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.U), args[1].(typex.U))
return []interface{}{out}
}
-func (c *nativeTypex_UMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_UMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.U), b.(typex.U))
}
-type nativeTypex_VMCaller struct {
+type nativeTypex_VMFunc struct {
fn func(typex.V, typex.V) typex.V
}
-func callMakerTypex_VM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_VM(fn interface{}) reflectx.Func {
f := fn.(func(typex.V, typex.V) typex.V)
- return &nativeTypex_VMCaller{fn: f}
+ return &nativeTypex_VMFunc{fn: f}
+}
+
+func (c *nativeTypex_VMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeTypex_VMCaller) Type() reflect.Type {
+func (c *nativeTypex_VMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_VMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_VMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.V), args[1].(typex.V))
return []interface{}{out}
}
-func (c *nativeTypex_VMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_VMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.V), b.(typex.V))
}
-type nativeTypex_WMCaller struct {
+type nativeTypex_WMFunc struct {
fn func(typex.W, typex.W) typex.W
}
-func callMakerTypex_WM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_WM(fn interface{}) reflectx.Func {
f := fn.(func(typex.W, typex.W) typex.W)
- return &nativeTypex_WMCaller{fn: f}
+ return &nativeTypex_WMFunc{fn: f}
}
-func (c *nativeTypex_WMCaller) Type() reflect.Type {
+func (c *nativeTypex_WMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeTypex_WMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_WMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_WMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.W), args[1].(typex.W))
return []interface{}{out}
}
-func (c *nativeTypex_WMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_WMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.W), b.(typex.W))
}
-type nativeTypex_XMCaller struct {
+type nativeTypex_XMFunc struct {
fn func(typex.X, typex.X) typex.X
}
-func callMakerTypex_XM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_XM(fn interface{}) reflectx.Func {
f := fn.(func(typex.X, typex.X) typex.X)
- return &nativeTypex_XMCaller{fn: f}
+ return &nativeTypex_XMFunc{fn: f}
}
-func (c *nativeTypex_XMCaller) Type() reflect.Type {
+func (c *nativeTypex_XMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *nativeTypex_XMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_XMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_XMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.X), args[1].(typex.X))
return []interface{}{out}
}
-func (c *nativeTypex_XMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_XMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.X), b.(typex.X))
}
-type nativeTypex_YMCaller struct {
+type nativeTypex_YMFunc struct {
fn func(typex.Y, typex.Y) typex.Y
}
-func callMakerTypex_YM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_YM(fn interface{}) reflectx.Func {
f := fn.(func(typex.Y, typex.Y) typex.Y)
- return &nativeTypex_YMCaller{fn: f}
+ return &nativeTypex_YMFunc{fn: f}
+}
+
+func (c *nativeTypex_YMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeTypex_YMCaller) Type() reflect.Type {
+func (c *nativeTypex_YMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_YMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_YMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.Y), args[1].(typex.Y))
return []interface{}{out}
}
-func (c *nativeTypex_YMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_YMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.Y), b.(typex.Y))
}
-type nativeTypex_ZMCaller struct {
+type nativeTypex_ZMFunc struct {
fn func(typex.Z, typex.Z) typex.Z
}
-func callMakerTypex_ZM(fn interface{}) reflectx.Caller {
+func funcMakerTypex_ZM(fn interface{}) reflectx.Func {
f := fn.(func(typex.Z, typex.Z) typex.Z)
- return &nativeTypex_ZMCaller{fn: f}
+ return &nativeTypex_ZMFunc{fn: f}
+}
+
+func (c *nativeTypex_ZMFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
}
-func (c *nativeTypex_ZMCaller) Type() reflect.Type {
+func (c *nativeTypex_ZMFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *nativeTypex_ZMCaller) Call(args []interface{}) []interface{} {
+func (c *nativeTypex_ZMFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].(typex.Z), args[1].(typex.Z))
return []interface{}{out}
}
-func (c *nativeTypex_ZMCaller) Call2x1(a, b interface{}) interface{} {
+func (c *nativeTypex_ZMFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.(typex.Z), b.(typex.Z))
}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/callers.tmpl b/sdks/go/pkg/beam/core/runtime/exec/callers.tmpl
index 36d427b..10de8a0 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/callers.tmpl
+++ b/sdks/go/pkg/beam/core/runtime/exec/callers.tmpl
@@ -34,30 +34,34 @@ import (
func init() {
{{- range $x := .X}}
- reflectx.RegisterCaller(reflect.TypeOf((*func ({{$x.Type}}, {{$x.Type}}){{$x.Type}})(nil)).Elem(), callMaker{{$x.Name}}M)
+ reflectx.RegisterFunc(reflect.TypeOf((*func ({{$x.Type}}, {{$x.Type}}){{$x.Type}})(nil)).Elem(), funcMaker{{$x.Name}}M)
{{- end}}
}
{{range $x := .X}}
-type native{{$x.Name}}MCaller struct {
+type native{{$x.Name}}MFunc struct {
fn func ({{$x.Type}}, {{$x.Type}}){{$x.Type}}
}
-func callMaker{{$x.Name}}M(fn interface{}) reflectx.Caller {
+func funcMaker{{$x.Name}}M(fn interface{}) reflectx.Func {
f := fn.(func ({{$x.Type}}, {{$x.Type}}){{$x.Type}})
- return &native{{$x.Name}}MCaller{fn: f}
+ return &native{{$x.Name}}MFunc{fn: f}
}
-func (c *native{{$x.Name}}MCaller) Type() reflect.Type {
+func (c *native{{$x.Name}}MFunc) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *native{{$x.Name}}MFunc) Type() reflect.Type {
return reflect.TypeOf(c.fn)
}
-func (c *native{{$x.Name}}MCaller) Call(args []interface{}) []interface{} {
+func (c *native{{$x.Name}}MFunc) Call(args []interface{}) []interface{} {
out := c.fn(args[0].({{$x.Type}}), args[1].({{$x.Type}}))
return []interface{}{out}
}
-func (c *native{{$x.Name}}MCaller) Call2x1(a, b interface{}) interface{} {
+func (c *native{{$x.Name}}MFunc) Call2x1(a, b interface{}) interface{} {
return c.fn(a.({{$x.Type}}), b.({{$x.Type}}))
}
{{end}}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/combine.go b/sdks/go/pkg/beam/core/runtime/exec/combine.go
index 84c064a..83b42d2 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/combine.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/combine.go
@@ -39,7 +39,7 @@ type Combine struct {
first bool
isPerKey, usesKey bool
- mergeFn reflectx.Caller2x1 // optimized caller in the case of binary merge accumulators
+ mergeFn reflectx.Func2x1 // optimized caller in the case of binary merge accumulators
status Status
err errorx.GuardedError
@@ -60,7 +60,7 @@ func (n *Combine) Up(ctx context.Context) error {
}
if n.Edge.CombineFn.AddInputFn() == nil {
- n.mergeFn = reflectx.MakeCaller2x1(n.Edge.CombineFn.MergeAccumulatorsFn().Fn.Interface())
+ n.mergeFn = reflectx.MakeFunc2x1(n.Edge.CombineFn.MergeAccumulatorsFn().Fn.Interface())
}
// TODO(herohde) 6/28/2017: maybe record the per-key mode in the Edge
diff --git a/sdks/go/pkg/beam/core/util/reflectx/call.go b/sdks/go/pkg/beam/core/util/reflectx/call.go
index ebac4da..05b40ef 100644
--- a/sdks/go/pkg/beam/core/util/reflectx/call.go
+++ b/sdks/go/pkg/beam/core/util/reflectx/call.go
@@ -25,9 +25,12 @@ import (
//go:generate specialize --input=calls.tmpl
-// Caller is an untyped function call interface. This indirection allows
-// us to avoid reflection call overhead for certain types.
-type Caller interface {
+// Func represents a callable untyped function. This indirection allows
+// us to avoid reflection call overhead for certain types as well as
+// faster dynamic function implementations.
+type Func interface {
+ // Name returns the name of the function.
+ Name() string
// Type returns the type.
Type() reflect.Type
// Call invokes the implicit fn with arguments.
@@ -35,29 +38,29 @@ type Caller interface {
}
var (
- callers = make(map[string]func(interface{}) Caller)
- callersMu sync.Mutex
+ funcs = make(map[string]func(interface{}) Func)
+ funcsMu sync.Mutex
)
-// RegisterCaller registers an custom caller factory for the given type, such as
-// "func(int)bool". If multiple caller factories are registered for the same type,
+// RegisterFunc registers an custom reflectFunc factory for the given type, such as
+// "func(int)bool". If multiple func factories are registered for the same type,
// the last registration wins.
-func RegisterCaller(t reflect.Type, maker func(interface{}) Caller) {
- callersMu.Lock()
- defer callersMu.Unlock()
+func RegisterFunc(t reflect.Type, maker func(interface{}) Func) {
+ funcsMu.Lock()
+ defer funcsMu.Unlock()
key := t.String()
- if _, exists := callers[key]; exists {
- log.Warnf(context.Background(), "Caller for %v already registered. Overwriting.", key)
+ if _, exists := funcs[key]; exists {
+ log.Warnf(context.Background(), "Func for %v already registered. Overwriting.", key)
}
- callers[key] = maker
+ funcs[key] = maker
}
-// MakeCaller returns a caller for given function.
-func MakeCaller(fn interface{}) Caller {
- callersMu.Lock()
- maker, exists := callers[reflect.TypeOf(fn).String()]
- callersMu.Unlock()
+// MakeFunc returns a reflectFunc for given function.
+func MakeFunc(fn interface{}) Func {
+ funcsMu.Lock()
+ maker, exists := funcs[reflect.TypeOf(fn).String()]
+ funcsMu.Unlock()
if exists {
return maker(fn)
@@ -66,18 +69,22 @@ func MakeCaller(fn interface{}) Caller {
// If no specialized implementation is available, we use the standard
// reflection-based call.
- return &caller{fn: reflect.ValueOf(fn)}
+ return &reflectFunc{fn: reflect.ValueOf(fn)}
}
-type caller struct {
+type reflectFunc struct {
fn reflect.Value
}
-func (c *caller) Type() reflect.Type {
+func (c *reflectFunc) Name() string {
+ return FunctionName(c.fn.Interface())
+}
+
+func (c *reflectFunc) Type() reflect.Type {
return c.fn.Type()
}
-func (c *caller) Call(args []interface{}) []interface{} {
+func (c *reflectFunc) Call(args []interface{}) []interface{} {
return Interface(c.fn.Call(ValueOf(args)))
}
diff --git a/sdks/go/pkg/beam/core/util/reflectx/calls.go b/sdks/go/pkg/beam/core/util/reflectx/calls.go
index 2799b8a..a1bfe6b 100644
--- a/sdks/go/pkg/beam/core/util/reflectx/calls.go
+++ b/sdks/go/pkg/beam/core/util/reflectx/calls.go
@@ -19,1195 +19,1323 @@ package reflectx
import "reflect"
-// Generated arity-specialized Caller implementations to avoid runtime temporary
+// Generated arity-specialized Func implementations to avoid runtime temporary
// slices. Code that knows the arity can potentially avoid that overhead in
// addition to avoiding the reflection call overhead.
//
-// We force CallerZxY to implement Caller as well to have a single registry. Concrete
-// caller implementations should implement the most specific supported variant. This
-// also allows more specific intermediate interfaces, such as Caller2bool, to be added
+// We force FuncXxY to implement Func as well to have a single registry. Concrete
+// Func implementations should implement the most specific supported variant. This
+// also allows more specific intermediate interfaces, such as Func2xbool, to be added
// later.
-type Caller0x0 interface {
- Caller
+type Func0x0 interface {
+ Func
Call0x0()
}
-type shimCaller0x0 struct {
- inner Caller
+type shimFunc0x0 struct {
+ inner Func
}
-func (c *shimCaller0x0) Type() reflect.Type {
+func (c *shimFunc0x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc0x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller0x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc0x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller0x0) Call0x0() {
+func (c *shimFunc0x0) Call0x0() {
ret := c.inner.Call([]interface{}{})
_ = ret
return
}
-func ToCaller0x0(c Caller) Caller0x0 {
+func ToFunc0x0(c Func) Func0x0 {
if c.Type().NumIn() != 0 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller0x0); ok {
+ if sc, ok := c.(Func0x0); ok {
return sc
}
- return &shimCaller0x0{inner: c}
+ return &shimFunc0x0{inner: c}
}
-func MakeCaller0x0(fn interface{}) Caller0x0 {
- return ToCaller0x0(MakeCaller(fn))
+func MakeFunc0x0(fn interface{}) Func0x0 {
+ return ToFunc0x0(MakeFunc(fn))
}
-type Caller0x1 interface {
- Caller
+type Func0x1 interface {
+ Func
Call0x1() interface{}
}
-type shimCaller0x1 struct {
- inner Caller
+type shimFunc0x1 struct {
+ inner Func
+}
+
+func (c *shimFunc0x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller0x1) Type() reflect.Type {
+func (c *shimFunc0x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller0x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc0x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller0x1) Call0x1() interface{} {
+func (c *shimFunc0x1) Call0x1() interface{} {
ret := c.inner.Call([]interface{}{})
_ = ret
return ret[0]
}
-func ToCaller0x1(c Caller) Caller0x1 {
+func ToFunc0x1(c Func) Func0x1 {
if c.Type().NumIn() != 0 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller0x1); ok {
+ if sc, ok := c.(Func0x1); ok {
return sc
}
- return &shimCaller0x1{inner: c}
+ return &shimFunc0x1{inner: c}
}
-func MakeCaller0x1(fn interface{}) Caller0x1 {
- return ToCaller0x1(MakeCaller(fn))
+func MakeFunc0x1(fn interface{}) Func0x1 {
+ return ToFunc0x1(MakeFunc(fn))
}
-type Caller0x2 interface {
- Caller
+type Func0x2 interface {
+ Func
Call0x2() (interface{}, interface{})
}
-type shimCaller0x2 struct {
- inner Caller
+type shimFunc0x2 struct {
+ inner Func
}
-func (c *shimCaller0x2) Type() reflect.Type {
+func (c *shimFunc0x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc0x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller0x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc0x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller0x2) Call0x2() (interface{}, interface{}) {
+func (c *shimFunc0x2) Call0x2() (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{})
_ = ret
return ret[0], ret[1]
}
-func ToCaller0x2(c Caller) Caller0x2 {
+func ToFunc0x2(c Func) Func0x2 {
if c.Type().NumIn() != 0 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller0x2); ok {
+ if sc, ok := c.(Func0x2); ok {
return sc
}
- return &shimCaller0x2{inner: c}
+ return &shimFunc0x2{inner: c}
}
-func MakeCaller0x2(fn interface{}) Caller0x2 {
- return ToCaller0x2(MakeCaller(fn))
+func MakeFunc0x2(fn interface{}) Func0x2 {
+ return ToFunc0x2(MakeFunc(fn))
}
-type Caller0x3 interface {
- Caller
+type Func0x3 interface {
+ Func
Call0x3() (interface{}, interface{}, interface{})
}
-type shimCaller0x3 struct {
- inner Caller
+type shimFunc0x3 struct {
+ inner Func
+}
+
+func (c *shimFunc0x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller0x3) Type() reflect.Type {
+func (c *shimFunc0x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller0x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc0x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller0x3) Call0x3() (interface{}, interface{}, interface{}) {
+func (c *shimFunc0x3) Call0x3() (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller0x3(c Caller) Caller0x3 {
+func ToFunc0x3(c Func) Func0x3 {
if c.Type().NumIn() != 0 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller0x3); ok {
+ if sc, ok := c.(Func0x3); ok {
return sc
}
- return &shimCaller0x3{inner: c}
+ return &shimFunc0x3{inner: c}
}
-func MakeCaller0x3(fn interface{}) Caller0x3 {
- return ToCaller0x3(MakeCaller(fn))
+func MakeFunc0x3(fn interface{}) Func0x3 {
+ return ToFunc0x3(MakeFunc(fn))
}
-type Caller1x0 interface {
- Caller
+type Func1x0 interface {
+ Func
Call1x0(interface{})
}
-type shimCaller1x0 struct {
- inner Caller
+type shimFunc1x0 struct {
+ inner Func
}
-func (c *shimCaller1x0) Type() reflect.Type {
+func (c *shimFunc1x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc1x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller1x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc1x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller1x0) Call1x0(arg0 interface{}) {
+func (c *shimFunc1x0) Call1x0(arg0 interface{}) {
ret := c.inner.Call([]interface{}{arg0})
_ = ret
return
}
-func ToCaller1x0(c Caller) Caller1x0 {
+func ToFunc1x0(c Func) Func1x0 {
if c.Type().NumIn() != 1 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller1x0); ok {
+ if sc, ok := c.(Func1x0); ok {
return sc
}
- return &shimCaller1x0{inner: c}
+ return &shimFunc1x0{inner: c}
}
-func MakeCaller1x0(fn interface{}) Caller1x0 {
- return ToCaller1x0(MakeCaller(fn))
+func MakeFunc1x0(fn interface{}) Func1x0 {
+ return ToFunc1x0(MakeFunc(fn))
}
-type Caller1x1 interface {
- Caller
+type Func1x1 interface {
+ Func
Call1x1(interface{}) interface{}
}
-type shimCaller1x1 struct {
- inner Caller
+type shimFunc1x1 struct {
+ inner Func
+}
+
+func (c *shimFunc1x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller1x1) Type() reflect.Type {
+func (c *shimFunc1x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller1x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc1x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller1x1) Call1x1(arg0 interface{}) interface{} {
+func (c *shimFunc1x1) Call1x1(arg0 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0})
_ = ret
return ret[0]
}
-func ToCaller1x1(c Caller) Caller1x1 {
+func ToFunc1x1(c Func) Func1x1 {
if c.Type().NumIn() != 1 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller1x1); ok {
+ if sc, ok := c.(Func1x1); ok {
return sc
}
- return &shimCaller1x1{inner: c}
+ return &shimFunc1x1{inner: c}
}
-func MakeCaller1x1(fn interface{}) Caller1x1 {
- return ToCaller1x1(MakeCaller(fn))
+func MakeFunc1x1(fn interface{}) Func1x1 {
+ return ToFunc1x1(MakeFunc(fn))
}
-type Caller1x2 interface {
- Caller
+type Func1x2 interface {
+ Func
Call1x2(interface{}) (interface{}, interface{})
}
-type shimCaller1x2 struct {
- inner Caller
+type shimFunc1x2 struct {
+ inner Func
}
-func (c *shimCaller1x2) Type() reflect.Type {
+func (c *shimFunc1x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc1x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller1x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc1x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller1x2) Call1x2(arg0 interface{}) (interface{}, interface{}) {
+func (c *shimFunc1x2) Call1x2(arg0 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0})
_ = ret
return ret[0], ret[1]
}
-func ToCaller1x2(c Caller) Caller1x2 {
+func ToFunc1x2(c Func) Func1x2 {
if c.Type().NumIn() != 1 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller1x2); ok {
+ if sc, ok := c.(Func1x2); ok {
return sc
}
- return &shimCaller1x2{inner: c}
+ return &shimFunc1x2{inner: c}
}
-func MakeCaller1x2(fn interface{}) Caller1x2 {
- return ToCaller1x2(MakeCaller(fn))
+func MakeFunc1x2(fn interface{}) Func1x2 {
+ return ToFunc1x2(MakeFunc(fn))
}
-type Caller1x3 interface {
- Caller
+type Func1x3 interface {
+ Func
Call1x3(interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller1x3 struct {
- inner Caller
+type shimFunc1x3 struct {
+ inner Func
+}
+
+func (c *shimFunc1x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller1x3) Type() reflect.Type {
+func (c *shimFunc1x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller1x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc1x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller1x3) Call1x3(arg0 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc1x3) Call1x3(arg0 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller1x3(c Caller) Caller1x3 {
+func ToFunc1x3(c Func) Func1x3 {
if c.Type().NumIn() != 1 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller1x3); ok {
+ if sc, ok := c.(Func1x3); ok {
return sc
}
- return &shimCaller1x3{inner: c}
+ return &shimFunc1x3{inner: c}
}
-func MakeCaller1x3(fn interface{}) Caller1x3 {
- return ToCaller1x3(MakeCaller(fn))
+func MakeFunc1x3(fn interface{}) Func1x3 {
+ return ToFunc1x3(MakeFunc(fn))
}
-type Caller2x0 interface {
- Caller
+type Func2x0 interface {
+ Func
Call2x0(interface{}, interface{})
}
-type shimCaller2x0 struct {
- inner Caller
+type shimFunc2x0 struct {
+ inner Func
}
-func (c *shimCaller2x0) Type() reflect.Type {
+func (c *shimFunc2x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc2x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller2x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc2x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller2x0) Call2x0(arg0, arg1 interface{}) {
+func (c *shimFunc2x0) Call2x0(arg0, arg1 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1})
_ = ret
return
}
-func ToCaller2x0(c Caller) Caller2x0 {
+func ToFunc2x0(c Func) Func2x0 {
if c.Type().NumIn() != 2 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller2x0); ok {
+ if sc, ok := c.(Func2x0); ok {
return sc
}
- return &shimCaller2x0{inner: c}
+ return &shimFunc2x0{inner: c}
}
-func MakeCaller2x0(fn interface{}) Caller2x0 {
- return ToCaller2x0(MakeCaller(fn))
+func MakeFunc2x0(fn interface{}) Func2x0 {
+ return ToFunc2x0(MakeFunc(fn))
}
-type Caller2x1 interface {
- Caller
+type Func2x1 interface {
+ Func
Call2x1(interface{}, interface{}) interface{}
}
-type shimCaller2x1 struct {
- inner Caller
+type shimFunc2x1 struct {
+ inner Func
+}
+
+func (c *shimFunc2x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller2x1) Type() reflect.Type {
+func (c *shimFunc2x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller2x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc2x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller2x1) Call2x1(arg0, arg1 interface{}) interface{} {
+func (c *shimFunc2x1) Call2x1(arg0, arg1 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1})
_ = ret
return ret[0]
}
-func ToCaller2x1(c Caller) Caller2x1 {
+func ToFunc2x1(c Func) Func2x1 {
if c.Type().NumIn() != 2 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller2x1); ok {
+ if sc, ok := c.(Func2x1); ok {
return sc
}
- return &shimCaller2x1{inner: c}
+ return &shimFunc2x1{inner: c}
}
-func MakeCaller2x1(fn interface{}) Caller2x1 {
- return ToCaller2x1(MakeCaller(fn))
+func MakeFunc2x1(fn interface{}) Func2x1 {
+ return ToFunc2x1(MakeFunc(fn))
}
-type Caller2x2 interface {
- Caller
+type Func2x2 interface {
+ Func
Call2x2(interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller2x2 struct {
- inner Caller
+type shimFunc2x2 struct {
+ inner Func
}
-func (c *shimCaller2x2) Type() reflect.Type {
+func (c *shimFunc2x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc2x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller2x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc2x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller2x2) Call2x2(arg0, arg1 interface{}) (interface{}, interface{}) {
+func (c *shimFunc2x2) Call2x2(arg0, arg1 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1})
_ = ret
return ret[0], ret[1]
}
-func ToCaller2x2(c Caller) Caller2x2 {
+func ToFunc2x2(c Func) Func2x2 {
if c.Type().NumIn() != 2 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller2x2); ok {
+ if sc, ok := c.(Func2x2); ok {
return sc
}
- return &shimCaller2x2{inner: c}
+ return &shimFunc2x2{inner: c}
}
-func MakeCaller2x2(fn interface{}) Caller2x2 {
- return ToCaller2x2(MakeCaller(fn))
+func MakeFunc2x2(fn interface{}) Func2x2 {
+ return ToFunc2x2(MakeFunc(fn))
}
-type Caller2x3 interface {
- Caller
+type Func2x3 interface {
+ Func
Call2x3(interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller2x3 struct {
- inner Caller
+type shimFunc2x3 struct {
+ inner Func
+}
+
+func (c *shimFunc2x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller2x3) Type() reflect.Type {
+func (c *shimFunc2x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller2x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc2x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller2x3) Call2x3(arg0, arg1 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc2x3) Call2x3(arg0, arg1 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller2x3(c Caller) Caller2x3 {
+func ToFunc2x3(c Func) Func2x3 {
if c.Type().NumIn() != 2 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller2x3); ok {
+ if sc, ok := c.(Func2x3); ok {
return sc
}
- return &shimCaller2x3{inner: c}
+ return &shimFunc2x3{inner: c}
}
-func MakeCaller2x3(fn interface{}) Caller2x3 {
- return ToCaller2x3(MakeCaller(fn))
+func MakeFunc2x3(fn interface{}) Func2x3 {
+ return ToFunc2x3(MakeFunc(fn))
}
-type Caller3x0 interface {
- Caller
+type Func3x0 interface {
+ Func
Call3x0(interface{}, interface{}, interface{})
}
-type shimCaller3x0 struct {
- inner Caller
+type shimFunc3x0 struct {
+ inner Func
}
-func (c *shimCaller3x0) Type() reflect.Type {
+func (c *shimFunc3x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc3x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller3x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc3x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller3x0) Call3x0(arg0, arg1, arg2 interface{}) {
+func (c *shimFunc3x0) Call3x0(arg0, arg1, arg2 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2})
_ = ret
return
}
-func ToCaller3x0(c Caller) Caller3x0 {
+func ToFunc3x0(c Func) Func3x0 {
if c.Type().NumIn() != 3 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller3x0); ok {
+ if sc, ok := c.(Func3x0); ok {
return sc
}
- return &shimCaller3x0{inner: c}
+ return &shimFunc3x0{inner: c}
}
-func MakeCaller3x0(fn interface{}) Caller3x0 {
- return ToCaller3x0(MakeCaller(fn))
+func MakeFunc3x0(fn interface{}) Func3x0 {
+ return ToFunc3x0(MakeFunc(fn))
}
-type Caller3x1 interface {
- Caller
+type Func3x1 interface {
+ Func
Call3x1(interface{}, interface{}, interface{}) interface{}
}
-type shimCaller3x1 struct {
- inner Caller
+type shimFunc3x1 struct {
+ inner Func
+}
+
+func (c *shimFunc3x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller3x1) Type() reflect.Type {
+func (c *shimFunc3x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller3x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc3x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller3x1) Call3x1(arg0, arg1, arg2 interface{}) interface{} {
+func (c *shimFunc3x1) Call3x1(arg0, arg1, arg2 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2})
_ = ret
return ret[0]
}
-func ToCaller3x1(c Caller) Caller3x1 {
+func ToFunc3x1(c Func) Func3x1 {
if c.Type().NumIn() != 3 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller3x1); ok {
+ if sc, ok := c.(Func3x1); ok {
return sc
}
- return &shimCaller3x1{inner: c}
+ return &shimFunc3x1{inner: c}
}
-func MakeCaller3x1(fn interface{}) Caller3x1 {
- return ToCaller3x1(MakeCaller(fn))
+func MakeFunc3x1(fn interface{}) Func3x1 {
+ return ToFunc3x1(MakeFunc(fn))
}
-type Caller3x2 interface {
- Caller
+type Func3x2 interface {
+ Func
Call3x2(interface{}, interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller3x2 struct {
- inner Caller
+type shimFunc3x2 struct {
+ inner Func
}
-func (c *shimCaller3x2) Type() reflect.Type {
+func (c *shimFunc3x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc3x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller3x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc3x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller3x2) Call3x2(arg0, arg1, arg2 interface{}) (interface{}, interface{}) {
+func (c *shimFunc3x2) Call3x2(arg0, arg1, arg2 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2})
_ = ret
return ret[0], ret[1]
}
-func ToCaller3x2(c Caller) Caller3x2 {
+func ToFunc3x2(c Func) Func3x2 {
if c.Type().NumIn() != 3 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller3x2); ok {
+ if sc, ok := c.(Func3x2); ok {
return sc
}
- return &shimCaller3x2{inner: c}
+ return &shimFunc3x2{inner: c}
}
-func MakeCaller3x2(fn interface{}) Caller3x2 {
- return ToCaller3x2(MakeCaller(fn))
+func MakeFunc3x2(fn interface{}) Func3x2 {
+ return ToFunc3x2(MakeFunc(fn))
}
-type Caller3x3 interface {
- Caller
+type Func3x3 interface {
+ Func
Call3x3(interface{}, interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller3x3 struct {
- inner Caller
+type shimFunc3x3 struct {
+ inner Func
+}
+
+func (c *shimFunc3x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller3x3) Type() reflect.Type {
+func (c *shimFunc3x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller3x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc3x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller3x3) Call3x3(arg0, arg1, arg2 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc3x3) Call3x3(arg0, arg1, arg2 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller3x3(c Caller) Caller3x3 {
+func ToFunc3x3(c Func) Func3x3 {
if c.Type().NumIn() != 3 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller3x3); ok {
+ if sc, ok := c.(Func3x3); ok {
return sc
}
- return &shimCaller3x3{inner: c}
+ return &shimFunc3x3{inner: c}
}
-func MakeCaller3x3(fn interface{}) Caller3x3 {
- return ToCaller3x3(MakeCaller(fn))
+func MakeFunc3x3(fn interface{}) Func3x3 {
+ return ToFunc3x3(MakeFunc(fn))
}
-type Caller4x0 interface {
- Caller
+type Func4x0 interface {
+ Func
Call4x0(interface{}, interface{}, interface{}, interface{})
}
-type shimCaller4x0 struct {
- inner Caller
+type shimFunc4x0 struct {
+ inner Func
}
-func (c *shimCaller4x0) Type() reflect.Type {
+func (c *shimFunc4x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc4x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller4x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc4x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller4x0) Call4x0(arg0, arg1, arg2, arg3 interface{}) {
+func (c *shimFunc4x0) Call4x0(arg0, arg1, arg2, arg3 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3})
_ = ret
return
}
-func ToCaller4x0(c Caller) Caller4x0 {
+func ToFunc4x0(c Func) Func4x0 {
if c.Type().NumIn() != 4 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller4x0); ok {
+ if sc, ok := c.(Func4x0); ok {
return sc
}
- return &shimCaller4x0{inner: c}
+ return &shimFunc4x0{inner: c}
}
-func MakeCaller4x0(fn interface{}) Caller4x0 {
- return ToCaller4x0(MakeCaller(fn))
+func MakeFunc4x0(fn interface{}) Func4x0 {
+ return ToFunc4x0(MakeFunc(fn))
}
-type Caller4x1 interface {
- Caller
+type Func4x1 interface {
+ Func
Call4x1(interface{}, interface{}, interface{}, interface{}) interface{}
}
-type shimCaller4x1 struct {
- inner Caller
+type shimFunc4x1 struct {
+ inner Func
+}
+
+func (c *shimFunc4x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller4x1) Type() reflect.Type {
+func (c *shimFunc4x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller4x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc4x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller4x1) Call4x1(arg0, arg1, arg2, arg3 interface{}) interface{} {
+func (c *shimFunc4x1) Call4x1(arg0, arg1, arg2, arg3 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3})
_ = ret
return ret[0]
}
-func ToCaller4x1(c Caller) Caller4x1 {
+func ToFunc4x1(c Func) Func4x1 {
if c.Type().NumIn() != 4 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller4x1); ok {
+ if sc, ok := c.(Func4x1); ok {
return sc
}
- return &shimCaller4x1{inner: c}
+ return &shimFunc4x1{inner: c}
}
-func MakeCaller4x1(fn interface{}) Caller4x1 {
- return ToCaller4x1(MakeCaller(fn))
+func MakeFunc4x1(fn interface{}) Func4x1 {
+ return ToFunc4x1(MakeFunc(fn))
}
-type Caller4x2 interface {
- Caller
+type Func4x2 interface {
+ Func
Call4x2(interface{}, interface{}, interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller4x2 struct {
- inner Caller
+type shimFunc4x2 struct {
+ inner Func
}
-func (c *shimCaller4x2) Type() reflect.Type {
+func (c *shimFunc4x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc4x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller4x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc4x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller4x2) Call4x2(arg0, arg1, arg2, arg3 interface{}) (interface{}, interface{}) {
+func (c *shimFunc4x2) Call4x2(arg0, arg1, arg2, arg3 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3})
_ = ret
return ret[0], ret[1]
}
-func ToCaller4x2(c Caller) Caller4x2 {
+func ToFunc4x2(c Func) Func4x2 {
if c.Type().NumIn() != 4 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller4x2); ok {
+ if sc, ok := c.(Func4x2); ok {
return sc
}
- return &shimCaller4x2{inner: c}
+ return &shimFunc4x2{inner: c}
}
-func MakeCaller4x2(fn interface{}) Caller4x2 {
- return ToCaller4x2(MakeCaller(fn))
+func MakeFunc4x2(fn interface{}) Func4x2 {
+ return ToFunc4x2(MakeFunc(fn))
}
-type Caller4x3 interface {
- Caller
+type Func4x3 interface {
+ Func
Call4x3(interface{}, interface{}, interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller4x3 struct {
- inner Caller
+type shimFunc4x3 struct {
+ inner Func
+}
+
+func (c *shimFunc4x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller4x3) Type() reflect.Type {
+func (c *shimFunc4x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller4x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc4x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller4x3) Call4x3(arg0, arg1, arg2, arg3 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc4x3) Call4x3(arg0, arg1, arg2, arg3 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller4x3(c Caller) Caller4x3 {
+func ToFunc4x3(c Func) Func4x3 {
if c.Type().NumIn() != 4 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller4x3); ok {
+ if sc, ok := c.(Func4x3); ok {
return sc
}
- return &shimCaller4x3{inner: c}
+ return &shimFunc4x3{inner: c}
}
-func MakeCaller4x3(fn interface{}) Caller4x3 {
- return ToCaller4x3(MakeCaller(fn))
+func MakeFunc4x3(fn interface{}) Func4x3 {
+ return ToFunc4x3(MakeFunc(fn))
}
-type Caller5x0 interface {
- Caller
+type Func5x0 interface {
+ Func
Call5x0(interface{}, interface{}, interface{}, interface{}, interface{})
}
-type shimCaller5x0 struct {
- inner Caller
+type shimFunc5x0 struct {
+ inner Func
}
-func (c *shimCaller5x0) Type() reflect.Type {
+func (c *shimFunc5x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc5x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller5x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc5x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller5x0) Call5x0(arg0, arg1, arg2, arg3, arg4 interface{}) {
+func (c *shimFunc5x0) Call5x0(arg0, arg1, arg2, arg3, arg4 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4})
_ = ret
return
}
-func ToCaller5x0(c Caller) Caller5x0 {
+func ToFunc5x0(c Func) Func5x0 {
if c.Type().NumIn() != 5 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller5x0); ok {
+ if sc, ok := c.(Func5x0); ok {
return sc
}
- return &shimCaller5x0{inner: c}
+ return &shimFunc5x0{inner: c}
}
-func MakeCaller5x0(fn interface{}) Caller5x0 {
- return ToCaller5x0(MakeCaller(fn))
+func MakeFunc5x0(fn interface{}) Func5x0 {
+ return ToFunc5x0(MakeFunc(fn))
}
-type Caller5x1 interface {
- Caller
+type Func5x1 interface {
+ Func
Call5x1(interface{}, interface{}, interface{}, interface{}, interface{}) interface{}
}
-type shimCaller5x1 struct {
- inner Caller
+type shimFunc5x1 struct {
+ inner Func
+}
+
+func (c *shimFunc5x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller5x1) Type() reflect.Type {
+func (c *shimFunc5x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller5x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc5x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller5x1) Call5x1(arg0, arg1, arg2, arg3, arg4 interface{}) interface{} {
+func (c *shimFunc5x1) Call5x1(arg0, arg1, arg2, arg3, arg4 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4})
_ = ret
return ret[0]
}
-func ToCaller5x1(c Caller) Caller5x1 {
+func ToFunc5x1(c Func) Func5x1 {
if c.Type().NumIn() != 5 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller5x1); ok {
+ if sc, ok := c.(Func5x1); ok {
return sc
}
- return &shimCaller5x1{inner: c}
+ return &shimFunc5x1{inner: c}
}
-func MakeCaller5x1(fn interface{}) Caller5x1 {
- return ToCaller5x1(MakeCaller(fn))
+func MakeFunc5x1(fn interface{}) Func5x1 {
+ return ToFunc5x1(MakeFunc(fn))
}
-type Caller5x2 interface {
- Caller
+type Func5x2 interface {
+ Func
Call5x2(interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller5x2 struct {
- inner Caller
+type shimFunc5x2 struct {
+ inner Func
}
-func (c *shimCaller5x2) Type() reflect.Type {
+func (c *shimFunc5x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc5x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller5x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc5x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller5x2) Call5x2(arg0, arg1, arg2, arg3, arg4 interface{}) (interface{}, interface{}) {
+func (c *shimFunc5x2) Call5x2(arg0, arg1, arg2, arg3, arg4 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4})
_ = ret
return ret[0], ret[1]
}
-func ToCaller5x2(c Caller) Caller5x2 {
+func ToFunc5x2(c Func) Func5x2 {
if c.Type().NumIn() != 5 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller5x2); ok {
+ if sc, ok := c.(Func5x2); ok {
return sc
}
- return &shimCaller5x2{inner: c}
+ return &shimFunc5x2{inner: c}
}
-func MakeCaller5x2(fn interface{}) Caller5x2 {
- return ToCaller5x2(MakeCaller(fn))
+func MakeFunc5x2(fn interface{}) Func5x2 {
+ return ToFunc5x2(MakeFunc(fn))
}
-type Caller5x3 interface {
- Caller
+type Func5x3 interface {
+ Func
Call5x3(interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller5x3 struct {
- inner Caller
+type shimFunc5x3 struct {
+ inner Func
+}
+
+func (c *shimFunc5x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller5x3) Type() reflect.Type {
+func (c *shimFunc5x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller5x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc5x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller5x3) Call5x3(arg0, arg1, arg2, arg3, arg4 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc5x3) Call5x3(arg0, arg1, arg2, arg3, arg4 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller5x3(c Caller) Caller5x3 {
+func ToFunc5x3(c Func) Func5x3 {
if c.Type().NumIn() != 5 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller5x3); ok {
+ if sc, ok := c.(Func5x3); ok {
return sc
}
- return &shimCaller5x3{inner: c}
+ return &shimFunc5x3{inner: c}
}
-func MakeCaller5x3(fn interface{}) Caller5x3 {
- return ToCaller5x3(MakeCaller(fn))
+func MakeFunc5x3(fn interface{}) Func5x3 {
+ return ToFunc5x3(MakeFunc(fn))
}
-type Caller6x0 interface {
- Caller
+type Func6x0 interface {
+ Func
Call6x0(interface{}, interface{}, interface{}, interface{}, interface{}, interface{})
}
-type shimCaller6x0 struct {
- inner Caller
+type shimFunc6x0 struct {
+ inner Func
}
-func (c *shimCaller6x0) Type() reflect.Type {
+func (c *shimFunc6x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc6x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller6x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc6x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller6x0) Call6x0(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) {
+func (c *shimFunc6x0) Call6x0(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5})
_ = ret
return
}
-func ToCaller6x0(c Caller) Caller6x0 {
+func ToFunc6x0(c Func) Func6x0 {
if c.Type().NumIn() != 6 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller6x0); ok {
+ if sc, ok := c.(Func6x0); ok {
return sc
}
- return &shimCaller6x0{inner: c}
+ return &shimFunc6x0{inner: c}
}
-func MakeCaller6x0(fn interface{}) Caller6x0 {
- return ToCaller6x0(MakeCaller(fn))
+func MakeFunc6x0(fn interface{}) Func6x0 {
+ return ToFunc6x0(MakeFunc(fn))
}
-type Caller6x1 interface {
- Caller
+type Func6x1 interface {
+ Func
Call6x1(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) interface{}
}
-type shimCaller6x1 struct {
- inner Caller
+type shimFunc6x1 struct {
+ inner Func
+}
+
+func (c *shimFunc6x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller6x1) Type() reflect.Type {
+func (c *shimFunc6x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller6x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc6x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller6x1) Call6x1(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) interface{} {
+func (c *shimFunc6x1) Call6x1(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5})
_ = ret
return ret[0]
}
-func ToCaller6x1(c Caller) Caller6x1 {
+func ToFunc6x1(c Func) Func6x1 {
if c.Type().NumIn() != 6 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller6x1); ok {
+ if sc, ok := c.(Func6x1); ok {
return sc
}
- return &shimCaller6x1{inner: c}
+ return &shimFunc6x1{inner: c}
}
-func MakeCaller6x1(fn interface{}) Caller6x1 {
- return ToCaller6x1(MakeCaller(fn))
+func MakeFunc6x1(fn interface{}) Func6x1 {
+ return ToFunc6x1(MakeFunc(fn))
}
-type Caller6x2 interface {
- Caller
+type Func6x2 interface {
+ Func
Call6x2(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller6x2 struct {
- inner Caller
+type shimFunc6x2 struct {
+ inner Func
}
-func (c *shimCaller6x2) Type() reflect.Type {
+func (c *shimFunc6x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc6x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller6x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc6x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller6x2) Call6x2(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) (interface{}, interface{}) {
+func (c *shimFunc6x2) Call6x2(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5})
_ = ret
return ret[0], ret[1]
}
-func ToCaller6x2(c Caller) Caller6x2 {
+func ToFunc6x2(c Func) Func6x2 {
if c.Type().NumIn() != 6 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller6x2); ok {
+ if sc, ok := c.(Func6x2); ok {
return sc
}
- return &shimCaller6x2{inner: c}
+ return &shimFunc6x2{inner: c}
}
-func MakeCaller6x2(fn interface{}) Caller6x2 {
- return ToCaller6x2(MakeCaller(fn))
+func MakeFunc6x2(fn interface{}) Func6x2 {
+ return ToFunc6x2(MakeFunc(fn))
}
-type Caller6x3 interface {
- Caller
+type Func6x3 interface {
+ Func
Call6x3(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller6x3 struct {
- inner Caller
+type shimFunc6x3 struct {
+ inner Func
+}
+
+func (c *shimFunc6x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller6x3) Type() reflect.Type {
+func (c *shimFunc6x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller6x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc6x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller6x3) Call6x3(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc6x3) Call6x3(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller6x3(c Caller) Caller6x3 {
+func ToFunc6x3(c Func) Func6x3 {
if c.Type().NumIn() != 6 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller6x3); ok {
+ if sc, ok := c.(Func6x3); ok {
return sc
}
- return &shimCaller6x3{inner: c}
+ return &shimFunc6x3{inner: c}
}
-func MakeCaller6x3(fn interface{}) Caller6x3 {
- return ToCaller6x3(MakeCaller(fn))
+func MakeFunc6x3(fn interface{}) Func6x3 {
+ return ToFunc6x3(MakeFunc(fn))
}
-type Caller7x0 interface {
- Caller
+type Func7x0 interface {
+ Func
Call7x0(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}, interface{})
}
-type shimCaller7x0 struct {
- inner Caller
+type shimFunc7x0 struct {
+ inner Func
}
-func (c *shimCaller7x0) Type() reflect.Type {
+func (c *shimFunc7x0) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc7x0) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller7x0) Call(args []interface{}) []interface{} {
+func (c *shimFunc7x0) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller7x0) Call7x0(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) {
+func (c *shimFunc7x0) Call7x0(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6})
_ = ret
return
}
-func ToCaller7x0(c Caller) Caller7x0 {
+func ToFunc7x0(c Func) Func7x0 {
if c.Type().NumIn() != 7 || c.Type().NumOut() != 0 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller7x0); ok {
+ if sc, ok := c.(Func7x0); ok {
return sc
}
- return &shimCaller7x0{inner: c}
+ return &shimFunc7x0{inner: c}
}
-func MakeCaller7x0(fn interface{}) Caller7x0 {
- return ToCaller7x0(MakeCaller(fn))
+func MakeFunc7x0(fn interface{}) Func7x0 {
+ return ToFunc7x0(MakeFunc(fn))
}
-type Caller7x1 interface {
- Caller
+type Func7x1 interface {
+ Func
Call7x1(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) interface{}
}
-type shimCaller7x1 struct {
- inner Caller
+type shimFunc7x1 struct {
+ inner Func
+}
+
+func (c *shimFunc7x1) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller7x1) Type() reflect.Type {
+func (c *shimFunc7x1) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller7x1) Call(args []interface{}) []interface{} {
+func (c *shimFunc7x1) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller7x1) Call7x1(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) interface{} {
+func (c *shimFunc7x1) Call7x1(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) interface{} {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6})
_ = ret
return ret[0]
}
-func ToCaller7x1(c Caller) Caller7x1 {
+func ToFunc7x1(c Func) Func7x1 {
if c.Type().NumIn() != 7 || c.Type().NumOut() != 1 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller7x1); ok {
+ if sc, ok := c.(Func7x1); ok {
return sc
}
- return &shimCaller7x1{inner: c}
+ return &shimFunc7x1{inner: c}
}
-func MakeCaller7x1(fn interface{}) Caller7x1 {
- return ToCaller7x1(MakeCaller(fn))
+func MakeFunc7x1(fn interface{}) Func7x1 {
+ return ToFunc7x1(MakeFunc(fn))
}
-type Caller7x2 interface {
- Caller
+type Func7x2 interface {
+ Func
Call7x2(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{})
}
-type shimCaller7x2 struct {
- inner Caller
+type shimFunc7x2 struct {
+ inner Func
}
-func (c *shimCaller7x2) Type() reflect.Type {
+func (c *shimFunc7x2) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc7x2) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller7x2) Call(args []interface{}) []interface{} {
+func (c *shimFunc7x2) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller7x2) Call7x2(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) (interface{}, interface{}) {
+func (c *shimFunc7x2) Call7x2(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) (interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6})
_ = ret
return ret[0], ret[1]
}
-func ToCaller7x2(c Caller) Caller7x2 {
+func ToFunc7x2(c Func) Func7x2 {
if c.Type().NumIn() != 7 || c.Type().NumOut() != 2 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller7x2); ok {
+ if sc, ok := c.(Func7x2); ok {
return sc
}
- return &shimCaller7x2{inner: c}
+ return &shimFunc7x2{inner: c}
}
-func MakeCaller7x2(fn interface{}) Caller7x2 {
- return ToCaller7x2(MakeCaller(fn))
+func MakeFunc7x2(fn interface{}) Func7x2 {
+ return ToFunc7x2(MakeFunc(fn))
}
-type Caller7x3 interface {
- Caller
+type Func7x3 interface {
+ Func
Call7x3(interface{}, interface{}, interface{}, interface{}, interface{}, interface{}, interface{}) (interface{}, interface{}, interface{})
}
-type shimCaller7x3 struct {
- inner Caller
+type shimFunc7x3 struct {
+ inner Func
+}
+
+func (c *shimFunc7x3) Name() string {
+ return c.inner.Name()
}
-func (c *shimCaller7x3) Type() reflect.Type {
+func (c *shimFunc7x3) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller7x3) Call(args []interface{}) []interface{} {
+func (c *shimFunc7x3) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller7x3) Call7x3(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) (interface{}, interface{}, interface{}) {
+func (c *shimFunc7x3) Call7x3(arg0, arg1, arg2, arg3, arg4, arg5, arg6 interface{}) (interface{}, interface{}, interface{}) {
ret := c.inner.Call([]interface{}{arg0, arg1, arg2, arg3, arg4, arg5, arg6})
_ = ret
return ret[0], ret[1], ret[2]
}
-func ToCaller7x3(c Caller) Caller7x3 {
+func ToFunc7x3(c Func) Func7x3 {
if c.Type().NumIn() != 7 || c.Type().NumOut() != 3 {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller7x3); ok {
+ if sc, ok := c.(Func7x3); ok {
return sc
}
- return &shimCaller7x3{inner: c}
+ return &shimFunc7x3{inner: c}
}
-func MakeCaller7x3(fn interface{}) Caller7x3 {
- return ToCaller7x3(MakeCaller(fn))
+func MakeFunc7x3(fn interface{}) Func7x3 {
+ return ToFunc7x3(MakeFunc(fn))
}
diff --git a/sdks/go/pkg/beam/core/util/reflectx/calls.tmpl b/sdks/go/pkg/beam/core/util/reflectx/calls.tmpl
index 0d68b5c..60b6107 100644
--- a/sdks/go/pkg/beam/core/util/reflectx/calls.tmpl
+++ b/sdks/go/pkg/beam/core/util/reflectx/calls.tmpl
@@ -17,52 +17,56 @@ package reflectx
import "reflect"
-// Generated arity-specialized Caller implementations to avoid runtime temporary
+// Generated arity-specialized Func implementations to avoid runtime temporary
// slices. Code that knows the arity can potentially avoid that overhead in
// addition to avoiding the reflection call overhead.
//
-// We force CallerZxY to implement Caller as well to have a single registry. Concrete
-// caller implementations should implement the most specific supported variant. This
-// also allows more specific intermediate interfaces, such as Caller2bool, to be added
+// We force FuncXxY to implement Func as well to have a single registry. Concrete
+// Func implementations should implement the most specific supported variant. This
+// also allows more specific intermediate interfaces, such as Func2xbool, to be added
// later.
{{range $in := upto 8}}
{{range $out := upto 4}}
-type Caller{{$in}}x{{$out}} interface {
- Caller
+type Func{{$in}}x{{$out}} interface {
+ Func
Call{{$in}}x{{$out}}({{mktuple $in "interface{}"}}) ({{mktuple $out "interface{}"}})
}
-type shimCaller{{$in}}x{{$out}} struct {
- inner Caller
+type shimFunc{{$in}}x{{$out}} struct {
+ inner Func
}
-func (c *shimCaller{{$in}}x{{$out}}) Type() reflect.Type {
+func (c *shimFunc{{$in}}x{{$out}}) Name() string {
+ return c.inner.Name()
+}
+
+func (c *shimFunc{{$in}}x{{$out}}) Type() reflect.Type {
return c.inner.Type()
}
-func (c *shimCaller{{$in}}x{{$out}}) Call(args []interface{}) []interface{} {
+func (c *shimFunc{{$in}}x{{$out}}) Call(args []interface{}) []interface{} {
return c.inner.Call(args)
}
-func (c *shimCaller{{$in}}x{{$out}}) Call{{$in}}x{{$out}}({{mkargs $in "arg%v" "interface{}"}}) ({{mktuple $out "interface{}"}}) {
+func (c *shimFunc{{$in}}x{{$out}}) Call{{$in}}x{{$out}}({{mkargs $in "arg%v" "interface{}"}}) ({{mktuple $out "interface{}"}}) {
ret := c.inner.Call([]interface{}{ {{mktuplef $in "arg%v"}} })
_ = ret
return {{mktuplef $out "ret[%v]"}}
}
-func ToCaller{{$in}}x{{$out}}(c Caller) Caller{{$in}}x{{$out}} {
+func ToFunc{{$in}}x{{$out}}(c Func) Func{{$in}}x{{$out}} {
if c.Type().NumIn() != {{$in}} || c.Type().NumOut() != {{$out}} {
- panic("incompatible caller type")
+ panic("incompatible func type")
}
- if sc, ok := c.(Caller{{$in}}x{{$out}}); ok {
+ if sc, ok := c.(Func{{$in}}x{{$out}}); ok {
return sc
}
- return &shimCaller{{$in}}x{{$out}}{inner: c}
+ return &shimFunc{{$in}}x{{$out}}{inner: c}
}
-func MakeCaller{{$in}}x{{$out}}(fn interface{}) Caller{{$in}}x{{$out}} {
- return ToCaller{{$in}}x{{$out}}(MakeCaller(fn))
+func MakeFunc{{$in}}x{{$out}}(fn interface{}) Func{{$in}}x{{$out}} {
+ return ToFunc{{$in}}x{{$out}}(MakeFunc(fn))
}
{{end}}
{{end}}
diff --git a/sdks/go/pkg/beam/core/util/reflectx/json.go b/sdks/go/pkg/beam/core/util/reflectx/json.go
index f9142ef..530b9f8 100644
--- a/sdks/go/pkg/beam/core/util/reflectx/json.go
+++ b/sdks/go/pkg/beam/core/util/reflectx/json.go
@@ -26,7 +26,7 @@ import (
func UnmarshalJSON(t reflect.Type, str string) (interface{}, error) {
data := reflect.New(t).Interface()
if err := json.Unmarshal([]byte(str), data); err != nil {
- return nil, fmt.Errorf("Failed to decode data: %v", err)
+ return nil, fmt.Errorf("failed to decode data: %v", err)
}
return reflect.ValueOf(data).Elem().Interface(), nil
}
diff --git a/sdks/go/pkg/beam/transforms/filter/filter.go b/sdks/go/pkg/beam/transforms/filter/filter.go
index eb3de1e..dbb8a39 100644
--- a/sdks/go/pkg/beam/transforms/filter/filter.go
+++ b/sdks/go/pkg/beam/transforms/filter/filter.go
@@ -80,11 +80,11 @@ type filterFn struct {
// Include indicates whether to include or exclude elements that satisfy the predicate.
Include bool `json:"include"`
- fn reflectx.Caller1x1
+ fn reflectx.Func1x1
}
func (f *filterFn) Setup() {
- f.fn = reflectx.MakeCaller1x1(f.Predicate.Fn.Interface())
+ f.fn = reflectx.MakeFunc1x1(f.Predicate.Fn.Interface())
}
func (f *filterFn) ProcessElement(elm beam.T, emit func(beam.T)) {
--
To stop receiving notification emails like this one, please contact
"commits@beam.apache.org" <co...@beam.apache.org>.
[beam] 04/04: CR: fix comments
Posted by lc...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lcwik pushed a commit to branch go-sdk
in repository https://gitbox.apache.org/repos/asf/beam.git
commit e019f199cca2e98f9dc8e544d5e2c6796b1be3dc
Author: Henning Rohde <he...@google.com>
AuthorDate: Fri Jan 19 15:45:48 2018 -0800
CR: fix comments
---
sdks/go/pkg/beam/core/runtime/exec/encode.go | 2 +-
sdks/go/pkg/beam/core/util/reflectx/call.go | 6 +++---
2 files changed, 4 insertions(+), 4 deletions(-)
diff --git a/sdks/go/pkg/beam/core/runtime/exec/encode.go b/sdks/go/pkg/beam/core/runtime/exec/encode.go
index 2940578..7f6bbee 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/encode.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/encode.go
@@ -30,7 +30,7 @@ type Encoder interface {
}
func makeEncoder(fn reflectx.Func) Encoder {
- // Detect one of the valid decoder forms and allow it to be invoked
+ // Detect one of the valid encoder forms and allow it to be invoked
// efficiently, relying on the general reflectx.Func framework for
// avoiding expensive reflection calls. There are 4 forms:
//
diff --git a/sdks/go/pkg/beam/core/util/reflectx/call.go b/sdks/go/pkg/beam/core/util/reflectx/call.go
index d011ec5..fbca8e3 100644
--- a/sdks/go/pkg/beam/core/util/reflectx/call.go
+++ b/sdks/go/pkg/beam/core/util/reflectx/call.go
@@ -45,8 +45,8 @@ var (
funcsMu sync.Mutex
)
-// RegisterFunc registers an custom reflectFunc factory for the given type, such as
-// "func(int)bool". If multiple func factories are registered for the same type,
+// RegisterFunc registers an custom Func factory for the given type, such as
+// "func(int)bool". If multiple Func factories are registered for the same type,
// the last registration wins.
func RegisterFunc(t reflect.Type, maker func(interface{}) Func) {
funcsMu.Lock()
@@ -59,7 +59,7 @@ func RegisterFunc(t reflect.Type, maker func(interface{}) Func) {
funcs[key] = maker
}
-// MakeFunc returns a reflectFunc for given function.
+// MakeFunc returns a Func for given function.
func MakeFunc(fn interface{}) Func {
funcsMu.Lock()
maker, exists := funcs[reflect.TypeOf(fn).String()]
--
To stop receiving notification emails like this one, please contact
"commits@beam.apache.org" <co...@beam.apache.org>.
[beam] 02/04: Use reflectx.Func as the fundamental function
representation
Posted by lc...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lcwik pushed a commit to branch go-sdk
in repository https://gitbox.apache.org/repos/asf/beam.git
commit 09e98e44146fb0b814aa2afeb789ea57671e3f35
Author: Henning Rohde <he...@google.com>
AuthorDate: Thu Jan 18 10:54:30 2018 -0800
Use reflectx.Func as the fundamental function representation
* Dynamic functions can thus use it directly and avoid reflection
* Change decoders/encodes to simple wrappers over a reflectx.Func.
---
sdks/go/cmd/symtab/main.go | 4 +-
sdks/go/pkg/beam/core/funcx/fn.go | 37 +-
sdks/go/pkg/beam/core/funcx/fn_test.go | 3 +-
sdks/go/pkg/beam/core/graph/bind_test.go | 4 +-
sdks/go/pkg/beam/core/graph/coder/coder.go | 8 +-
sdks/go/pkg/beam/core/graph/edge.go | 4 +-
sdks/go/pkg/beam/core/graph/fn.go | 32 +-
sdks/go/pkg/beam/core/runtime/exec/coder.go | 8 +-
sdks/go/pkg/beam/core/runtime/exec/combine.go | 2 +-
sdks/go/pkg/beam/core/runtime/exec/decode.go | 108 +-
sdks/go/pkg/beam/core/runtime/exec/decoders.go | 1347 --
sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl | 89 -
sdks/go/pkg/beam/core/runtime/exec/emit.go | 2 -
sdks/go/pkg/beam/core/runtime/exec/emitters.go | 14214 ------------------
sdks/go/pkg/beam/core/runtime/exec/encode.go | 109 +-
sdks/go/pkg/beam/core/runtime/exec/encoders.go | 1171 --
sdks/go/pkg/beam/core/runtime/exec/encoders.tmpl | 81 -
sdks/go/pkg/beam/core/runtime/exec/fn.go | 15 +-
sdks/go/pkg/beam/core/runtime/exec/fn_test.go | 15 +-
sdks/go/pkg/beam/core/runtime/exec/input.go | 2 -
.../core/runtime/exec/{ => optimized}/callers.go | 2 +-
.../core/runtime/exec/{ => optimized}/callers.tmpl | 6 +-
.../beam/core/runtime/exec/optimized/decoders.go | 2407 ++++
.../beam/core/runtime/exec/optimized/decoders.tmpl | 146 +
.../beam/core/runtime/exec/optimized/emitters.go | 14215 +++++++++++++++++++
.../runtime/exec/{ => optimized}/emitters.tmpl | 32 +-
.../beam/core/runtime/exec/optimized/encoders.go | 2299 +++
.../beam/core/runtime/exec/optimized/encoders.tmpl | 146 +
.../go/pkg/beam/core/runtime/exec/optimized/gen.go | 27 +
.../core/runtime/exec/{ => optimized}/inputs.go | 4055 +++---
.../core/runtime/exec/{ => optimized}/inputs.tmpl | 26 +-
sdks/go/pkg/beam/core/runtime/exec/util.go | 11 -
sdks/go/pkg/beam/core/runtime/graphx/serialize.go | 11 +-
sdks/go/pkg/beam/core/runtime/graphx/translate.go | 2 +-
sdks/go/pkg/beam/core/runtime/graphx/user.go | 11 +-
sdks/go/pkg/beam/core/util/reflectx/call.go | 13 +
sdks/go/pkg/beam/encoding.go | 23 +-
sdks/go/pkg/beam/partition.go | 62 +-
sdks/go/pkg/beam/transforms/filter/filter.go | 8 +-
sdks/go/pkg/beam/transforms/top/top.go | 33 +-
sdks/go/pkg/beam/transforms/top/top_test.go | 7 +-
sdks/go/pkg/beam/x/beamx/run.go | 2 +
42 files changed, 21596 insertions(+), 19203 deletions(-)
diff --git a/sdks/go/cmd/symtab/main.go b/sdks/go/cmd/symtab/main.go
index 0a46d5b..f4454b2 100644
--- a/sdks/go/cmd/symtab/main.go
+++ b/sdks/go/cmd/symtab/main.go
@@ -72,12 +72,12 @@ func main() {
// Restarts counter and calls increment function by its address.
counter = 0
- ret, err := funcx.New(reflectx.LoadFunction(addr, t))
+ ret, err := funcx.New(reflectx.MakeFunc(reflectx.LoadFunction(addr, t)))
if err != nil {
log.Fatalf("error creating function out of address")
return
}
- ret.Fn.Call([]reflect.Value{reflect.ValueOf(arg)})
+ ret.Fn.Call([]interface{}{arg})
// Checks that function was executed.
if counter != 1 {
diff --git a/sdks/go/pkg/beam/core/funcx/fn.go b/sdks/go/pkg/beam/core/funcx/fn.go
index 5d1b8f1..b39f08d 100644
--- a/sdks/go/pkg/beam/core/funcx/fn.go
+++ b/sdks/go/pkg/beam/core/funcx/fn.go
@@ -19,7 +19,6 @@ import (
"errors"
"fmt"
"reflect"
- "runtime"
"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
"github.com/apache/beam/sdks/go/pkg/beam/core/util/reflectx"
@@ -128,8 +127,7 @@ type ReturnParam struct {
// Fn is the reflected user function or method, preprocessed. This wrapper
// is useful both at graph construction time as well as execution time.
type Fn struct {
- Name string // robust name
- Fn reflect.Value
+ Fn reflectx.Func
Param []FnParam
Ret []ReturnParam
@@ -212,20 +210,13 @@ func (u *Fn) String() string {
return fmt.Sprintf("%+v", *u)
}
-// New returns a Fn from a function, if valid. Closures are considered valid
-// here, but will be rejected if they are attempted to be serialized.
-func New(dofn interface{}) (*Fn, error) {
- fn := reflect.ValueOf(dofn)
- if fn.Kind() != reflect.Func {
- return nil, fmt.Errorf("not a function or method: %v", fn.Kind())
- }
-
- name := runtime.FuncForPC(fn.Pointer()).Name()
- fntype := fn.Type()
-
+// New returns a Fn from a user function, if valid. Closures and dynamically
+// created functions are considered valid here, but will be rejected if they
+// are attempted to be serialized.
+func New(fn reflectx.Func) (*Fn, error) {
var param []FnParam
- for i := 0; i < fntype.NumIn(); i++ {
- t := fntype.In(i)
+ for i := 0; i < fn.Type().NumIn(); i++ {
+ t := fn.Type().In(i)
kind := FnIllegal
switch {
@@ -244,15 +235,15 @@ func New(dofn interface{}) (*Fn, error) {
case IsReIter(t):
kind = FnReIter
default:
- return nil, fmt.Errorf("bad parameter type for %s: %v", name, t)
+ return nil, fmt.Errorf("bad parameter type for %s: %v", fn.Name(), t)
}
param = append(param, FnParam{Kind: kind, T: t})
}
var ret []ReturnParam
- for i := 0; i < fntype.NumOut(); i++ {
- t := fntype.Out(i)
+ for i := 0; i < fn.Type().NumOut(); i++ {
+ t := fn.Type().Out(i)
kind := RetIllegal
switch {
@@ -263,13 +254,13 @@ func New(dofn interface{}) (*Fn, error) {
case typex.IsContainer(t), typex.IsConcrete(t), typex.IsUniversal(t):
kind = RetValue
default:
- return nil, fmt.Errorf("bad return type for %s: %v", name, t)
+ return nil, fmt.Errorf("bad return type for %s: %v", fn.Name(), t)
}
ret = append(ret, ReturnParam{Kind: kind, T: t})
}
- u := &Fn{Fn: fn, Name: name, Param: param, Ret: ret}
+ u := &Fn{Fn: fn, Param: param, Ret: ret}
if err := validateOrder(u); err != nil {
return nil, err
@@ -308,14 +299,14 @@ func validateOrder(u *Fn) error {
// Validate the parameter ordering.
for i, p := range u.Param {
if paramState, err = nextParamState(paramState, p.Kind); err != nil {
- return fmt.Errorf("%s at parameter %d for %s", err.Error(), i, u.Name)
+ return fmt.Errorf("%s at parameter %d for %s", err.Error(), i, u.Fn.Name())
}
}
// Validate the return value ordering.
retState := rsStart
for i, r := range u.Ret {
if retState, err = nextRetState(retState, r.Kind); err != nil {
- return fmt.Errorf("%s for return value %d for %s", err.Error(), i, u.Name)
+ return fmt.Errorf("%s for return value %d for %s", err.Error(), i, u.Fn.Name())
}
}
return nil
diff --git a/sdks/go/pkg/beam/core/funcx/fn_test.go b/sdks/go/pkg/beam/core/funcx/fn_test.go
index 81a24e6..da120dd 100644
--- a/sdks/go/pkg/beam/core/funcx/fn_test.go
+++ b/sdks/go/pkg/beam/core/funcx/fn_test.go
@@ -22,6 +22,7 @@ import (
"testing"
"github.com/apache/beam/sdks/go/pkg/beam/core/typex"
+ "github.com/apache/beam/sdks/go/pkg/beam/core/util/reflectx"
)
type foo struct {
@@ -180,7 +181,7 @@ func TestNew(t *testing.T) {
for _, test := range tests {
test := test
t.Run(test.Name, func(t *testing.T) {
- u, err := New(test.Fn)
+ u, err := New(reflectx.MakeFunc(test.Fn))
if err != nil {
if test.Err == nil {
t.Fatalf("Expected test.Err to be set; got: New(%v) failed: %v", test.Fn, err)
diff --git a/sdks/go/pkg/beam/core/graph/bind_test.go b/sdks/go/pkg/beam/core/graph/bind_test.go
index b9ec1ea..c462780 100644
--- a/sdks/go/pkg/beam/core/graph/bind_test.go
+++ b/sdks/go/pkg/beam/core/graph/bind_test.go
@@ -124,7 +124,7 @@ func TestBind(t *testing.T) {
}
for _, test := range tests {
- fn, err := funcx.New(test.Fn)
+ fn, err := funcx.New(reflectx.MakeFunc(test.Fn))
if err != nil {
t.Errorf("Invalid Fn: %v", err)
continue
@@ -172,7 +172,7 @@ func TestBindWithTypedefs(t *testing.T) {
}
for _, test := range tests {
- fn, err := funcx.New(test.Fn)
+ fn, err := funcx.New(reflectx.MakeFunc(test.Fn))
if err != nil {
t.Errorf("Invalid Fn: %v", err)
continue
diff --git a/sdks/go/pkg/beam/core/graph/coder/coder.go b/sdks/go/pkg/beam/core/graph/coder/coder.go
index 1c46d7a..d342b74 100644
--- a/sdks/go/pkg/beam/core/graph/coder/coder.go
+++ b/sdks/go/pkg/beam/core/graph/coder/coder.go
@@ -62,10 +62,10 @@ func (c *CustomCoder) Equals(o *CustomCoder) bool {
if c.Type != o.Type {
return false
}
- if c.Dec.Name != o.Dec.Name {
+ if c.Dec.Fn.Name() != o.Dec.Fn.Name() {
return false
}
- return c.Enc.Name == o.Enc.Name
+ return c.Enc.Fn.Name() == o.Enc.Fn.Name()
}
func (c *CustomCoder) String() string {
@@ -90,7 +90,7 @@ var (
// NewCustomCoder creates a coder for the supplied parameters defining a
// particular encoding strategy.
func NewCustomCoder(id string, t reflect.Type, encode, decode interface{}) (*CustomCoder, error) {
- enc, err := funcx.New(encode)
+ enc, err := funcx.New(reflectx.MakeFunc(encode))
if err != nil {
return nil, fmt.Errorf("bad encode: %v", err)
}
@@ -98,7 +98,7 @@ func NewCustomCoder(id string, t reflect.Type, encode, decode interface{}) (*Cus
return nil, fmt.Errorf("encode has incorrect signature: %v", err)
}
- dec, err := funcx.New(decode)
+ dec, err := funcx.New(reflectx.MakeFunc(decode))
if err != nil {
return nil, fmt.Errorf("bad decode: %v", err)
}
diff --git a/sdks/go/pkg/beam/core/graph/edge.go b/sdks/go/pkg/beam/core/graph/edge.go
index 4044cfa..2104025 100644
--- a/sdks/go/pkg/beam/core/graph/edge.go
+++ b/sdks/go/pkg/beam/core/graph/edge.go
@@ -314,9 +314,7 @@ func NewCombine(g *Graph, s *Scope, u *CombineFn, in []*Node) (*MultiEdge, error
// MergeAccumulators is guaranteed to exist. We do not allow the accumulator
// to be a tuple type (i.e., so one can't define a inline KV merge function).
- synth := &funcx.Fn{
- Name: u.Name(),
- }
+ synth := &funcx.Fn{}
if f := u.AddInputFn(); f != nil {
synth.Param = f.Param[1:] // drop accumulator parameter.
} else {
diff --git a/sdks/go/pkg/beam/core/graph/fn.go b/sdks/go/pkg/beam/core/graph/fn.go
index 1326375..032227f 100644
--- a/sdks/go/pkg/beam/core/graph/fn.go
+++ b/sdks/go/pkg/beam/core/graph/fn.go
@@ -43,7 +43,7 @@ type Fn struct {
// Name returns the name of the function or struct.
func (f *Fn) Name() string {
if f.Fn != nil {
- return f.Fn.Name
+ return f.Fn.Fn.Name()
}
t := reflectx.SkipPtr(reflect.TypeOf(f.Recv))
return fmt.Sprintf("%v.%v", t.PkgPath(), t.Name())
@@ -51,42 +51,38 @@ func (f *Fn) Name() string {
// DynFn is a generator for dynamically-created functions:
//
-// gen: []byte -> T
+// gen: (name string, t reflect.Type, []byte) -> func : T
//
-// where the generated function, fn : T, is created by reflect.MakeFunc and
-// uses reflect.Values. The type, T, must be a valid funcx.Fn type. The
-// generator takes some arbitrary data as a []byte input. This concept allows
-// serialization of dynamically-generated functions, which do not have a valid
-// (unique) symbol. All such functions use the "reflect.makeFuncStub" symbol.
+// where the generated function, fn : T, is re-created at runtime. This concept
+// allows serialization of dynamically-generated functions, which do not have a
+// valid (unique) symbol such as one created via reflect.MakeFunc.
type DynFn struct {
- // Name is the (fake) name of the function. The actual symbol name is
- // always "reflect.makeFuncStub".
+ // Name is the name of the function. It does not have to be a valid symbol.
Name string
- // T is the type of the function
+ // T is the type of the generated function
T reflect.Type
- // Data holds the data for the generator.
+ // Data holds the data for the generator. This data is trivially serializable.
Data []byte
- // Gen is the function generator.
- Gen func([]byte) func([]reflect.Value) []reflect.Value
+ // Gen is the function generator. The function generator itself must be a
+ // function with a unique symbol.
+ Gen func(string, reflect.Type, []byte) reflectx.Func
}
// NewFn pre-processes a function, dynamic function or struct for graph
// construction.
func NewFn(fn interface{}) (*Fn, error) {
if gen, ok := fn.(*DynFn); ok {
- f, err := funcx.New(reflect.MakeFunc(gen.T, gen.Gen(gen.Data)).Interface())
+ f, err := funcx.New(gen.Gen(gen.Name, gen.T, gen.Data))
if err != nil {
return nil, err
}
- f.Name = gen.Name
-
return &Fn{Fn: f, DynFn: gen}, nil
}
val := reflect.ValueOf(fn)
switch val.Type().Kind() {
case reflect.Func:
- f, err := funcx.New(fn)
+ f, err := funcx.New(reflectx.MakeFunc(fn))
if err != nil {
return nil, err
}
@@ -120,7 +116,7 @@ func NewFn(fn interface{}) (*Fn, error) {
// serialize each method, call them explicitly and avoid struct
// registration.
- f, err := funcx.New(val.Method(i).Interface())
+ f, err := funcx.New(reflectx.MakeFunc(val.Method(i).Interface()))
if err != nil {
return nil, fmt.Errorf("method %v invalid: %v", m.Name, err)
}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/coder.go b/sdks/go/pkg/beam/core/runtime/exec/coder.go
index 8c4e6a5..058d3da 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/coder.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/coder.go
@@ -89,7 +89,7 @@ func MakeElementEncoder(c *coder.Coder) ElementEncoder {
case coder.Custom:
return &customEncoder{
t: c.Custom.Type,
- enc: makeEncoder(c.Custom.Enc),
+ enc: makeEncoder(c.Custom.Enc.Fn),
}
case coder.KV:
@@ -116,7 +116,7 @@ func MakeElementDecoder(c *coder.Coder) ElementDecoder {
case coder.Custom:
return &customDecoder{
t: c.Custom.Type,
- dec: makeDecoder(c.Custom.Dec),
+ dec: makeDecoder(c.Custom.Dec.Fn),
}
case coder.KV:
@@ -190,7 +190,7 @@ type customEncoder struct {
func (c *customEncoder) Encode(val FullValue, w io.Writer) error {
// (1) Call encode
- data, err := c.enc.Encode(c.t, val.Elm)
+ data, err := c.enc.Encode(c.t, val.Elm.Interface())
if err != nil {
return err
}
@@ -228,7 +228,7 @@ func (c *customDecoder) Decode(r io.Reader) (FullValue, error) {
if err != nil {
return FullValue{}, err
}
- return FullValue{Elm: val}, err
+ return FullValue{Elm: reflect.ValueOf(val)}, err
}
type kvEncoder struct {
diff --git a/sdks/go/pkg/beam/core/runtime/exec/combine.go b/sdks/go/pkg/beam/core/runtime/exec/combine.go
index 83b42d2..18df9d1 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/combine.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/combine.go
@@ -60,7 +60,7 @@ func (n *Combine) Up(ctx context.Context) error {
}
if n.Edge.CombineFn.AddInputFn() == nil {
- n.mergeFn = reflectx.MakeFunc2x1(n.Edge.CombineFn.MergeAccumulatorsFn().Fn.Interface())
+ n.mergeFn = reflectx.ToFunc2x1(n.Edge.CombineFn.MergeAccumulatorsFn().Fn)
}
// TODO(herohde) 6/28/2017: maybe record the per-key mode in the Edge
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decode.go b/sdks/go/pkg/beam/core/runtime/exec/decode.go
index 248eee7..93fa345 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/decode.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/decode.go
@@ -16,75 +16,87 @@
package exec
import (
- "context"
"fmt"
"reflect"
- "sync"
- "github.com/apache/beam/sdks/go/pkg/beam/core/funcx"
- "github.com/apache/beam/sdks/go/pkg/beam/log"
+ "github.com/apache/beam/sdks/go/pkg/beam/core/util/reflectx"
)
-//go:generate specialize --input=decoders.tmpl --x=data,universals
-
-// Decoder is a uniform custom encoder interface.
+// Decoder is a uniform custom encoder interface. It wraps various
+// forms of reflectx.Funcs.
type Decoder interface {
// Decode decodes the []byte in to a value of the given type.
- Decode(reflect.Type, []byte) (reflect.Value, error)
+ Decode(reflect.Type, []byte) (interface{}, error)
}
-var (
- decoders = make(map[string]func(reflect.Value) Decoder)
- decodersMu sync.Mutex
-)
-
-// RegisterDecoder registers an custom decoder invoker for the given type,
-// such as "func(int)[]byte". If multiple decoder invokers are registered
-// for the same type, the last registration wins.
-func RegisterDecoder(t reflect.Type, maker func(reflect.Value) Decoder) {
- decodersMu.Lock()
- defer decodersMu.Unlock()
+func makeDecoder(fn reflectx.Func) Decoder {
+ // Detect one of the valid decoder forms and allow it to be invoked
+ // efficiently, relying on the general reflectx.Func framework for
+ // avoiding expensive reflection calls. There are 4 forms:
+ //
+ // []byte -> T
+ // []byte -> (T, error)
+ // (Type, []byte) -> T
+ // (Type, []byte) -> (T, error)
+ //
+ // We simply enumerate the forms. The wrappers simply ignore the
+ // appropriate parts.
- key := t.String()
- if _, exists := decoders[key]; exists {
- log.Warnf(context.Background(), "Decoder for %v already registered. Overwriting.", key)
+ switch fn.Type().NumIn() {
+ case 1:
+ switch fn.Type().NumOut() {
+ case 1:
+ return &decoder1x1{fn: reflectx.ToFunc1x1(fn)}
+ case 2:
+ return &decoder1x2{fn: reflectx.ToFunc1x2(fn)}
+ }
+ case 2:
+ switch fn.Type().NumOut() {
+ case 1:
+ return &decoder2x1{fn: reflectx.ToFunc2x1(fn)}
+ case 2:
+ return &decoder2x2{fn: reflectx.ToFunc2x2(fn)}
+ }
}
- decoders[key] = maker
+ panic(fmt.Sprintf("Invalid decoder: %v", fn))
}
-func makeDecoder(fn *funcx.Fn) Decoder {
- decodersMu.Lock()
- maker, exists := decoders[fn.Fn.Type().String()]
- decodersMu.Unlock()
+type decoder1x1 struct {
+ fn reflectx.Func1x1
+}
- if exists {
- return maker(fn.Fn)
- }
+func (d *decoder1x1) Decode(t reflect.Type, data []byte) (interface{}, error) {
+ return d.fn.Call1x1(data), nil
+}
+
+type decoder1x2 struct {
+ fn reflectx.Func1x2
+}
- // If no specialized implementation is available, we use the (slower)
- // reflection-based one.
+func (d *decoder1x2) Decode(t reflect.Type, data []byte) (interface{}, error) {
+ val, err := d.fn.Call1x2(data)
+ if err != nil {
+ return nil, err.(error)
+ }
+ return val, nil
+}
- return &decoder{fn: fn}
+type decoder2x1 struct {
+ fn reflectx.Func2x1
}
-type decoder struct {
- fn *funcx.Fn
+func (d *decoder2x1) Decode(t reflect.Type, data []byte) (interface{}, error) {
+ return d.fn.Call2x1(t, data), nil
}
-func (d *decoder) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- args := make([]reflect.Value, len(d.fn.Param))
- if index, ok := d.fn.Type(); ok {
- args[index] = reflect.ValueOf(t)
- }
- params := d.fn.Params(funcx.FnValue)
- args[params[0]] = reflect.ValueOf(data)
+type decoder2x2 struct {
+ fn reflectx.Func2x2
+}
- ret, err := reflectCallNoPanic(d.fn.Fn, args)
+func (d *decoder2x2) Decode(t reflect.Type, data []byte) (interface{}, error) {
+ val, err := d.fn.Call2x2(t, data)
if err != nil {
- return reflect.Value{}, err
- }
- if index, ok := d.fn.Error(); ok && !ret[index].IsNil() {
- return reflect.Value{}, fmt.Errorf("decode error: %v", ret[index].Interface())
+ return nil, err.(error)
}
- return ret[d.fn.Returns(funcx.RetValue)[0]], nil
+ return val, nil
}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decoders.go b/sdks/go/pkg/beam/core/runtime/exec/decoders.go
deleted file mode 100644
index 6f191c7..0000000
--- a/sdks/go/pkg/beam/core/runtime/exec/decoders.go
+++ /dev/null
@@ -1,1347 +0,0 @@
-// File generated by specialize. Do not edit.
-
-// Licensed to the Apache Software Foundation (ASF) under one or more
-// contributor license agreements. See the NOTICE file distributed with
-// this work for additional information regarding copyright ownership.
-// The ASF licenses this file to You under the Apache License, Version 2.0
-// (the "License"); you may not use this file except in compliance with
-// the License. You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package exec
-
-import (
- "reflect"
-
- "github.com/apache/beam/sdks/go/pkg/beam/core/typex"
-)
-
-func init() {
- RegisterDecoder(reflect.TypeOf((*func([]byte) []byte)(nil)).Elem(), decoderMakerByteSlice)
- RegisterDecoder(reflect.TypeOf((*func([]byte) ([]byte, error))(nil)).Elem(), decoderMakerByteSliceE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) []byte)(nil)).Elem(), decoderMakerTByteSlice)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) ([]byte, error))(nil)).Elem(), decoderMakerTByteSliceE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) bool)(nil)).Elem(), decoderMakerBool)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (bool, error))(nil)).Elem(), decoderMakerBoolE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) bool)(nil)).Elem(), decoderMakerTBool)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (bool, error))(nil)).Elem(), decoderMakerTBoolE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) string)(nil)).Elem(), decoderMakerString)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (string, error))(nil)).Elem(), decoderMakerStringE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) string)(nil)).Elem(), decoderMakerTString)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (string, error))(nil)).Elem(), decoderMakerTStringE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) int)(nil)).Elem(), decoderMakerInt)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (int, error))(nil)).Elem(), decoderMakerIntE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int)(nil)).Elem(), decoderMakerTInt)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int, error))(nil)).Elem(), decoderMakerTIntE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) int8)(nil)).Elem(), decoderMakerInt8)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (int8, error))(nil)).Elem(), decoderMakerInt8E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int8)(nil)).Elem(), decoderMakerTInt8)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int8, error))(nil)).Elem(), decoderMakerTInt8E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) int16)(nil)).Elem(), decoderMakerInt16)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (int16, error))(nil)).Elem(), decoderMakerInt16E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int16)(nil)).Elem(), decoderMakerTInt16)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int16, error))(nil)).Elem(), decoderMakerTInt16E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) int32)(nil)).Elem(), decoderMakerInt32)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (int32, error))(nil)).Elem(), decoderMakerInt32E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int32)(nil)).Elem(), decoderMakerTInt32)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int32, error))(nil)).Elem(), decoderMakerTInt32E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) int64)(nil)).Elem(), decoderMakerInt64)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (int64, error))(nil)).Elem(), decoderMakerInt64E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) int64)(nil)).Elem(), decoderMakerTInt64)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (int64, error))(nil)).Elem(), decoderMakerTInt64E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) uint)(nil)).Elem(), decoderMakerUint)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (uint, error))(nil)).Elem(), decoderMakerUintE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint)(nil)).Elem(), decoderMakerTUint)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint, error))(nil)).Elem(), decoderMakerTUintE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) uint8)(nil)).Elem(), decoderMakerUint8)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (uint8, error))(nil)).Elem(), decoderMakerUint8E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint8)(nil)).Elem(), decoderMakerTUint8)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint8, error))(nil)).Elem(), decoderMakerTUint8E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) uint16)(nil)).Elem(), decoderMakerUint16)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (uint16, error))(nil)).Elem(), decoderMakerUint16E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint16)(nil)).Elem(), decoderMakerTUint16)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint16, error))(nil)).Elem(), decoderMakerTUint16E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) uint32)(nil)).Elem(), decoderMakerUint32)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (uint32, error))(nil)).Elem(), decoderMakerUint32E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint32)(nil)).Elem(), decoderMakerTUint32)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint32, error))(nil)).Elem(), decoderMakerTUint32E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) uint64)(nil)).Elem(), decoderMakerUint64)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (uint64, error))(nil)).Elem(), decoderMakerUint64E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) uint64)(nil)).Elem(), decoderMakerTUint64)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (uint64, error))(nil)).Elem(), decoderMakerTUint64E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) float32)(nil)).Elem(), decoderMakerFloat32)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (float32, error))(nil)).Elem(), decoderMakerFloat32E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) float32)(nil)).Elem(), decoderMakerTFloat32)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (float32, error))(nil)).Elem(), decoderMakerTFloat32E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) float64)(nil)).Elem(), decoderMakerFloat64)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (float64, error))(nil)).Elem(), decoderMakerFloat64E)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) float64)(nil)).Elem(), decoderMakerTFloat64)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (float64, error))(nil)).Elem(), decoderMakerTFloat64E)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.T)(nil)).Elem(), decoderMakerTypex_T)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.T, error))(nil)).Elem(), decoderMakerTypex_TE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.T)(nil)).Elem(), decoderMakerTTypex_T)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.T, error))(nil)).Elem(), decoderMakerTTypex_TE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.U)(nil)).Elem(), decoderMakerTypex_U)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.U, error))(nil)).Elem(), decoderMakerTypex_UE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.U)(nil)).Elem(), decoderMakerTTypex_U)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.U, error))(nil)).Elem(), decoderMakerTTypex_UE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.V)(nil)).Elem(), decoderMakerTypex_V)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.V, error))(nil)).Elem(), decoderMakerTypex_VE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.V)(nil)).Elem(), decoderMakerTTypex_V)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.V, error))(nil)).Elem(), decoderMakerTTypex_VE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.W)(nil)).Elem(), decoderMakerTypex_W)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.W, error))(nil)).Elem(), decoderMakerTypex_WE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.W)(nil)).Elem(), decoderMakerTTypex_W)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.W, error))(nil)).Elem(), decoderMakerTTypex_WE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.X)(nil)).Elem(), decoderMakerTypex_X)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.X, error))(nil)).Elem(), decoderMakerTypex_XE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.X)(nil)).Elem(), decoderMakerTTypex_X)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.X, error))(nil)).Elem(), decoderMakerTTypex_XE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.Y)(nil)).Elem(), decoderMakerTypex_Y)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.Y, error))(nil)).Elem(), decoderMakerTypex_YE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.Y)(nil)).Elem(), decoderMakerTTypex_Y)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.Y, error))(nil)).Elem(), decoderMakerTTypex_YE)
- RegisterDecoder(reflect.TypeOf((*func([]byte) typex.Z)(nil)).Elem(), decoderMakerTypex_Z)
- RegisterDecoder(reflect.TypeOf((*func([]byte) (typex.Z, error))(nil)).Elem(), decoderMakerTypex_ZE)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) typex.Z)(nil)).Elem(), decoderMakerTTypex_Z)
- RegisterDecoder(reflect.TypeOf((*func(reflect.Type, []byte) (typex.Z, error))(nil)).Elem(), decoderMakerTTypex_ZE)
-}
-
-type decoderByteSlice struct {
- fn func([]byte) []byte
-}
-
-func (e *decoderByteSlice) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerByteSlice(fn reflect.Value) Decoder {
- return &decoderByteSlice{fn: fn.Interface().(func([]byte) []byte)}
-}
-
-type decoderByteSliceE struct {
- fn func([]byte) ([]byte, error)
-}
-
-func (e *decoderByteSliceE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerByteSliceE(fn reflect.Value) Decoder {
- return &decoderByteSliceE{fn: fn.Interface().(func([]byte) ([]byte, error))}
-}
-
-type decoderTByteSlice struct {
- fn func(reflect.Type, []byte) []byte
-}
-
-func (e *decoderTByteSlice) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTByteSlice(fn reflect.Value) Decoder {
- return &decoderTByteSlice{fn: fn.Interface().(func(reflect.Type, []byte) []byte)}
-}
-
-type decoderTByteSliceE struct {
- fn func(reflect.Type, []byte) ([]byte, error)
-}
-
-func (e *decoderTByteSliceE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTByteSliceE(fn reflect.Value) Decoder {
- return &decoderTByteSliceE{fn: fn.Interface().(func(reflect.Type, []byte) ([]byte, error))}
-}
-
-type decoderBool struct {
- fn func([]byte) bool
-}
-
-func (e *decoderBool) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerBool(fn reflect.Value) Decoder {
- return &decoderBool{fn: fn.Interface().(func([]byte) bool)}
-}
-
-type decoderBoolE struct {
- fn func([]byte) (bool, error)
-}
-
-func (e *decoderBoolE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerBoolE(fn reflect.Value) Decoder {
- return &decoderBoolE{fn: fn.Interface().(func([]byte) (bool, error))}
-}
-
-type decoderTBool struct {
- fn func(reflect.Type, []byte) bool
-}
-
-func (e *decoderTBool) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTBool(fn reflect.Value) Decoder {
- return &decoderTBool{fn: fn.Interface().(func(reflect.Type, []byte) bool)}
-}
-
-type decoderTBoolE struct {
- fn func(reflect.Type, []byte) (bool, error)
-}
-
-func (e *decoderTBoolE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTBoolE(fn reflect.Value) Decoder {
- return &decoderTBoolE{fn: fn.Interface().(func(reflect.Type, []byte) (bool, error))}
-}
-
-type decoderString struct {
- fn func([]byte) string
-}
-
-func (e *decoderString) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerString(fn reflect.Value) Decoder {
- return &decoderString{fn: fn.Interface().(func([]byte) string)}
-}
-
-type decoderStringE struct {
- fn func([]byte) (string, error)
-}
-
-func (e *decoderStringE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerStringE(fn reflect.Value) Decoder {
- return &decoderStringE{fn: fn.Interface().(func([]byte) (string, error))}
-}
-
-type decoderTString struct {
- fn func(reflect.Type, []byte) string
-}
-
-func (e *decoderTString) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTString(fn reflect.Value) Decoder {
- return &decoderTString{fn: fn.Interface().(func(reflect.Type, []byte) string)}
-}
-
-type decoderTStringE struct {
- fn func(reflect.Type, []byte) (string, error)
-}
-
-func (e *decoderTStringE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTStringE(fn reflect.Value) Decoder {
- return &decoderTStringE{fn: fn.Interface().(func(reflect.Type, []byte) (string, error))}
-}
-
-type decoderInt struct {
- fn func([]byte) int
-}
-
-func (e *decoderInt) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerInt(fn reflect.Value) Decoder {
- return &decoderInt{fn: fn.Interface().(func([]byte) int)}
-}
-
-type decoderIntE struct {
- fn func([]byte) (int, error)
-}
-
-func (e *decoderIntE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerIntE(fn reflect.Value) Decoder {
- return &decoderIntE{fn: fn.Interface().(func([]byte) (int, error))}
-}
-
-type decoderTInt struct {
- fn func(reflect.Type, []byte) int
-}
-
-func (e *decoderTInt) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTInt(fn reflect.Value) Decoder {
- return &decoderTInt{fn: fn.Interface().(func(reflect.Type, []byte) int)}
-}
-
-type decoderTIntE struct {
- fn func(reflect.Type, []byte) (int, error)
-}
-
-func (e *decoderTIntE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTIntE(fn reflect.Value) Decoder {
- return &decoderTIntE{fn: fn.Interface().(func(reflect.Type, []byte) (int, error))}
-}
-
-type decoderInt8 struct {
- fn func([]byte) int8
-}
-
-func (e *decoderInt8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerInt8(fn reflect.Value) Decoder {
- return &decoderInt8{fn: fn.Interface().(func([]byte) int8)}
-}
-
-type decoderInt8E struct {
- fn func([]byte) (int8, error)
-}
-
-func (e *decoderInt8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerInt8E(fn reflect.Value) Decoder {
- return &decoderInt8E{fn: fn.Interface().(func([]byte) (int8, error))}
-}
-
-type decoderTInt8 struct {
- fn func(reflect.Type, []byte) int8
-}
-
-func (e *decoderTInt8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTInt8(fn reflect.Value) Decoder {
- return &decoderTInt8{fn: fn.Interface().(func(reflect.Type, []byte) int8)}
-}
-
-type decoderTInt8E struct {
- fn func(reflect.Type, []byte) (int8, error)
-}
-
-func (e *decoderTInt8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTInt8E(fn reflect.Value) Decoder {
- return &decoderTInt8E{fn: fn.Interface().(func(reflect.Type, []byte) (int8, error))}
-}
-
-type decoderInt16 struct {
- fn func([]byte) int16
-}
-
-func (e *decoderInt16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerInt16(fn reflect.Value) Decoder {
- return &decoderInt16{fn: fn.Interface().(func([]byte) int16)}
-}
-
-type decoderInt16E struct {
- fn func([]byte) (int16, error)
-}
-
-func (e *decoderInt16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerInt16E(fn reflect.Value) Decoder {
- return &decoderInt16E{fn: fn.Interface().(func([]byte) (int16, error))}
-}
-
-type decoderTInt16 struct {
- fn func(reflect.Type, []byte) int16
-}
-
-func (e *decoderTInt16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTInt16(fn reflect.Value) Decoder {
- return &decoderTInt16{fn: fn.Interface().(func(reflect.Type, []byte) int16)}
-}
-
-type decoderTInt16E struct {
- fn func(reflect.Type, []byte) (int16, error)
-}
-
-func (e *decoderTInt16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTInt16E(fn reflect.Value) Decoder {
- return &decoderTInt16E{fn: fn.Interface().(func(reflect.Type, []byte) (int16, error))}
-}
-
-type decoderInt32 struct {
- fn func([]byte) int32
-}
-
-func (e *decoderInt32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerInt32(fn reflect.Value) Decoder {
- return &decoderInt32{fn: fn.Interface().(func([]byte) int32)}
-}
-
-type decoderInt32E struct {
- fn func([]byte) (int32, error)
-}
-
-func (e *decoderInt32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerInt32E(fn reflect.Value) Decoder {
- return &decoderInt32E{fn: fn.Interface().(func([]byte) (int32, error))}
-}
-
-type decoderTInt32 struct {
- fn func(reflect.Type, []byte) int32
-}
-
-func (e *decoderTInt32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTInt32(fn reflect.Value) Decoder {
- return &decoderTInt32{fn: fn.Interface().(func(reflect.Type, []byte) int32)}
-}
-
-type decoderTInt32E struct {
- fn func(reflect.Type, []byte) (int32, error)
-}
-
-func (e *decoderTInt32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTInt32E(fn reflect.Value) Decoder {
- return &decoderTInt32E{fn: fn.Interface().(func(reflect.Type, []byte) (int32, error))}
-}
-
-type decoderInt64 struct {
- fn func([]byte) int64
-}
-
-func (e *decoderInt64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerInt64(fn reflect.Value) Decoder {
- return &decoderInt64{fn: fn.Interface().(func([]byte) int64)}
-}
-
-type decoderInt64E struct {
- fn func([]byte) (int64, error)
-}
-
-func (e *decoderInt64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerInt64E(fn reflect.Value) Decoder {
- return &decoderInt64E{fn: fn.Interface().(func([]byte) (int64, error))}
-}
-
-type decoderTInt64 struct {
- fn func(reflect.Type, []byte) int64
-}
-
-func (e *decoderTInt64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTInt64(fn reflect.Value) Decoder {
- return &decoderTInt64{fn: fn.Interface().(func(reflect.Type, []byte) int64)}
-}
-
-type decoderTInt64E struct {
- fn func(reflect.Type, []byte) (int64, error)
-}
-
-func (e *decoderTInt64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTInt64E(fn reflect.Value) Decoder {
- return &decoderTInt64E{fn: fn.Interface().(func(reflect.Type, []byte) (int64, error))}
-}
-
-type decoderUint struct {
- fn func([]byte) uint
-}
-
-func (e *decoderUint) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerUint(fn reflect.Value) Decoder {
- return &decoderUint{fn: fn.Interface().(func([]byte) uint)}
-}
-
-type decoderUintE struct {
- fn func([]byte) (uint, error)
-}
-
-func (e *decoderUintE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerUintE(fn reflect.Value) Decoder {
- return &decoderUintE{fn: fn.Interface().(func([]byte) (uint, error))}
-}
-
-type decoderTUint struct {
- fn func(reflect.Type, []byte) uint
-}
-
-func (e *decoderTUint) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTUint(fn reflect.Value) Decoder {
- return &decoderTUint{fn: fn.Interface().(func(reflect.Type, []byte) uint)}
-}
-
-type decoderTUintE struct {
- fn func(reflect.Type, []byte) (uint, error)
-}
-
-func (e *decoderTUintE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTUintE(fn reflect.Value) Decoder {
- return &decoderTUintE{fn: fn.Interface().(func(reflect.Type, []byte) (uint, error))}
-}
-
-type decoderUint8 struct {
- fn func([]byte) uint8
-}
-
-func (e *decoderUint8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerUint8(fn reflect.Value) Decoder {
- return &decoderUint8{fn: fn.Interface().(func([]byte) uint8)}
-}
-
-type decoderUint8E struct {
- fn func([]byte) (uint8, error)
-}
-
-func (e *decoderUint8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerUint8E(fn reflect.Value) Decoder {
- return &decoderUint8E{fn: fn.Interface().(func([]byte) (uint8, error))}
-}
-
-type decoderTUint8 struct {
- fn func(reflect.Type, []byte) uint8
-}
-
-func (e *decoderTUint8) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTUint8(fn reflect.Value) Decoder {
- return &decoderTUint8{fn: fn.Interface().(func(reflect.Type, []byte) uint8)}
-}
-
-type decoderTUint8E struct {
- fn func(reflect.Type, []byte) (uint8, error)
-}
-
-func (e *decoderTUint8E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTUint8E(fn reflect.Value) Decoder {
- return &decoderTUint8E{fn: fn.Interface().(func(reflect.Type, []byte) (uint8, error))}
-}
-
-type decoderUint16 struct {
- fn func([]byte) uint16
-}
-
-func (e *decoderUint16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerUint16(fn reflect.Value) Decoder {
- return &decoderUint16{fn: fn.Interface().(func([]byte) uint16)}
-}
-
-type decoderUint16E struct {
- fn func([]byte) (uint16, error)
-}
-
-func (e *decoderUint16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerUint16E(fn reflect.Value) Decoder {
- return &decoderUint16E{fn: fn.Interface().(func([]byte) (uint16, error))}
-}
-
-type decoderTUint16 struct {
- fn func(reflect.Type, []byte) uint16
-}
-
-func (e *decoderTUint16) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTUint16(fn reflect.Value) Decoder {
- return &decoderTUint16{fn: fn.Interface().(func(reflect.Type, []byte) uint16)}
-}
-
-type decoderTUint16E struct {
- fn func(reflect.Type, []byte) (uint16, error)
-}
-
-func (e *decoderTUint16E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTUint16E(fn reflect.Value) Decoder {
- return &decoderTUint16E{fn: fn.Interface().(func(reflect.Type, []byte) (uint16, error))}
-}
-
-type decoderUint32 struct {
- fn func([]byte) uint32
-}
-
-func (e *decoderUint32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerUint32(fn reflect.Value) Decoder {
- return &decoderUint32{fn: fn.Interface().(func([]byte) uint32)}
-}
-
-type decoderUint32E struct {
- fn func([]byte) (uint32, error)
-}
-
-func (e *decoderUint32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerUint32E(fn reflect.Value) Decoder {
- return &decoderUint32E{fn: fn.Interface().(func([]byte) (uint32, error))}
-}
-
-type decoderTUint32 struct {
- fn func(reflect.Type, []byte) uint32
-}
-
-func (e *decoderTUint32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTUint32(fn reflect.Value) Decoder {
- return &decoderTUint32{fn: fn.Interface().(func(reflect.Type, []byte) uint32)}
-}
-
-type decoderTUint32E struct {
- fn func(reflect.Type, []byte) (uint32, error)
-}
-
-func (e *decoderTUint32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTUint32E(fn reflect.Value) Decoder {
- return &decoderTUint32E{fn: fn.Interface().(func(reflect.Type, []byte) (uint32, error))}
-}
-
-type decoderUint64 struct {
- fn func([]byte) uint64
-}
-
-func (e *decoderUint64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerUint64(fn reflect.Value) Decoder {
- return &decoderUint64{fn: fn.Interface().(func([]byte) uint64)}
-}
-
-type decoderUint64E struct {
- fn func([]byte) (uint64, error)
-}
-
-func (e *decoderUint64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerUint64E(fn reflect.Value) Decoder {
- return &decoderUint64E{fn: fn.Interface().(func([]byte) (uint64, error))}
-}
-
-type decoderTUint64 struct {
- fn func(reflect.Type, []byte) uint64
-}
-
-func (e *decoderTUint64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTUint64(fn reflect.Value) Decoder {
- return &decoderTUint64{fn: fn.Interface().(func(reflect.Type, []byte) uint64)}
-}
-
-type decoderTUint64E struct {
- fn func(reflect.Type, []byte) (uint64, error)
-}
-
-func (e *decoderTUint64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTUint64E(fn reflect.Value) Decoder {
- return &decoderTUint64E{fn: fn.Interface().(func(reflect.Type, []byte) (uint64, error))}
-}
-
-type decoderFloat32 struct {
- fn func([]byte) float32
-}
-
-func (e *decoderFloat32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerFloat32(fn reflect.Value) Decoder {
- return &decoderFloat32{fn: fn.Interface().(func([]byte) float32)}
-}
-
-type decoderFloat32E struct {
- fn func([]byte) (float32, error)
-}
-
-func (e *decoderFloat32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerFloat32E(fn reflect.Value) Decoder {
- return &decoderFloat32E{fn: fn.Interface().(func([]byte) (float32, error))}
-}
-
-type decoderTFloat32 struct {
- fn func(reflect.Type, []byte) float32
-}
-
-func (e *decoderTFloat32) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTFloat32(fn reflect.Value) Decoder {
- return &decoderTFloat32{fn: fn.Interface().(func(reflect.Type, []byte) float32)}
-}
-
-type decoderTFloat32E struct {
- fn func(reflect.Type, []byte) (float32, error)
-}
-
-func (e *decoderTFloat32E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTFloat32E(fn reflect.Value) Decoder {
- return &decoderTFloat32E{fn: fn.Interface().(func(reflect.Type, []byte) (float32, error))}
-}
-
-type decoderFloat64 struct {
- fn func([]byte) float64
-}
-
-func (e *decoderFloat64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerFloat64(fn reflect.Value) Decoder {
- return &decoderFloat64{fn: fn.Interface().(func([]byte) float64)}
-}
-
-type decoderFloat64E struct {
- fn func([]byte) (float64, error)
-}
-
-func (e *decoderFloat64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerFloat64E(fn reflect.Value) Decoder {
- return &decoderFloat64E{fn: fn.Interface().(func([]byte) (float64, error))}
-}
-
-type decoderTFloat64 struct {
- fn func(reflect.Type, []byte) float64
-}
-
-func (e *decoderTFloat64) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTFloat64(fn reflect.Value) Decoder {
- return &decoderTFloat64{fn: fn.Interface().(func(reflect.Type, []byte) float64)}
-}
-
-type decoderTFloat64E struct {
- fn func(reflect.Type, []byte) (float64, error)
-}
-
-func (e *decoderTFloat64E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTFloat64E(fn reflect.Value) Decoder {
- return &decoderTFloat64E{fn: fn.Interface().(func(reflect.Type, []byte) (float64, error))}
-}
-
-type decoderTypex_T struct {
- fn func([]byte) typex.T
-}
-
-func (e *decoderTypex_T) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_T(fn reflect.Value) Decoder {
- return &decoderTypex_T{fn: fn.Interface().(func([]byte) typex.T)}
-}
-
-type decoderTypex_TE struct {
- fn func([]byte) (typex.T, error)
-}
-
-func (e *decoderTypex_TE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_TE(fn reflect.Value) Decoder {
- return &decoderTypex_TE{fn: fn.Interface().(func([]byte) (typex.T, error))}
-}
-
-type decoderTTypex_T struct {
- fn func(reflect.Type, []byte) typex.T
-}
-
-func (e *decoderTTypex_T) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_T(fn reflect.Value) Decoder {
- return &decoderTTypex_T{fn: fn.Interface().(func(reflect.Type, []byte) typex.T)}
-}
-
-type decoderTTypex_TE struct {
- fn func(reflect.Type, []byte) (typex.T, error)
-}
-
-func (e *decoderTTypex_TE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_TE(fn reflect.Value) Decoder {
- return &decoderTTypex_TE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.T, error))}
-}
-
-type decoderTypex_U struct {
- fn func([]byte) typex.U
-}
-
-func (e *decoderTypex_U) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_U(fn reflect.Value) Decoder {
- return &decoderTypex_U{fn: fn.Interface().(func([]byte) typex.U)}
-}
-
-type decoderTypex_UE struct {
- fn func([]byte) (typex.U, error)
-}
-
-func (e *decoderTypex_UE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_UE(fn reflect.Value) Decoder {
- return &decoderTypex_UE{fn: fn.Interface().(func([]byte) (typex.U, error))}
-}
-
-type decoderTTypex_U struct {
- fn func(reflect.Type, []byte) typex.U
-}
-
-func (e *decoderTTypex_U) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_U(fn reflect.Value) Decoder {
- return &decoderTTypex_U{fn: fn.Interface().(func(reflect.Type, []byte) typex.U)}
-}
-
-type decoderTTypex_UE struct {
- fn func(reflect.Type, []byte) (typex.U, error)
-}
-
-func (e *decoderTTypex_UE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_UE(fn reflect.Value) Decoder {
- return &decoderTTypex_UE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.U, error))}
-}
-
-type decoderTypex_V struct {
- fn func([]byte) typex.V
-}
-
-func (e *decoderTypex_V) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_V(fn reflect.Value) Decoder {
- return &decoderTypex_V{fn: fn.Interface().(func([]byte) typex.V)}
-}
-
-type decoderTypex_VE struct {
- fn func([]byte) (typex.V, error)
-}
-
-func (e *decoderTypex_VE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_VE(fn reflect.Value) Decoder {
- return &decoderTypex_VE{fn: fn.Interface().(func([]byte) (typex.V, error))}
-}
-
-type decoderTTypex_V struct {
- fn func(reflect.Type, []byte) typex.V
-}
-
-func (e *decoderTTypex_V) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_V(fn reflect.Value) Decoder {
- return &decoderTTypex_V{fn: fn.Interface().(func(reflect.Type, []byte) typex.V)}
-}
-
-type decoderTTypex_VE struct {
- fn func(reflect.Type, []byte) (typex.V, error)
-}
-
-func (e *decoderTTypex_VE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_VE(fn reflect.Value) Decoder {
- return &decoderTTypex_VE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.V, error))}
-}
-
-type decoderTypex_W struct {
- fn func([]byte) typex.W
-}
-
-func (e *decoderTypex_W) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_W(fn reflect.Value) Decoder {
- return &decoderTypex_W{fn: fn.Interface().(func([]byte) typex.W)}
-}
-
-type decoderTypex_WE struct {
- fn func([]byte) (typex.W, error)
-}
-
-func (e *decoderTypex_WE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_WE(fn reflect.Value) Decoder {
- return &decoderTypex_WE{fn: fn.Interface().(func([]byte) (typex.W, error))}
-}
-
-type decoderTTypex_W struct {
- fn func(reflect.Type, []byte) typex.W
-}
-
-func (e *decoderTTypex_W) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_W(fn reflect.Value) Decoder {
- return &decoderTTypex_W{fn: fn.Interface().(func(reflect.Type, []byte) typex.W)}
-}
-
-type decoderTTypex_WE struct {
- fn func(reflect.Type, []byte) (typex.W, error)
-}
-
-func (e *decoderTTypex_WE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_WE(fn reflect.Value) Decoder {
- return &decoderTTypex_WE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.W, error))}
-}
-
-type decoderTypex_X struct {
- fn func([]byte) typex.X
-}
-
-func (e *decoderTypex_X) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_X(fn reflect.Value) Decoder {
- return &decoderTypex_X{fn: fn.Interface().(func([]byte) typex.X)}
-}
-
-type decoderTypex_XE struct {
- fn func([]byte) (typex.X, error)
-}
-
-func (e *decoderTypex_XE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_XE(fn reflect.Value) Decoder {
- return &decoderTypex_XE{fn: fn.Interface().(func([]byte) (typex.X, error))}
-}
-
-type decoderTTypex_X struct {
- fn func(reflect.Type, []byte) typex.X
-}
-
-func (e *decoderTTypex_X) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_X(fn reflect.Value) Decoder {
- return &decoderTTypex_X{fn: fn.Interface().(func(reflect.Type, []byte) typex.X)}
-}
-
-type decoderTTypex_XE struct {
- fn func(reflect.Type, []byte) (typex.X, error)
-}
-
-func (e *decoderTTypex_XE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_XE(fn reflect.Value) Decoder {
- return &decoderTTypex_XE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.X, error))}
-}
-
-type decoderTypex_Y struct {
- fn func([]byte) typex.Y
-}
-
-func (e *decoderTypex_Y) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_Y(fn reflect.Value) Decoder {
- return &decoderTypex_Y{fn: fn.Interface().(func([]byte) typex.Y)}
-}
-
-type decoderTypex_YE struct {
- fn func([]byte) (typex.Y, error)
-}
-
-func (e *decoderTypex_YE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_YE(fn reflect.Value) Decoder {
- return &decoderTypex_YE{fn: fn.Interface().(func([]byte) (typex.Y, error))}
-}
-
-type decoderTTypex_Y struct {
- fn func(reflect.Type, []byte) typex.Y
-}
-
-func (e *decoderTTypex_Y) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_Y(fn reflect.Value) Decoder {
- return &decoderTTypex_Y{fn: fn.Interface().(func(reflect.Type, []byte) typex.Y)}
-}
-
-type decoderTTypex_YE struct {
- fn func(reflect.Type, []byte) (typex.Y, error)
-}
-
-func (e *decoderTTypex_YE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_YE(fn reflect.Value) Decoder {
- return &decoderTTypex_YE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.Y, error))}
-}
-
-type decoderTypex_Z struct {
- fn func([]byte) typex.Z
-}
-
-func (e *decoderTypex_Z) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMakerTypex_Z(fn reflect.Value) Decoder {
- return &decoderTypex_Z{fn: fn.Interface().(func([]byte) typex.Z)}
-}
-
-type decoderTypex_ZE struct {
- fn func([]byte) (typex.Z, error)
-}
-
-func (e *decoderTypex_ZE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTypex_ZE(fn reflect.Value) Decoder {
- return &decoderTypex_ZE{fn: fn.Interface().(func([]byte) (typex.Z, error))}
-}
-
-type decoderTTypex_Z struct {
- fn func(reflect.Type, []byte) typex.Z
-}
-
-func (e *decoderTTypex_Z) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerTTypex_Z(fn reflect.Value) Decoder {
- return &decoderTTypex_Z{fn: fn.Interface().(func(reflect.Type, []byte) typex.Z)}
-}
-
-type decoderTTypex_ZE struct {
- fn func(reflect.Type, []byte) (typex.Z, error)
-}
-
-func (e *decoderTTypex_ZE) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerTTypex_ZE(fn reflect.Value) Decoder {
- return &decoderTTypex_ZE{fn: fn.Interface().(func(reflect.Type, []byte) (typex.Z, error))}
-}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl b/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl
deleted file mode 100644
index 1df00c7..0000000
--- a/sdks/go/pkg/beam/core/runtime/exec/decoders.tmpl
+++ /dev/null
@@ -1,89 +0,0 @@
-// Licensed to the Apache Software Foundation (ASF) under one or more
-// contributor license agreements. See the NOTICE file distributed with
-// this work for additional information regarding copyright ownership.
-// The ASF licenses this file to You under the Apache License, Version 2.0
-// (the "License"); you may not use this file except in compliance with
-// the License. You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package exec
-
-import (
- "reflect"
-
- "github.com/apache/beam/sdks/go/pkg/beam/core/typex"
-)
-
-func init() {
-{{- range $x := .X}}
- RegisterDecoder(reflect.TypeOf((*func ([]byte) {{$x.Type}})(nil)).Elem(), decoderMaker{{$x.Name}})
- RegisterDecoder(reflect.TypeOf((*func ([]byte) ({{$x.Type}}, error))(nil)).Elem(), decoderMaker{{$x.Name}}E)
- RegisterDecoder(reflect.TypeOf((*func (reflect.Type, []byte) {{$x.Type}})(nil)).Elem(), decoderMakerT{{$x.Name}})
- RegisterDecoder(reflect.TypeOf((*func (reflect.Type, []byte) ({{$x.Type}}, error))(nil)).Elem(), decoderMakerT{{$x.Name}}E)
-{{- end}}
-}
-
-{{range $x := .X}}
-type decoder{{$x.Name}} struct {
- fn func ([]byte) {{$x.Type}}
-}
-
-func (e *decoder{{$x.Name}}) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(data)), nil
-}
-
-func decoderMaker{{$x.Name}}(fn reflect.Value) Decoder {
- return &decoder{{$x.Name}}{fn: fn.Interface().(func ([]byte) {{$x.Type}})}
-}
-
-type decoder{{$x.Name}}E struct {
- fn func ([]byte) ({{$x.Type}}, error)
-}
-
-func (e *decoder{{$x.Name}}E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMaker{{$x.Name}}E(fn reflect.Value) Decoder {
- return &decoder{{$x.Name}}E{fn: fn.Interface().(func ([]byte) ({{$x.Type}}, error))}
-}
-
-type decoderT{{$x.Name}} struct {
- fn func (reflect.Type, []byte) {{$x.Type}}
-}
-
-func (e *decoderT{{$x.Name}}) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- return reflect.ValueOf(e.fn(t, data)), nil
-}
-
-func decoderMakerT{{$x.Name}}(fn reflect.Value) Decoder {
- return &decoderT{{$x.Name}}{fn: fn.Interface().(func (reflect.Type, []byte) {{$x.Type}})}
-}
-
-type decoderT{{$x.Name}}E struct {
- fn func (reflect.Type, []byte) ({{$x.Type}}, error)
-}
-
-func (e *decoderT{{$x.Name}}E) Decode(t reflect.Type, data []byte) (reflect.Value, error) {
- val, err := e.fn(t, data)
- if err != nil {
- return reflect.Value{}, nil
- }
- return reflect.ValueOf(val), nil
-}
-
-func decoderMakerT{{$x.Name}}E(fn reflect.Value) Decoder {
- return &decoderT{{$x.Name}}E{fn: fn.Interface().(func (reflect.Type, []byte) ({{$x.Type}}, error))}
-}
-{{end}}
diff --git a/sdks/go/pkg/beam/core/runtime/exec/emit.go b/sdks/go/pkg/beam/core/runtime/exec/emit.go
index 6336b70..9682064 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/emit.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/emit.go
@@ -26,8 +26,6 @@ import (
"github.com/apache/beam/sdks/go/pkg/beam/log"
)
-//go:generate specialize --input=emitters.tmpl --x=data,universals --y=data,universals
-
// ReusableEmitter is a resettable value needed to hold the implicit context and
// emit event time.
type ReusableEmitter interface {
diff --git a/sdks/go/pkg/beam/core/runtime/exec/emitters.go b/sdks/go/pkg/beam/core/runtime/exec/emitters.go
deleted file mode 100644
index 59e8f58..0000000
--- a/sdks/go/pkg/beam/core/runtime/exec/emitters.go
+++ /dev/null
@@ -1,14214 +0,0 @@
-// File generated by specialize. Do not edit.
-
-// Licensed to the Apache Software Foundation (ASF) under one or more
-// contributor license agreements. See the NOTICE file distributed with
-// this work for additional information regarding copyright ownership.
-// The ASF licenses this file to You under the Apache License, Version 2.0
-// (the "License"); you may not use this file except in compliance with
-// the License. You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-package exec
-
-import (
- "context"
- "reflect"
-
- "github.com/apache/beam/sdks/go/pkg/beam/core/typex"
-)
-
-func init() {
- RegisterEmitter(reflect.TypeOf((*func([]byte))(nil)).Elem(), emitMakerByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte))(nil)).Elem(), emitMakerETByteSlice)
- RegisterEmitter(reflect.TypeOf((*func([]byte, []byte))(nil)).Elem(), emitMakerByteSliceByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, []byte))(nil)).Elem(), emitMakerETByteSliceByteSlice)
- RegisterEmitter(reflect.TypeOf((*func([]byte, bool))(nil)).Elem(), emitMakerByteSliceBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, bool))(nil)).Elem(), emitMakerETByteSliceBool)
- RegisterEmitter(reflect.TypeOf((*func([]byte, string))(nil)).Elem(), emitMakerByteSliceString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, string))(nil)).Elem(), emitMakerETByteSliceString)
- RegisterEmitter(reflect.TypeOf((*func([]byte, int))(nil)).Elem(), emitMakerByteSliceInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, int))(nil)).Elem(), emitMakerETByteSliceInt)
- RegisterEmitter(reflect.TypeOf((*func([]byte, int8))(nil)).Elem(), emitMakerByteSliceInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, int8))(nil)).Elem(), emitMakerETByteSliceInt8)
- RegisterEmitter(reflect.TypeOf((*func([]byte, int16))(nil)).Elem(), emitMakerByteSliceInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, int16))(nil)).Elem(), emitMakerETByteSliceInt16)
- RegisterEmitter(reflect.TypeOf((*func([]byte, int32))(nil)).Elem(), emitMakerByteSliceInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, int32))(nil)).Elem(), emitMakerETByteSliceInt32)
- RegisterEmitter(reflect.TypeOf((*func([]byte, int64))(nil)).Elem(), emitMakerByteSliceInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, int64))(nil)).Elem(), emitMakerETByteSliceInt64)
- RegisterEmitter(reflect.TypeOf((*func([]byte, uint))(nil)).Elem(), emitMakerByteSliceUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, uint))(nil)).Elem(), emitMakerETByteSliceUint)
- RegisterEmitter(reflect.TypeOf((*func([]byte, uint8))(nil)).Elem(), emitMakerByteSliceUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, uint8))(nil)).Elem(), emitMakerETByteSliceUint8)
- RegisterEmitter(reflect.TypeOf((*func([]byte, uint16))(nil)).Elem(), emitMakerByteSliceUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, uint16))(nil)).Elem(), emitMakerETByteSliceUint16)
- RegisterEmitter(reflect.TypeOf((*func([]byte, uint32))(nil)).Elem(), emitMakerByteSliceUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, uint32))(nil)).Elem(), emitMakerETByteSliceUint32)
- RegisterEmitter(reflect.TypeOf((*func([]byte, uint64))(nil)).Elem(), emitMakerByteSliceUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, uint64))(nil)).Elem(), emitMakerETByteSliceUint64)
- RegisterEmitter(reflect.TypeOf((*func([]byte, float32))(nil)).Elem(), emitMakerByteSliceFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, float32))(nil)).Elem(), emitMakerETByteSliceFloat32)
- RegisterEmitter(reflect.TypeOf((*func([]byte, float64))(nil)).Elem(), emitMakerByteSliceFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, float64))(nil)).Elem(), emitMakerETByteSliceFloat64)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.T))(nil)).Elem(), emitMakerByteSliceTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.T))(nil)).Elem(), emitMakerETByteSliceTypex_T)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.U))(nil)).Elem(), emitMakerByteSliceTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.U))(nil)).Elem(), emitMakerETByteSliceTypex_U)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.V))(nil)).Elem(), emitMakerByteSliceTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.V))(nil)).Elem(), emitMakerETByteSliceTypex_V)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.W))(nil)).Elem(), emitMakerByteSliceTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.W))(nil)).Elem(), emitMakerETByteSliceTypex_W)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.X))(nil)).Elem(), emitMakerByteSliceTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.X))(nil)).Elem(), emitMakerETByteSliceTypex_X)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.Y))(nil)).Elem(), emitMakerByteSliceTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.Y))(nil)).Elem(), emitMakerETByteSliceTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func([]byte, typex.Z))(nil)).Elem(), emitMakerByteSliceTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, []byte, typex.Z))(nil)).Elem(), emitMakerETByteSliceTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(bool))(nil)).Elem(), emitMakerBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool))(nil)).Elem(), emitMakerETBool)
- RegisterEmitter(reflect.TypeOf((*func(bool, []byte))(nil)).Elem(), emitMakerBoolByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, []byte))(nil)).Elem(), emitMakerETBoolByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(bool, bool))(nil)).Elem(), emitMakerBoolBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, bool))(nil)).Elem(), emitMakerETBoolBool)
- RegisterEmitter(reflect.TypeOf((*func(bool, string))(nil)).Elem(), emitMakerBoolString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, string))(nil)).Elem(), emitMakerETBoolString)
- RegisterEmitter(reflect.TypeOf((*func(bool, int))(nil)).Elem(), emitMakerBoolInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, int))(nil)).Elem(), emitMakerETBoolInt)
- RegisterEmitter(reflect.TypeOf((*func(bool, int8))(nil)).Elem(), emitMakerBoolInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, int8))(nil)).Elem(), emitMakerETBoolInt8)
- RegisterEmitter(reflect.TypeOf((*func(bool, int16))(nil)).Elem(), emitMakerBoolInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, int16))(nil)).Elem(), emitMakerETBoolInt16)
- RegisterEmitter(reflect.TypeOf((*func(bool, int32))(nil)).Elem(), emitMakerBoolInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, int32))(nil)).Elem(), emitMakerETBoolInt32)
- RegisterEmitter(reflect.TypeOf((*func(bool, int64))(nil)).Elem(), emitMakerBoolInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, int64))(nil)).Elem(), emitMakerETBoolInt64)
- RegisterEmitter(reflect.TypeOf((*func(bool, uint))(nil)).Elem(), emitMakerBoolUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, uint))(nil)).Elem(), emitMakerETBoolUint)
- RegisterEmitter(reflect.TypeOf((*func(bool, uint8))(nil)).Elem(), emitMakerBoolUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, uint8))(nil)).Elem(), emitMakerETBoolUint8)
- RegisterEmitter(reflect.TypeOf((*func(bool, uint16))(nil)).Elem(), emitMakerBoolUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, uint16))(nil)).Elem(), emitMakerETBoolUint16)
- RegisterEmitter(reflect.TypeOf((*func(bool, uint32))(nil)).Elem(), emitMakerBoolUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, uint32))(nil)).Elem(), emitMakerETBoolUint32)
- RegisterEmitter(reflect.TypeOf((*func(bool, uint64))(nil)).Elem(), emitMakerBoolUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, uint64))(nil)).Elem(), emitMakerETBoolUint64)
- RegisterEmitter(reflect.TypeOf((*func(bool, float32))(nil)).Elem(), emitMakerBoolFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, float32))(nil)).Elem(), emitMakerETBoolFloat32)
- RegisterEmitter(reflect.TypeOf((*func(bool, float64))(nil)).Elem(), emitMakerBoolFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, float64))(nil)).Elem(), emitMakerETBoolFloat64)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.T))(nil)).Elem(), emitMakerBoolTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.T))(nil)).Elem(), emitMakerETBoolTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.U))(nil)).Elem(), emitMakerBoolTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.U))(nil)).Elem(), emitMakerETBoolTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.V))(nil)).Elem(), emitMakerBoolTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.V))(nil)).Elem(), emitMakerETBoolTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.W))(nil)).Elem(), emitMakerBoolTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.W))(nil)).Elem(), emitMakerETBoolTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.X))(nil)).Elem(), emitMakerBoolTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.X))(nil)).Elem(), emitMakerETBoolTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.Y))(nil)).Elem(), emitMakerBoolTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.Y))(nil)).Elem(), emitMakerETBoolTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(bool, typex.Z))(nil)).Elem(), emitMakerBoolTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, bool, typex.Z))(nil)).Elem(), emitMakerETBoolTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(string))(nil)).Elem(), emitMakerString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string))(nil)).Elem(), emitMakerETString)
- RegisterEmitter(reflect.TypeOf((*func(string, []byte))(nil)).Elem(), emitMakerStringByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, []byte))(nil)).Elem(), emitMakerETStringByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(string, bool))(nil)).Elem(), emitMakerStringBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, bool))(nil)).Elem(), emitMakerETStringBool)
- RegisterEmitter(reflect.TypeOf((*func(string, string))(nil)).Elem(), emitMakerStringString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, string))(nil)).Elem(), emitMakerETStringString)
- RegisterEmitter(reflect.TypeOf((*func(string, int))(nil)).Elem(), emitMakerStringInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, int))(nil)).Elem(), emitMakerETStringInt)
- RegisterEmitter(reflect.TypeOf((*func(string, int8))(nil)).Elem(), emitMakerStringInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, int8))(nil)).Elem(), emitMakerETStringInt8)
- RegisterEmitter(reflect.TypeOf((*func(string, int16))(nil)).Elem(), emitMakerStringInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, int16))(nil)).Elem(), emitMakerETStringInt16)
- RegisterEmitter(reflect.TypeOf((*func(string, int32))(nil)).Elem(), emitMakerStringInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, int32))(nil)).Elem(), emitMakerETStringInt32)
- RegisterEmitter(reflect.TypeOf((*func(string, int64))(nil)).Elem(), emitMakerStringInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, int64))(nil)).Elem(), emitMakerETStringInt64)
- RegisterEmitter(reflect.TypeOf((*func(string, uint))(nil)).Elem(), emitMakerStringUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, uint))(nil)).Elem(), emitMakerETStringUint)
- RegisterEmitter(reflect.TypeOf((*func(string, uint8))(nil)).Elem(), emitMakerStringUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, uint8))(nil)).Elem(), emitMakerETStringUint8)
- RegisterEmitter(reflect.TypeOf((*func(string, uint16))(nil)).Elem(), emitMakerStringUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, uint16))(nil)).Elem(), emitMakerETStringUint16)
- RegisterEmitter(reflect.TypeOf((*func(string, uint32))(nil)).Elem(), emitMakerStringUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, uint32))(nil)).Elem(), emitMakerETStringUint32)
- RegisterEmitter(reflect.TypeOf((*func(string, uint64))(nil)).Elem(), emitMakerStringUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, uint64))(nil)).Elem(), emitMakerETStringUint64)
- RegisterEmitter(reflect.TypeOf((*func(string, float32))(nil)).Elem(), emitMakerStringFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, float32))(nil)).Elem(), emitMakerETStringFloat32)
- RegisterEmitter(reflect.TypeOf((*func(string, float64))(nil)).Elem(), emitMakerStringFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, float64))(nil)).Elem(), emitMakerETStringFloat64)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.T))(nil)).Elem(), emitMakerStringTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.T))(nil)).Elem(), emitMakerETStringTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.U))(nil)).Elem(), emitMakerStringTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.U))(nil)).Elem(), emitMakerETStringTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.V))(nil)).Elem(), emitMakerStringTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.V))(nil)).Elem(), emitMakerETStringTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.W))(nil)).Elem(), emitMakerStringTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.W))(nil)).Elem(), emitMakerETStringTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.X))(nil)).Elem(), emitMakerStringTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.X))(nil)).Elem(), emitMakerETStringTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.Y))(nil)).Elem(), emitMakerStringTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.Y))(nil)).Elem(), emitMakerETStringTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(string, typex.Z))(nil)).Elem(), emitMakerStringTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, string, typex.Z))(nil)).Elem(), emitMakerETStringTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(int))(nil)).Elem(), emitMakerInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int))(nil)).Elem(), emitMakerETInt)
- RegisterEmitter(reflect.TypeOf((*func(int, []byte))(nil)).Elem(), emitMakerIntByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, []byte))(nil)).Elem(), emitMakerETIntByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(int, bool))(nil)).Elem(), emitMakerIntBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, bool))(nil)).Elem(), emitMakerETIntBool)
- RegisterEmitter(reflect.TypeOf((*func(int, string))(nil)).Elem(), emitMakerIntString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, string))(nil)).Elem(), emitMakerETIntString)
- RegisterEmitter(reflect.TypeOf((*func(int, int))(nil)).Elem(), emitMakerIntInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, int))(nil)).Elem(), emitMakerETIntInt)
- RegisterEmitter(reflect.TypeOf((*func(int, int8))(nil)).Elem(), emitMakerIntInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, int8))(nil)).Elem(), emitMakerETIntInt8)
- RegisterEmitter(reflect.TypeOf((*func(int, int16))(nil)).Elem(), emitMakerIntInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, int16))(nil)).Elem(), emitMakerETIntInt16)
- RegisterEmitter(reflect.TypeOf((*func(int, int32))(nil)).Elem(), emitMakerIntInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, int32))(nil)).Elem(), emitMakerETIntInt32)
- RegisterEmitter(reflect.TypeOf((*func(int, int64))(nil)).Elem(), emitMakerIntInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, int64))(nil)).Elem(), emitMakerETIntInt64)
- RegisterEmitter(reflect.TypeOf((*func(int, uint))(nil)).Elem(), emitMakerIntUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, uint))(nil)).Elem(), emitMakerETIntUint)
- RegisterEmitter(reflect.TypeOf((*func(int, uint8))(nil)).Elem(), emitMakerIntUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, uint8))(nil)).Elem(), emitMakerETIntUint8)
- RegisterEmitter(reflect.TypeOf((*func(int, uint16))(nil)).Elem(), emitMakerIntUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, uint16))(nil)).Elem(), emitMakerETIntUint16)
- RegisterEmitter(reflect.TypeOf((*func(int, uint32))(nil)).Elem(), emitMakerIntUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, uint32))(nil)).Elem(), emitMakerETIntUint32)
- RegisterEmitter(reflect.TypeOf((*func(int, uint64))(nil)).Elem(), emitMakerIntUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, uint64))(nil)).Elem(), emitMakerETIntUint64)
- RegisterEmitter(reflect.TypeOf((*func(int, float32))(nil)).Elem(), emitMakerIntFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, float32))(nil)).Elem(), emitMakerETIntFloat32)
- RegisterEmitter(reflect.TypeOf((*func(int, float64))(nil)).Elem(), emitMakerIntFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, float64))(nil)).Elem(), emitMakerETIntFloat64)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.T))(nil)).Elem(), emitMakerIntTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.T))(nil)).Elem(), emitMakerETIntTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.U))(nil)).Elem(), emitMakerIntTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.U))(nil)).Elem(), emitMakerETIntTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.V))(nil)).Elem(), emitMakerIntTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.V))(nil)).Elem(), emitMakerETIntTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.W))(nil)).Elem(), emitMakerIntTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.W))(nil)).Elem(), emitMakerETIntTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.X))(nil)).Elem(), emitMakerIntTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.X))(nil)).Elem(), emitMakerETIntTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.Y))(nil)).Elem(), emitMakerIntTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.Y))(nil)).Elem(), emitMakerETIntTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(int, typex.Z))(nil)).Elem(), emitMakerIntTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int, typex.Z))(nil)).Elem(), emitMakerETIntTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(int8))(nil)).Elem(), emitMakerInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8))(nil)).Elem(), emitMakerETInt8)
- RegisterEmitter(reflect.TypeOf((*func(int8, []byte))(nil)).Elem(), emitMakerInt8ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, []byte))(nil)).Elem(), emitMakerETInt8ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(int8, bool))(nil)).Elem(), emitMakerInt8Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, bool))(nil)).Elem(), emitMakerETInt8Bool)
- RegisterEmitter(reflect.TypeOf((*func(int8, string))(nil)).Elem(), emitMakerInt8String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, string))(nil)).Elem(), emitMakerETInt8String)
- RegisterEmitter(reflect.TypeOf((*func(int8, int))(nil)).Elem(), emitMakerInt8Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, int))(nil)).Elem(), emitMakerETInt8Int)
- RegisterEmitter(reflect.TypeOf((*func(int8, int8))(nil)).Elem(), emitMakerInt8Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, int8))(nil)).Elem(), emitMakerETInt8Int8)
- RegisterEmitter(reflect.TypeOf((*func(int8, int16))(nil)).Elem(), emitMakerInt8Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, int16))(nil)).Elem(), emitMakerETInt8Int16)
- RegisterEmitter(reflect.TypeOf((*func(int8, int32))(nil)).Elem(), emitMakerInt8Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, int32))(nil)).Elem(), emitMakerETInt8Int32)
- RegisterEmitter(reflect.TypeOf((*func(int8, int64))(nil)).Elem(), emitMakerInt8Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, int64))(nil)).Elem(), emitMakerETInt8Int64)
- RegisterEmitter(reflect.TypeOf((*func(int8, uint))(nil)).Elem(), emitMakerInt8Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, uint))(nil)).Elem(), emitMakerETInt8Uint)
- RegisterEmitter(reflect.TypeOf((*func(int8, uint8))(nil)).Elem(), emitMakerInt8Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, uint8))(nil)).Elem(), emitMakerETInt8Uint8)
- RegisterEmitter(reflect.TypeOf((*func(int8, uint16))(nil)).Elem(), emitMakerInt8Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, uint16))(nil)).Elem(), emitMakerETInt8Uint16)
- RegisterEmitter(reflect.TypeOf((*func(int8, uint32))(nil)).Elem(), emitMakerInt8Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, uint32))(nil)).Elem(), emitMakerETInt8Uint32)
- RegisterEmitter(reflect.TypeOf((*func(int8, uint64))(nil)).Elem(), emitMakerInt8Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, uint64))(nil)).Elem(), emitMakerETInt8Uint64)
- RegisterEmitter(reflect.TypeOf((*func(int8, float32))(nil)).Elem(), emitMakerInt8Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, float32))(nil)).Elem(), emitMakerETInt8Float32)
- RegisterEmitter(reflect.TypeOf((*func(int8, float64))(nil)).Elem(), emitMakerInt8Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, float64))(nil)).Elem(), emitMakerETInt8Float64)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.T))(nil)).Elem(), emitMakerInt8Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.T))(nil)).Elem(), emitMakerETInt8Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.U))(nil)).Elem(), emitMakerInt8Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.U))(nil)).Elem(), emitMakerETInt8Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.V))(nil)).Elem(), emitMakerInt8Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.V))(nil)).Elem(), emitMakerETInt8Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.W))(nil)).Elem(), emitMakerInt8Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.W))(nil)).Elem(), emitMakerETInt8Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.X))(nil)).Elem(), emitMakerInt8Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.X))(nil)).Elem(), emitMakerETInt8Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.Y))(nil)).Elem(), emitMakerInt8Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.Y))(nil)).Elem(), emitMakerETInt8Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(int8, typex.Z))(nil)).Elem(), emitMakerInt8Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int8, typex.Z))(nil)).Elem(), emitMakerETInt8Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(int16))(nil)).Elem(), emitMakerInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16))(nil)).Elem(), emitMakerETInt16)
- RegisterEmitter(reflect.TypeOf((*func(int16, []byte))(nil)).Elem(), emitMakerInt16ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, []byte))(nil)).Elem(), emitMakerETInt16ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(int16, bool))(nil)).Elem(), emitMakerInt16Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, bool))(nil)).Elem(), emitMakerETInt16Bool)
- RegisterEmitter(reflect.TypeOf((*func(int16, string))(nil)).Elem(), emitMakerInt16String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, string))(nil)).Elem(), emitMakerETInt16String)
- RegisterEmitter(reflect.TypeOf((*func(int16, int))(nil)).Elem(), emitMakerInt16Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, int))(nil)).Elem(), emitMakerETInt16Int)
- RegisterEmitter(reflect.TypeOf((*func(int16, int8))(nil)).Elem(), emitMakerInt16Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, int8))(nil)).Elem(), emitMakerETInt16Int8)
- RegisterEmitter(reflect.TypeOf((*func(int16, int16))(nil)).Elem(), emitMakerInt16Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, int16))(nil)).Elem(), emitMakerETInt16Int16)
- RegisterEmitter(reflect.TypeOf((*func(int16, int32))(nil)).Elem(), emitMakerInt16Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, int32))(nil)).Elem(), emitMakerETInt16Int32)
- RegisterEmitter(reflect.TypeOf((*func(int16, int64))(nil)).Elem(), emitMakerInt16Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, int64))(nil)).Elem(), emitMakerETInt16Int64)
- RegisterEmitter(reflect.TypeOf((*func(int16, uint))(nil)).Elem(), emitMakerInt16Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, uint))(nil)).Elem(), emitMakerETInt16Uint)
- RegisterEmitter(reflect.TypeOf((*func(int16, uint8))(nil)).Elem(), emitMakerInt16Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, uint8))(nil)).Elem(), emitMakerETInt16Uint8)
- RegisterEmitter(reflect.TypeOf((*func(int16, uint16))(nil)).Elem(), emitMakerInt16Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, uint16))(nil)).Elem(), emitMakerETInt16Uint16)
- RegisterEmitter(reflect.TypeOf((*func(int16, uint32))(nil)).Elem(), emitMakerInt16Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, uint32))(nil)).Elem(), emitMakerETInt16Uint32)
- RegisterEmitter(reflect.TypeOf((*func(int16, uint64))(nil)).Elem(), emitMakerInt16Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, uint64))(nil)).Elem(), emitMakerETInt16Uint64)
- RegisterEmitter(reflect.TypeOf((*func(int16, float32))(nil)).Elem(), emitMakerInt16Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, float32))(nil)).Elem(), emitMakerETInt16Float32)
- RegisterEmitter(reflect.TypeOf((*func(int16, float64))(nil)).Elem(), emitMakerInt16Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, float64))(nil)).Elem(), emitMakerETInt16Float64)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.T))(nil)).Elem(), emitMakerInt16Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.T))(nil)).Elem(), emitMakerETInt16Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.U))(nil)).Elem(), emitMakerInt16Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.U))(nil)).Elem(), emitMakerETInt16Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.V))(nil)).Elem(), emitMakerInt16Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.V))(nil)).Elem(), emitMakerETInt16Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.W))(nil)).Elem(), emitMakerInt16Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.W))(nil)).Elem(), emitMakerETInt16Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.X))(nil)).Elem(), emitMakerInt16Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.X))(nil)).Elem(), emitMakerETInt16Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.Y))(nil)).Elem(), emitMakerInt16Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.Y))(nil)).Elem(), emitMakerETInt16Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(int16, typex.Z))(nil)).Elem(), emitMakerInt16Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int16, typex.Z))(nil)).Elem(), emitMakerETInt16Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(int32))(nil)).Elem(), emitMakerInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32))(nil)).Elem(), emitMakerETInt32)
- RegisterEmitter(reflect.TypeOf((*func(int32, []byte))(nil)).Elem(), emitMakerInt32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, []byte))(nil)).Elem(), emitMakerETInt32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(int32, bool))(nil)).Elem(), emitMakerInt32Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, bool))(nil)).Elem(), emitMakerETInt32Bool)
- RegisterEmitter(reflect.TypeOf((*func(int32, string))(nil)).Elem(), emitMakerInt32String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, string))(nil)).Elem(), emitMakerETInt32String)
- RegisterEmitter(reflect.TypeOf((*func(int32, int))(nil)).Elem(), emitMakerInt32Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, int))(nil)).Elem(), emitMakerETInt32Int)
- RegisterEmitter(reflect.TypeOf((*func(int32, int8))(nil)).Elem(), emitMakerInt32Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, int8))(nil)).Elem(), emitMakerETInt32Int8)
- RegisterEmitter(reflect.TypeOf((*func(int32, int16))(nil)).Elem(), emitMakerInt32Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, int16))(nil)).Elem(), emitMakerETInt32Int16)
- RegisterEmitter(reflect.TypeOf((*func(int32, int32))(nil)).Elem(), emitMakerInt32Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, int32))(nil)).Elem(), emitMakerETInt32Int32)
- RegisterEmitter(reflect.TypeOf((*func(int32, int64))(nil)).Elem(), emitMakerInt32Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, int64))(nil)).Elem(), emitMakerETInt32Int64)
- RegisterEmitter(reflect.TypeOf((*func(int32, uint))(nil)).Elem(), emitMakerInt32Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, uint))(nil)).Elem(), emitMakerETInt32Uint)
- RegisterEmitter(reflect.TypeOf((*func(int32, uint8))(nil)).Elem(), emitMakerInt32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, uint8))(nil)).Elem(), emitMakerETInt32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(int32, uint16))(nil)).Elem(), emitMakerInt32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, uint16))(nil)).Elem(), emitMakerETInt32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(int32, uint32))(nil)).Elem(), emitMakerInt32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, uint32))(nil)).Elem(), emitMakerETInt32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(int32, uint64))(nil)).Elem(), emitMakerInt32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, uint64))(nil)).Elem(), emitMakerETInt32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(int32, float32))(nil)).Elem(), emitMakerInt32Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, float32))(nil)).Elem(), emitMakerETInt32Float32)
- RegisterEmitter(reflect.TypeOf((*func(int32, float64))(nil)).Elem(), emitMakerInt32Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, float64))(nil)).Elem(), emitMakerETInt32Float64)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.T))(nil)).Elem(), emitMakerInt32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.T))(nil)).Elem(), emitMakerETInt32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.U))(nil)).Elem(), emitMakerInt32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.U))(nil)).Elem(), emitMakerETInt32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.V))(nil)).Elem(), emitMakerInt32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.V))(nil)).Elem(), emitMakerETInt32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.W))(nil)).Elem(), emitMakerInt32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.W))(nil)).Elem(), emitMakerETInt32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.X))(nil)).Elem(), emitMakerInt32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.X))(nil)).Elem(), emitMakerETInt32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.Y))(nil)).Elem(), emitMakerInt32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.Y))(nil)).Elem(), emitMakerETInt32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(int32, typex.Z))(nil)).Elem(), emitMakerInt32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int32, typex.Z))(nil)).Elem(), emitMakerETInt32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(int64))(nil)).Elem(), emitMakerInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64))(nil)).Elem(), emitMakerETInt64)
- RegisterEmitter(reflect.TypeOf((*func(int64, []byte))(nil)).Elem(), emitMakerInt64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, []byte))(nil)).Elem(), emitMakerETInt64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(int64, bool))(nil)).Elem(), emitMakerInt64Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, bool))(nil)).Elem(), emitMakerETInt64Bool)
- RegisterEmitter(reflect.TypeOf((*func(int64, string))(nil)).Elem(), emitMakerInt64String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, string))(nil)).Elem(), emitMakerETInt64String)
- RegisterEmitter(reflect.TypeOf((*func(int64, int))(nil)).Elem(), emitMakerInt64Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, int))(nil)).Elem(), emitMakerETInt64Int)
- RegisterEmitter(reflect.TypeOf((*func(int64, int8))(nil)).Elem(), emitMakerInt64Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, int8))(nil)).Elem(), emitMakerETInt64Int8)
- RegisterEmitter(reflect.TypeOf((*func(int64, int16))(nil)).Elem(), emitMakerInt64Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, int16))(nil)).Elem(), emitMakerETInt64Int16)
- RegisterEmitter(reflect.TypeOf((*func(int64, int32))(nil)).Elem(), emitMakerInt64Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, int32))(nil)).Elem(), emitMakerETInt64Int32)
- RegisterEmitter(reflect.TypeOf((*func(int64, int64))(nil)).Elem(), emitMakerInt64Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, int64))(nil)).Elem(), emitMakerETInt64Int64)
- RegisterEmitter(reflect.TypeOf((*func(int64, uint))(nil)).Elem(), emitMakerInt64Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, uint))(nil)).Elem(), emitMakerETInt64Uint)
- RegisterEmitter(reflect.TypeOf((*func(int64, uint8))(nil)).Elem(), emitMakerInt64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, uint8))(nil)).Elem(), emitMakerETInt64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(int64, uint16))(nil)).Elem(), emitMakerInt64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, uint16))(nil)).Elem(), emitMakerETInt64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(int64, uint32))(nil)).Elem(), emitMakerInt64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, uint32))(nil)).Elem(), emitMakerETInt64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(int64, uint64))(nil)).Elem(), emitMakerInt64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, uint64))(nil)).Elem(), emitMakerETInt64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(int64, float32))(nil)).Elem(), emitMakerInt64Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, float32))(nil)).Elem(), emitMakerETInt64Float32)
- RegisterEmitter(reflect.TypeOf((*func(int64, float64))(nil)).Elem(), emitMakerInt64Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, float64))(nil)).Elem(), emitMakerETInt64Float64)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.T))(nil)).Elem(), emitMakerInt64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.T))(nil)).Elem(), emitMakerETInt64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.U))(nil)).Elem(), emitMakerInt64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.U))(nil)).Elem(), emitMakerETInt64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.V))(nil)).Elem(), emitMakerInt64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.V))(nil)).Elem(), emitMakerETInt64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.W))(nil)).Elem(), emitMakerInt64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.W))(nil)).Elem(), emitMakerETInt64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.X))(nil)).Elem(), emitMakerInt64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.X))(nil)).Elem(), emitMakerETInt64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.Y))(nil)).Elem(), emitMakerInt64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.Y))(nil)).Elem(), emitMakerETInt64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(int64, typex.Z))(nil)).Elem(), emitMakerInt64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, int64, typex.Z))(nil)).Elem(), emitMakerETInt64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(uint))(nil)).Elem(), emitMakerUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint))(nil)).Elem(), emitMakerETUint)
- RegisterEmitter(reflect.TypeOf((*func(uint, []byte))(nil)).Elem(), emitMakerUintByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, []byte))(nil)).Elem(), emitMakerETUintByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(uint, bool))(nil)).Elem(), emitMakerUintBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, bool))(nil)).Elem(), emitMakerETUintBool)
- RegisterEmitter(reflect.TypeOf((*func(uint, string))(nil)).Elem(), emitMakerUintString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, string))(nil)).Elem(), emitMakerETUintString)
- RegisterEmitter(reflect.TypeOf((*func(uint, int))(nil)).Elem(), emitMakerUintInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, int))(nil)).Elem(), emitMakerETUintInt)
- RegisterEmitter(reflect.TypeOf((*func(uint, int8))(nil)).Elem(), emitMakerUintInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, int8))(nil)).Elem(), emitMakerETUintInt8)
- RegisterEmitter(reflect.TypeOf((*func(uint, int16))(nil)).Elem(), emitMakerUintInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, int16))(nil)).Elem(), emitMakerETUintInt16)
- RegisterEmitter(reflect.TypeOf((*func(uint, int32))(nil)).Elem(), emitMakerUintInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, int32))(nil)).Elem(), emitMakerETUintInt32)
- RegisterEmitter(reflect.TypeOf((*func(uint, int64))(nil)).Elem(), emitMakerUintInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, int64))(nil)).Elem(), emitMakerETUintInt64)
- RegisterEmitter(reflect.TypeOf((*func(uint, uint))(nil)).Elem(), emitMakerUintUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, uint))(nil)).Elem(), emitMakerETUintUint)
- RegisterEmitter(reflect.TypeOf((*func(uint, uint8))(nil)).Elem(), emitMakerUintUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, uint8))(nil)).Elem(), emitMakerETUintUint8)
- RegisterEmitter(reflect.TypeOf((*func(uint, uint16))(nil)).Elem(), emitMakerUintUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, uint16))(nil)).Elem(), emitMakerETUintUint16)
- RegisterEmitter(reflect.TypeOf((*func(uint, uint32))(nil)).Elem(), emitMakerUintUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, uint32))(nil)).Elem(), emitMakerETUintUint32)
- RegisterEmitter(reflect.TypeOf((*func(uint, uint64))(nil)).Elem(), emitMakerUintUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, uint64))(nil)).Elem(), emitMakerETUintUint64)
- RegisterEmitter(reflect.TypeOf((*func(uint, float32))(nil)).Elem(), emitMakerUintFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, float32))(nil)).Elem(), emitMakerETUintFloat32)
- RegisterEmitter(reflect.TypeOf((*func(uint, float64))(nil)).Elem(), emitMakerUintFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, float64))(nil)).Elem(), emitMakerETUintFloat64)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.T))(nil)).Elem(), emitMakerUintTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.T))(nil)).Elem(), emitMakerETUintTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.U))(nil)).Elem(), emitMakerUintTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.U))(nil)).Elem(), emitMakerETUintTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.V))(nil)).Elem(), emitMakerUintTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.V))(nil)).Elem(), emitMakerETUintTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.W))(nil)).Elem(), emitMakerUintTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.W))(nil)).Elem(), emitMakerETUintTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.X))(nil)).Elem(), emitMakerUintTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.X))(nil)).Elem(), emitMakerETUintTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.Y))(nil)).Elem(), emitMakerUintTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.Y))(nil)).Elem(), emitMakerETUintTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(uint, typex.Z))(nil)).Elem(), emitMakerUintTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint, typex.Z))(nil)).Elem(), emitMakerETUintTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(uint8))(nil)).Elem(), emitMakerUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8))(nil)).Elem(), emitMakerETUint8)
- RegisterEmitter(reflect.TypeOf((*func(uint8, []byte))(nil)).Elem(), emitMakerUint8ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, []byte))(nil)).Elem(), emitMakerETUint8ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(uint8, bool))(nil)).Elem(), emitMakerUint8Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, bool))(nil)).Elem(), emitMakerETUint8Bool)
- RegisterEmitter(reflect.TypeOf((*func(uint8, string))(nil)).Elem(), emitMakerUint8String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, string))(nil)).Elem(), emitMakerETUint8String)
- RegisterEmitter(reflect.TypeOf((*func(uint8, int))(nil)).Elem(), emitMakerUint8Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, int))(nil)).Elem(), emitMakerETUint8Int)
- RegisterEmitter(reflect.TypeOf((*func(uint8, int8))(nil)).Elem(), emitMakerUint8Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, int8))(nil)).Elem(), emitMakerETUint8Int8)
- RegisterEmitter(reflect.TypeOf((*func(uint8, int16))(nil)).Elem(), emitMakerUint8Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, int16))(nil)).Elem(), emitMakerETUint8Int16)
- RegisterEmitter(reflect.TypeOf((*func(uint8, int32))(nil)).Elem(), emitMakerUint8Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, int32))(nil)).Elem(), emitMakerETUint8Int32)
- RegisterEmitter(reflect.TypeOf((*func(uint8, int64))(nil)).Elem(), emitMakerUint8Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, int64))(nil)).Elem(), emitMakerETUint8Int64)
- RegisterEmitter(reflect.TypeOf((*func(uint8, uint))(nil)).Elem(), emitMakerUint8Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, uint))(nil)).Elem(), emitMakerETUint8Uint)
- RegisterEmitter(reflect.TypeOf((*func(uint8, uint8))(nil)).Elem(), emitMakerUint8Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, uint8))(nil)).Elem(), emitMakerETUint8Uint8)
- RegisterEmitter(reflect.TypeOf((*func(uint8, uint16))(nil)).Elem(), emitMakerUint8Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, uint16))(nil)).Elem(), emitMakerETUint8Uint16)
- RegisterEmitter(reflect.TypeOf((*func(uint8, uint32))(nil)).Elem(), emitMakerUint8Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, uint32))(nil)).Elem(), emitMakerETUint8Uint32)
- RegisterEmitter(reflect.TypeOf((*func(uint8, uint64))(nil)).Elem(), emitMakerUint8Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, uint64))(nil)).Elem(), emitMakerETUint8Uint64)
- RegisterEmitter(reflect.TypeOf((*func(uint8, float32))(nil)).Elem(), emitMakerUint8Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, float32))(nil)).Elem(), emitMakerETUint8Float32)
- RegisterEmitter(reflect.TypeOf((*func(uint8, float64))(nil)).Elem(), emitMakerUint8Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, float64))(nil)).Elem(), emitMakerETUint8Float64)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.T))(nil)).Elem(), emitMakerUint8Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.T))(nil)).Elem(), emitMakerETUint8Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.U))(nil)).Elem(), emitMakerUint8Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.U))(nil)).Elem(), emitMakerETUint8Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.V))(nil)).Elem(), emitMakerUint8Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.V))(nil)).Elem(), emitMakerETUint8Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.W))(nil)).Elem(), emitMakerUint8Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.W))(nil)).Elem(), emitMakerETUint8Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.X))(nil)).Elem(), emitMakerUint8Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.X))(nil)).Elem(), emitMakerETUint8Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.Y))(nil)).Elem(), emitMakerUint8Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.Y))(nil)).Elem(), emitMakerETUint8Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(uint8, typex.Z))(nil)).Elem(), emitMakerUint8Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint8, typex.Z))(nil)).Elem(), emitMakerETUint8Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(uint16))(nil)).Elem(), emitMakerUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16))(nil)).Elem(), emitMakerETUint16)
- RegisterEmitter(reflect.TypeOf((*func(uint16, []byte))(nil)).Elem(), emitMakerUint16ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, []byte))(nil)).Elem(), emitMakerETUint16ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(uint16, bool))(nil)).Elem(), emitMakerUint16Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, bool))(nil)).Elem(), emitMakerETUint16Bool)
- RegisterEmitter(reflect.TypeOf((*func(uint16, string))(nil)).Elem(), emitMakerUint16String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, string))(nil)).Elem(), emitMakerETUint16String)
- RegisterEmitter(reflect.TypeOf((*func(uint16, int))(nil)).Elem(), emitMakerUint16Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, int))(nil)).Elem(), emitMakerETUint16Int)
- RegisterEmitter(reflect.TypeOf((*func(uint16, int8))(nil)).Elem(), emitMakerUint16Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, int8))(nil)).Elem(), emitMakerETUint16Int8)
- RegisterEmitter(reflect.TypeOf((*func(uint16, int16))(nil)).Elem(), emitMakerUint16Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, int16))(nil)).Elem(), emitMakerETUint16Int16)
- RegisterEmitter(reflect.TypeOf((*func(uint16, int32))(nil)).Elem(), emitMakerUint16Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, int32))(nil)).Elem(), emitMakerETUint16Int32)
- RegisterEmitter(reflect.TypeOf((*func(uint16, int64))(nil)).Elem(), emitMakerUint16Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, int64))(nil)).Elem(), emitMakerETUint16Int64)
- RegisterEmitter(reflect.TypeOf((*func(uint16, uint))(nil)).Elem(), emitMakerUint16Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, uint))(nil)).Elem(), emitMakerETUint16Uint)
- RegisterEmitter(reflect.TypeOf((*func(uint16, uint8))(nil)).Elem(), emitMakerUint16Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, uint8))(nil)).Elem(), emitMakerETUint16Uint8)
- RegisterEmitter(reflect.TypeOf((*func(uint16, uint16))(nil)).Elem(), emitMakerUint16Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, uint16))(nil)).Elem(), emitMakerETUint16Uint16)
- RegisterEmitter(reflect.TypeOf((*func(uint16, uint32))(nil)).Elem(), emitMakerUint16Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, uint32))(nil)).Elem(), emitMakerETUint16Uint32)
- RegisterEmitter(reflect.TypeOf((*func(uint16, uint64))(nil)).Elem(), emitMakerUint16Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, uint64))(nil)).Elem(), emitMakerETUint16Uint64)
- RegisterEmitter(reflect.TypeOf((*func(uint16, float32))(nil)).Elem(), emitMakerUint16Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, float32))(nil)).Elem(), emitMakerETUint16Float32)
- RegisterEmitter(reflect.TypeOf((*func(uint16, float64))(nil)).Elem(), emitMakerUint16Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, float64))(nil)).Elem(), emitMakerETUint16Float64)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.T))(nil)).Elem(), emitMakerUint16Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.T))(nil)).Elem(), emitMakerETUint16Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.U))(nil)).Elem(), emitMakerUint16Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.U))(nil)).Elem(), emitMakerETUint16Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.V))(nil)).Elem(), emitMakerUint16Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.V))(nil)).Elem(), emitMakerETUint16Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.W))(nil)).Elem(), emitMakerUint16Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.W))(nil)).Elem(), emitMakerETUint16Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.X))(nil)).Elem(), emitMakerUint16Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.X))(nil)).Elem(), emitMakerETUint16Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.Y))(nil)).Elem(), emitMakerUint16Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.Y))(nil)).Elem(), emitMakerETUint16Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(uint16, typex.Z))(nil)).Elem(), emitMakerUint16Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint16, typex.Z))(nil)).Elem(), emitMakerETUint16Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(uint32))(nil)).Elem(), emitMakerUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32))(nil)).Elem(), emitMakerETUint32)
- RegisterEmitter(reflect.TypeOf((*func(uint32, []byte))(nil)).Elem(), emitMakerUint32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, []byte))(nil)).Elem(), emitMakerETUint32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(uint32, bool))(nil)).Elem(), emitMakerUint32Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, bool))(nil)).Elem(), emitMakerETUint32Bool)
- RegisterEmitter(reflect.TypeOf((*func(uint32, string))(nil)).Elem(), emitMakerUint32String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, string))(nil)).Elem(), emitMakerETUint32String)
- RegisterEmitter(reflect.TypeOf((*func(uint32, int))(nil)).Elem(), emitMakerUint32Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, int))(nil)).Elem(), emitMakerETUint32Int)
- RegisterEmitter(reflect.TypeOf((*func(uint32, int8))(nil)).Elem(), emitMakerUint32Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, int8))(nil)).Elem(), emitMakerETUint32Int8)
- RegisterEmitter(reflect.TypeOf((*func(uint32, int16))(nil)).Elem(), emitMakerUint32Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, int16))(nil)).Elem(), emitMakerETUint32Int16)
- RegisterEmitter(reflect.TypeOf((*func(uint32, int32))(nil)).Elem(), emitMakerUint32Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, int32))(nil)).Elem(), emitMakerETUint32Int32)
- RegisterEmitter(reflect.TypeOf((*func(uint32, int64))(nil)).Elem(), emitMakerUint32Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, int64))(nil)).Elem(), emitMakerETUint32Int64)
- RegisterEmitter(reflect.TypeOf((*func(uint32, uint))(nil)).Elem(), emitMakerUint32Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, uint))(nil)).Elem(), emitMakerETUint32Uint)
- RegisterEmitter(reflect.TypeOf((*func(uint32, uint8))(nil)).Elem(), emitMakerUint32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, uint8))(nil)).Elem(), emitMakerETUint32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(uint32, uint16))(nil)).Elem(), emitMakerUint32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, uint16))(nil)).Elem(), emitMakerETUint32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(uint32, uint32))(nil)).Elem(), emitMakerUint32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, uint32))(nil)).Elem(), emitMakerETUint32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(uint32, uint64))(nil)).Elem(), emitMakerUint32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, uint64))(nil)).Elem(), emitMakerETUint32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(uint32, float32))(nil)).Elem(), emitMakerUint32Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, float32))(nil)).Elem(), emitMakerETUint32Float32)
- RegisterEmitter(reflect.TypeOf((*func(uint32, float64))(nil)).Elem(), emitMakerUint32Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, float64))(nil)).Elem(), emitMakerETUint32Float64)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.T))(nil)).Elem(), emitMakerUint32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.T))(nil)).Elem(), emitMakerETUint32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.U))(nil)).Elem(), emitMakerUint32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.U))(nil)).Elem(), emitMakerETUint32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.V))(nil)).Elem(), emitMakerUint32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.V))(nil)).Elem(), emitMakerETUint32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.W))(nil)).Elem(), emitMakerUint32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.W))(nil)).Elem(), emitMakerETUint32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.X))(nil)).Elem(), emitMakerUint32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.X))(nil)).Elem(), emitMakerETUint32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.Y))(nil)).Elem(), emitMakerUint32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.Y))(nil)).Elem(), emitMakerETUint32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(uint32, typex.Z))(nil)).Elem(), emitMakerUint32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint32, typex.Z))(nil)).Elem(), emitMakerETUint32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(uint64))(nil)).Elem(), emitMakerUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64))(nil)).Elem(), emitMakerETUint64)
- RegisterEmitter(reflect.TypeOf((*func(uint64, []byte))(nil)).Elem(), emitMakerUint64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, []byte))(nil)).Elem(), emitMakerETUint64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(uint64, bool))(nil)).Elem(), emitMakerUint64Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, bool))(nil)).Elem(), emitMakerETUint64Bool)
- RegisterEmitter(reflect.TypeOf((*func(uint64, string))(nil)).Elem(), emitMakerUint64String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, string))(nil)).Elem(), emitMakerETUint64String)
- RegisterEmitter(reflect.TypeOf((*func(uint64, int))(nil)).Elem(), emitMakerUint64Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, int))(nil)).Elem(), emitMakerETUint64Int)
- RegisterEmitter(reflect.TypeOf((*func(uint64, int8))(nil)).Elem(), emitMakerUint64Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, int8))(nil)).Elem(), emitMakerETUint64Int8)
- RegisterEmitter(reflect.TypeOf((*func(uint64, int16))(nil)).Elem(), emitMakerUint64Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, int16))(nil)).Elem(), emitMakerETUint64Int16)
- RegisterEmitter(reflect.TypeOf((*func(uint64, int32))(nil)).Elem(), emitMakerUint64Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, int32))(nil)).Elem(), emitMakerETUint64Int32)
- RegisterEmitter(reflect.TypeOf((*func(uint64, int64))(nil)).Elem(), emitMakerUint64Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, int64))(nil)).Elem(), emitMakerETUint64Int64)
- RegisterEmitter(reflect.TypeOf((*func(uint64, uint))(nil)).Elem(), emitMakerUint64Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, uint))(nil)).Elem(), emitMakerETUint64Uint)
- RegisterEmitter(reflect.TypeOf((*func(uint64, uint8))(nil)).Elem(), emitMakerUint64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, uint8))(nil)).Elem(), emitMakerETUint64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(uint64, uint16))(nil)).Elem(), emitMakerUint64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, uint16))(nil)).Elem(), emitMakerETUint64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(uint64, uint32))(nil)).Elem(), emitMakerUint64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, uint32))(nil)).Elem(), emitMakerETUint64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(uint64, uint64))(nil)).Elem(), emitMakerUint64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, uint64))(nil)).Elem(), emitMakerETUint64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(uint64, float32))(nil)).Elem(), emitMakerUint64Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, float32))(nil)).Elem(), emitMakerETUint64Float32)
- RegisterEmitter(reflect.TypeOf((*func(uint64, float64))(nil)).Elem(), emitMakerUint64Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, float64))(nil)).Elem(), emitMakerETUint64Float64)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.T))(nil)).Elem(), emitMakerUint64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.T))(nil)).Elem(), emitMakerETUint64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.U))(nil)).Elem(), emitMakerUint64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.U))(nil)).Elem(), emitMakerETUint64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.V))(nil)).Elem(), emitMakerUint64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.V))(nil)).Elem(), emitMakerETUint64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.W))(nil)).Elem(), emitMakerUint64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.W))(nil)).Elem(), emitMakerETUint64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.X))(nil)).Elem(), emitMakerUint64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.X))(nil)).Elem(), emitMakerETUint64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.Y))(nil)).Elem(), emitMakerUint64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.Y))(nil)).Elem(), emitMakerETUint64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(uint64, typex.Z))(nil)).Elem(), emitMakerUint64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, uint64, typex.Z))(nil)).Elem(), emitMakerETUint64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(float32))(nil)).Elem(), emitMakerFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32))(nil)).Elem(), emitMakerETFloat32)
- RegisterEmitter(reflect.TypeOf((*func(float32, []byte))(nil)).Elem(), emitMakerFloat32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, []byte))(nil)).Elem(), emitMakerETFloat32ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(float32, bool))(nil)).Elem(), emitMakerFloat32Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, bool))(nil)).Elem(), emitMakerETFloat32Bool)
- RegisterEmitter(reflect.TypeOf((*func(float32, string))(nil)).Elem(), emitMakerFloat32String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, string))(nil)).Elem(), emitMakerETFloat32String)
- RegisterEmitter(reflect.TypeOf((*func(float32, int))(nil)).Elem(), emitMakerFloat32Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, int))(nil)).Elem(), emitMakerETFloat32Int)
- RegisterEmitter(reflect.TypeOf((*func(float32, int8))(nil)).Elem(), emitMakerFloat32Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, int8))(nil)).Elem(), emitMakerETFloat32Int8)
- RegisterEmitter(reflect.TypeOf((*func(float32, int16))(nil)).Elem(), emitMakerFloat32Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, int16))(nil)).Elem(), emitMakerETFloat32Int16)
- RegisterEmitter(reflect.TypeOf((*func(float32, int32))(nil)).Elem(), emitMakerFloat32Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, int32))(nil)).Elem(), emitMakerETFloat32Int32)
- RegisterEmitter(reflect.TypeOf((*func(float32, int64))(nil)).Elem(), emitMakerFloat32Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, int64))(nil)).Elem(), emitMakerETFloat32Int64)
- RegisterEmitter(reflect.TypeOf((*func(float32, uint))(nil)).Elem(), emitMakerFloat32Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, uint))(nil)).Elem(), emitMakerETFloat32Uint)
- RegisterEmitter(reflect.TypeOf((*func(float32, uint8))(nil)).Elem(), emitMakerFloat32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, uint8))(nil)).Elem(), emitMakerETFloat32Uint8)
- RegisterEmitter(reflect.TypeOf((*func(float32, uint16))(nil)).Elem(), emitMakerFloat32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, uint16))(nil)).Elem(), emitMakerETFloat32Uint16)
- RegisterEmitter(reflect.TypeOf((*func(float32, uint32))(nil)).Elem(), emitMakerFloat32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, uint32))(nil)).Elem(), emitMakerETFloat32Uint32)
- RegisterEmitter(reflect.TypeOf((*func(float32, uint64))(nil)).Elem(), emitMakerFloat32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, uint64))(nil)).Elem(), emitMakerETFloat32Uint64)
- RegisterEmitter(reflect.TypeOf((*func(float32, float32))(nil)).Elem(), emitMakerFloat32Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, float32))(nil)).Elem(), emitMakerETFloat32Float32)
- RegisterEmitter(reflect.TypeOf((*func(float32, float64))(nil)).Elem(), emitMakerFloat32Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, float64))(nil)).Elem(), emitMakerETFloat32Float64)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.T))(nil)).Elem(), emitMakerFloat32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.T))(nil)).Elem(), emitMakerETFloat32Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.U))(nil)).Elem(), emitMakerFloat32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.U))(nil)).Elem(), emitMakerETFloat32Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.V))(nil)).Elem(), emitMakerFloat32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.V))(nil)).Elem(), emitMakerETFloat32Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.W))(nil)).Elem(), emitMakerFloat32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.W))(nil)).Elem(), emitMakerETFloat32Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.X))(nil)).Elem(), emitMakerFloat32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.X))(nil)).Elem(), emitMakerETFloat32Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.Y))(nil)).Elem(), emitMakerFloat32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.Y))(nil)).Elem(), emitMakerETFloat32Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(float32, typex.Z))(nil)).Elem(), emitMakerFloat32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float32, typex.Z))(nil)).Elem(), emitMakerETFloat32Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(float64))(nil)).Elem(), emitMakerFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64))(nil)).Elem(), emitMakerETFloat64)
- RegisterEmitter(reflect.TypeOf((*func(float64, []byte))(nil)).Elem(), emitMakerFloat64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, []byte))(nil)).Elem(), emitMakerETFloat64ByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(float64, bool))(nil)).Elem(), emitMakerFloat64Bool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, bool))(nil)).Elem(), emitMakerETFloat64Bool)
- RegisterEmitter(reflect.TypeOf((*func(float64, string))(nil)).Elem(), emitMakerFloat64String)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, string))(nil)).Elem(), emitMakerETFloat64String)
- RegisterEmitter(reflect.TypeOf((*func(float64, int))(nil)).Elem(), emitMakerFloat64Int)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, int))(nil)).Elem(), emitMakerETFloat64Int)
- RegisterEmitter(reflect.TypeOf((*func(float64, int8))(nil)).Elem(), emitMakerFloat64Int8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, int8))(nil)).Elem(), emitMakerETFloat64Int8)
- RegisterEmitter(reflect.TypeOf((*func(float64, int16))(nil)).Elem(), emitMakerFloat64Int16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, int16))(nil)).Elem(), emitMakerETFloat64Int16)
- RegisterEmitter(reflect.TypeOf((*func(float64, int32))(nil)).Elem(), emitMakerFloat64Int32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, int32))(nil)).Elem(), emitMakerETFloat64Int32)
- RegisterEmitter(reflect.TypeOf((*func(float64, int64))(nil)).Elem(), emitMakerFloat64Int64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, int64))(nil)).Elem(), emitMakerETFloat64Int64)
- RegisterEmitter(reflect.TypeOf((*func(float64, uint))(nil)).Elem(), emitMakerFloat64Uint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, uint))(nil)).Elem(), emitMakerETFloat64Uint)
- RegisterEmitter(reflect.TypeOf((*func(float64, uint8))(nil)).Elem(), emitMakerFloat64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, uint8))(nil)).Elem(), emitMakerETFloat64Uint8)
- RegisterEmitter(reflect.TypeOf((*func(float64, uint16))(nil)).Elem(), emitMakerFloat64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, uint16))(nil)).Elem(), emitMakerETFloat64Uint16)
- RegisterEmitter(reflect.TypeOf((*func(float64, uint32))(nil)).Elem(), emitMakerFloat64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, uint32))(nil)).Elem(), emitMakerETFloat64Uint32)
- RegisterEmitter(reflect.TypeOf((*func(float64, uint64))(nil)).Elem(), emitMakerFloat64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, uint64))(nil)).Elem(), emitMakerETFloat64Uint64)
- RegisterEmitter(reflect.TypeOf((*func(float64, float32))(nil)).Elem(), emitMakerFloat64Float32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, float32))(nil)).Elem(), emitMakerETFloat64Float32)
- RegisterEmitter(reflect.TypeOf((*func(float64, float64))(nil)).Elem(), emitMakerFloat64Float64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, float64))(nil)).Elem(), emitMakerETFloat64Float64)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.T))(nil)).Elem(), emitMakerFloat64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.T))(nil)).Elem(), emitMakerETFloat64Typex_T)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.U))(nil)).Elem(), emitMakerFloat64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.U))(nil)).Elem(), emitMakerETFloat64Typex_U)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.V))(nil)).Elem(), emitMakerFloat64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.V))(nil)).Elem(), emitMakerETFloat64Typex_V)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.W))(nil)).Elem(), emitMakerFloat64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.W))(nil)).Elem(), emitMakerETFloat64Typex_W)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.X))(nil)).Elem(), emitMakerFloat64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.X))(nil)).Elem(), emitMakerETFloat64Typex_X)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.Y))(nil)).Elem(), emitMakerFloat64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.Y))(nil)).Elem(), emitMakerETFloat64Typex_Y)
- RegisterEmitter(reflect.TypeOf((*func(float64, typex.Z))(nil)).Elem(), emitMakerFloat64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, float64, typex.Z))(nil)).Elem(), emitMakerETFloat64Typex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.T))(nil)).Elem(), emitMakerTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T))(nil)).Elem(), emitMakerETTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, []byte))(nil)).Elem(), emitMakerTypex_TByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, []byte))(nil)).Elem(), emitMakerETTypex_TByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, bool))(nil)).Elem(), emitMakerTypex_TBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, bool))(nil)).Elem(), emitMakerETTypex_TBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, string))(nil)).Elem(), emitMakerTypex_TString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, string))(nil)).Elem(), emitMakerETTypex_TString)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, int))(nil)).Elem(), emitMakerTypex_TInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, int))(nil)).Elem(), emitMakerETTypex_TInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, int8))(nil)).Elem(), emitMakerTypex_TInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, int8))(nil)).Elem(), emitMakerETTypex_TInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, int16))(nil)).Elem(), emitMakerTypex_TInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, int16))(nil)).Elem(), emitMakerETTypex_TInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, int32))(nil)).Elem(), emitMakerTypex_TInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, int32))(nil)).Elem(), emitMakerETTypex_TInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, int64))(nil)).Elem(), emitMakerTypex_TInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, int64))(nil)).Elem(), emitMakerETTypex_TInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, uint))(nil)).Elem(), emitMakerTypex_TUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, uint))(nil)).Elem(), emitMakerETTypex_TUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, uint8))(nil)).Elem(), emitMakerTypex_TUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, uint8))(nil)).Elem(), emitMakerETTypex_TUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, uint16))(nil)).Elem(), emitMakerTypex_TUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, uint16))(nil)).Elem(), emitMakerETTypex_TUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, uint32))(nil)).Elem(), emitMakerTypex_TUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, uint32))(nil)).Elem(), emitMakerETTypex_TUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, uint64))(nil)).Elem(), emitMakerTypex_TUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, uint64))(nil)).Elem(), emitMakerETTypex_TUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, float32))(nil)).Elem(), emitMakerTypex_TFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, float32))(nil)).Elem(), emitMakerETTypex_TFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, float64))(nil)).Elem(), emitMakerTypex_TFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, float64))(nil)).Elem(), emitMakerETTypex_TFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.T))(nil)).Elem(), emitMakerTypex_TTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.T))(nil)).Elem(), emitMakerETTypex_TTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.U))(nil)).Elem(), emitMakerTypex_TTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.U))(nil)).Elem(), emitMakerETTypex_TTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.V))(nil)).Elem(), emitMakerTypex_TTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.V))(nil)).Elem(), emitMakerETTypex_TTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.W))(nil)).Elem(), emitMakerTypex_TTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.W))(nil)).Elem(), emitMakerETTypex_TTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.X))(nil)).Elem(), emitMakerTypex_TTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.X))(nil)).Elem(), emitMakerETTypex_TTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.Y))(nil)).Elem(), emitMakerTypex_TTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.Y))(nil)).Elem(), emitMakerETTypex_TTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.T, typex.Z))(nil)).Elem(), emitMakerTypex_TTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.T, typex.Z))(nil)).Elem(), emitMakerETTypex_TTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.U))(nil)).Elem(), emitMakerTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U))(nil)).Elem(), emitMakerETTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, []byte))(nil)).Elem(), emitMakerTypex_UByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, []byte))(nil)).Elem(), emitMakerETTypex_UByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, bool))(nil)).Elem(), emitMakerTypex_UBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, bool))(nil)).Elem(), emitMakerETTypex_UBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, string))(nil)).Elem(), emitMakerTypex_UString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, string))(nil)).Elem(), emitMakerETTypex_UString)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, int))(nil)).Elem(), emitMakerTypex_UInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, int))(nil)).Elem(), emitMakerETTypex_UInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, int8))(nil)).Elem(), emitMakerTypex_UInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, int8))(nil)).Elem(), emitMakerETTypex_UInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, int16))(nil)).Elem(), emitMakerTypex_UInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, int16))(nil)).Elem(), emitMakerETTypex_UInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, int32))(nil)).Elem(), emitMakerTypex_UInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, int32))(nil)).Elem(), emitMakerETTypex_UInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, int64))(nil)).Elem(), emitMakerTypex_UInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, int64))(nil)).Elem(), emitMakerETTypex_UInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, uint))(nil)).Elem(), emitMakerTypex_UUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, uint))(nil)).Elem(), emitMakerETTypex_UUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, uint8))(nil)).Elem(), emitMakerTypex_UUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, uint8))(nil)).Elem(), emitMakerETTypex_UUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, uint16))(nil)).Elem(), emitMakerTypex_UUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, uint16))(nil)).Elem(), emitMakerETTypex_UUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, uint32))(nil)).Elem(), emitMakerTypex_UUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, uint32))(nil)).Elem(), emitMakerETTypex_UUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, uint64))(nil)).Elem(), emitMakerTypex_UUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, uint64))(nil)).Elem(), emitMakerETTypex_UUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, float32))(nil)).Elem(), emitMakerTypex_UFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, float32))(nil)).Elem(), emitMakerETTypex_UFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, float64))(nil)).Elem(), emitMakerTypex_UFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, float64))(nil)).Elem(), emitMakerETTypex_UFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.T))(nil)).Elem(), emitMakerTypex_UTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.T))(nil)).Elem(), emitMakerETTypex_UTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.U))(nil)).Elem(), emitMakerTypex_UTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.U))(nil)).Elem(), emitMakerETTypex_UTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.V))(nil)).Elem(), emitMakerTypex_UTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.V))(nil)).Elem(), emitMakerETTypex_UTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.W))(nil)).Elem(), emitMakerTypex_UTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.W))(nil)).Elem(), emitMakerETTypex_UTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.X))(nil)).Elem(), emitMakerTypex_UTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.X))(nil)).Elem(), emitMakerETTypex_UTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.Y))(nil)).Elem(), emitMakerTypex_UTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.Y))(nil)).Elem(), emitMakerETTypex_UTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.U, typex.Z))(nil)).Elem(), emitMakerTypex_UTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.U, typex.Z))(nil)).Elem(), emitMakerETTypex_UTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.V))(nil)).Elem(), emitMakerTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V))(nil)).Elem(), emitMakerETTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, []byte))(nil)).Elem(), emitMakerTypex_VByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, []byte))(nil)).Elem(), emitMakerETTypex_VByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, bool))(nil)).Elem(), emitMakerTypex_VBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, bool))(nil)).Elem(), emitMakerETTypex_VBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, string))(nil)).Elem(), emitMakerTypex_VString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, string))(nil)).Elem(), emitMakerETTypex_VString)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, int))(nil)).Elem(), emitMakerTypex_VInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, int))(nil)).Elem(), emitMakerETTypex_VInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, int8))(nil)).Elem(), emitMakerTypex_VInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, int8))(nil)).Elem(), emitMakerETTypex_VInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, int16))(nil)).Elem(), emitMakerTypex_VInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, int16))(nil)).Elem(), emitMakerETTypex_VInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, int32))(nil)).Elem(), emitMakerTypex_VInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, int32))(nil)).Elem(), emitMakerETTypex_VInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, int64))(nil)).Elem(), emitMakerTypex_VInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, int64))(nil)).Elem(), emitMakerETTypex_VInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, uint))(nil)).Elem(), emitMakerTypex_VUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, uint))(nil)).Elem(), emitMakerETTypex_VUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, uint8))(nil)).Elem(), emitMakerTypex_VUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, uint8))(nil)).Elem(), emitMakerETTypex_VUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, uint16))(nil)).Elem(), emitMakerTypex_VUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, uint16))(nil)).Elem(), emitMakerETTypex_VUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, uint32))(nil)).Elem(), emitMakerTypex_VUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, uint32))(nil)).Elem(), emitMakerETTypex_VUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, uint64))(nil)).Elem(), emitMakerTypex_VUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, uint64))(nil)).Elem(), emitMakerETTypex_VUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, float32))(nil)).Elem(), emitMakerTypex_VFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, float32))(nil)).Elem(), emitMakerETTypex_VFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, float64))(nil)).Elem(), emitMakerTypex_VFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, float64))(nil)).Elem(), emitMakerETTypex_VFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.T))(nil)).Elem(), emitMakerTypex_VTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.T))(nil)).Elem(), emitMakerETTypex_VTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.U))(nil)).Elem(), emitMakerTypex_VTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.U))(nil)).Elem(), emitMakerETTypex_VTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.V))(nil)).Elem(), emitMakerTypex_VTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.V))(nil)).Elem(), emitMakerETTypex_VTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.W))(nil)).Elem(), emitMakerTypex_VTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.W))(nil)).Elem(), emitMakerETTypex_VTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.X))(nil)).Elem(), emitMakerTypex_VTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.X))(nil)).Elem(), emitMakerETTypex_VTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.Y))(nil)).Elem(), emitMakerTypex_VTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.Y))(nil)).Elem(), emitMakerETTypex_VTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.V, typex.Z))(nil)).Elem(), emitMakerTypex_VTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.V, typex.Z))(nil)).Elem(), emitMakerETTypex_VTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.W))(nil)).Elem(), emitMakerTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W))(nil)).Elem(), emitMakerETTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, []byte))(nil)).Elem(), emitMakerTypex_WByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, []byte))(nil)).Elem(), emitMakerETTypex_WByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, bool))(nil)).Elem(), emitMakerTypex_WBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, bool))(nil)).Elem(), emitMakerETTypex_WBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, string))(nil)).Elem(), emitMakerTypex_WString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, string))(nil)).Elem(), emitMakerETTypex_WString)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, int))(nil)).Elem(), emitMakerTypex_WInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, int))(nil)).Elem(), emitMakerETTypex_WInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, int8))(nil)).Elem(), emitMakerTypex_WInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, int8))(nil)).Elem(), emitMakerETTypex_WInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, int16))(nil)).Elem(), emitMakerTypex_WInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, int16))(nil)).Elem(), emitMakerETTypex_WInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, int32))(nil)).Elem(), emitMakerTypex_WInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, int32))(nil)).Elem(), emitMakerETTypex_WInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, int64))(nil)).Elem(), emitMakerTypex_WInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, int64))(nil)).Elem(), emitMakerETTypex_WInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, uint))(nil)).Elem(), emitMakerTypex_WUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, uint))(nil)).Elem(), emitMakerETTypex_WUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, uint8))(nil)).Elem(), emitMakerTypex_WUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, uint8))(nil)).Elem(), emitMakerETTypex_WUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, uint16))(nil)).Elem(), emitMakerTypex_WUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, uint16))(nil)).Elem(), emitMakerETTypex_WUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, uint32))(nil)).Elem(), emitMakerTypex_WUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, uint32))(nil)).Elem(), emitMakerETTypex_WUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, uint64))(nil)).Elem(), emitMakerTypex_WUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, uint64))(nil)).Elem(), emitMakerETTypex_WUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, float32))(nil)).Elem(), emitMakerTypex_WFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, float32))(nil)).Elem(), emitMakerETTypex_WFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, float64))(nil)).Elem(), emitMakerTypex_WFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, float64))(nil)).Elem(), emitMakerETTypex_WFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.T))(nil)).Elem(), emitMakerTypex_WTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.T))(nil)).Elem(), emitMakerETTypex_WTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.U))(nil)).Elem(), emitMakerTypex_WTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.U))(nil)).Elem(), emitMakerETTypex_WTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.V))(nil)).Elem(), emitMakerTypex_WTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.V))(nil)).Elem(), emitMakerETTypex_WTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.W))(nil)).Elem(), emitMakerTypex_WTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.W))(nil)).Elem(), emitMakerETTypex_WTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.X))(nil)).Elem(), emitMakerTypex_WTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.X))(nil)).Elem(), emitMakerETTypex_WTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.Y))(nil)).Elem(), emitMakerTypex_WTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.Y))(nil)).Elem(), emitMakerETTypex_WTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.W, typex.Z))(nil)).Elem(), emitMakerTypex_WTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.W, typex.Z))(nil)).Elem(), emitMakerETTypex_WTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.X))(nil)).Elem(), emitMakerTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X))(nil)).Elem(), emitMakerETTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, []byte))(nil)).Elem(), emitMakerTypex_XByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, []byte))(nil)).Elem(), emitMakerETTypex_XByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, bool))(nil)).Elem(), emitMakerTypex_XBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, bool))(nil)).Elem(), emitMakerETTypex_XBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, string))(nil)).Elem(), emitMakerTypex_XString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, string))(nil)).Elem(), emitMakerETTypex_XString)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, int))(nil)).Elem(), emitMakerTypex_XInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, int))(nil)).Elem(), emitMakerETTypex_XInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, int8))(nil)).Elem(), emitMakerTypex_XInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, int8))(nil)).Elem(), emitMakerETTypex_XInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, int16))(nil)).Elem(), emitMakerTypex_XInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, int16))(nil)).Elem(), emitMakerETTypex_XInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, int32))(nil)).Elem(), emitMakerTypex_XInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, int32))(nil)).Elem(), emitMakerETTypex_XInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, int64))(nil)).Elem(), emitMakerTypex_XInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, int64))(nil)).Elem(), emitMakerETTypex_XInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, uint))(nil)).Elem(), emitMakerTypex_XUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, uint))(nil)).Elem(), emitMakerETTypex_XUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, uint8))(nil)).Elem(), emitMakerTypex_XUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, uint8))(nil)).Elem(), emitMakerETTypex_XUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, uint16))(nil)).Elem(), emitMakerTypex_XUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, uint16))(nil)).Elem(), emitMakerETTypex_XUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, uint32))(nil)).Elem(), emitMakerTypex_XUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, uint32))(nil)).Elem(), emitMakerETTypex_XUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, uint64))(nil)).Elem(), emitMakerTypex_XUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, uint64))(nil)).Elem(), emitMakerETTypex_XUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, float32))(nil)).Elem(), emitMakerTypex_XFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, float32))(nil)).Elem(), emitMakerETTypex_XFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, float64))(nil)).Elem(), emitMakerTypex_XFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, float64))(nil)).Elem(), emitMakerETTypex_XFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.T))(nil)).Elem(), emitMakerTypex_XTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.T))(nil)).Elem(), emitMakerETTypex_XTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.U))(nil)).Elem(), emitMakerTypex_XTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.U))(nil)).Elem(), emitMakerETTypex_XTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.V))(nil)).Elem(), emitMakerTypex_XTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.V))(nil)).Elem(), emitMakerETTypex_XTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.W))(nil)).Elem(), emitMakerTypex_XTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.W))(nil)).Elem(), emitMakerETTypex_XTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.X))(nil)).Elem(), emitMakerTypex_XTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.X))(nil)).Elem(), emitMakerETTypex_XTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.Y))(nil)).Elem(), emitMakerTypex_XTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.Y))(nil)).Elem(), emitMakerETTypex_XTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.X, typex.Z))(nil)).Elem(), emitMakerTypex_XTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.X, typex.Z))(nil)).Elem(), emitMakerETTypex_XTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y))(nil)).Elem(), emitMakerTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y))(nil)).Elem(), emitMakerETTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, []byte))(nil)).Elem(), emitMakerTypex_YByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, []byte))(nil)).Elem(), emitMakerETTypex_YByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, bool))(nil)).Elem(), emitMakerTypex_YBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, bool))(nil)).Elem(), emitMakerETTypex_YBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, string))(nil)).Elem(), emitMakerTypex_YString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, string))(nil)).Elem(), emitMakerETTypex_YString)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, int))(nil)).Elem(), emitMakerTypex_YInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, int))(nil)).Elem(), emitMakerETTypex_YInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, int8))(nil)).Elem(), emitMakerTypex_YInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, int8))(nil)).Elem(), emitMakerETTypex_YInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, int16))(nil)).Elem(), emitMakerTypex_YInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, int16))(nil)).Elem(), emitMakerETTypex_YInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, int32))(nil)).Elem(), emitMakerTypex_YInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, int32))(nil)).Elem(), emitMakerETTypex_YInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, int64))(nil)).Elem(), emitMakerTypex_YInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, int64))(nil)).Elem(), emitMakerETTypex_YInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, uint))(nil)).Elem(), emitMakerTypex_YUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, uint))(nil)).Elem(), emitMakerETTypex_YUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, uint8))(nil)).Elem(), emitMakerTypex_YUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, uint8))(nil)).Elem(), emitMakerETTypex_YUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, uint16))(nil)).Elem(), emitMakerTypex_YUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, uint16))(nil)).Elem(), emitMakerETTypex_YUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, uint32))(nil)).Elem(), emitMakerTypex_YUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, uint32))(nil)).Elem(), emitMakerETTypex_YUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, uint64))(nil)).Elem(), emitMakerTypex_YUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, uint64))(nil)).Elem(), emitMakerETTypex_YUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, float32))(nil)).Elem(), emitMakerTypex_YFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, float32))(nil)).Elem(), emitMakerETTypex_YFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, float64))(nil)).Elem(), emitMakerTypex_YFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, float64))(nil)).Elem(), emitMakerETTypex_YFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.T))(nil)).Elem(), emitMakerTypex_YTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.T))(nil)).Elem(), emitMakerETTypex_YTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.U))(nil)).Elem(), emitMakerTypex_YTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.U))(nil)).Elem(), emitMakerETTypex_YTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.V))(nil)).Elem(), emitMakerTypex_YTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.V))(nil)).Elem(), emitMakerETTypex_YTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.W))(nil)).Elem(), emitMakerTypex_YTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.W))(nil)).Elem(), emitMakerETTypex_YTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.X))(nil)).Elem(), emitMakerTypex_YTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.X))(nil)).Elem(), emitMakerETTypex_YTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.Y))(nil)).Elem(), emitMakerTypex_YTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.Y))(nil)).Elem(), emitMakerETTypex_YTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.Y, typex.Z))(nil)).Elem(), emitMakerTypex_YTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Y, typex.Z))(nil)).Elem(), emitMakerETTypex_YTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z))(nil)).Elem(), emitMakerTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z))(nil)).Elem(), emitMakerETTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, []byte))(nil)).Elem(), emitMakerTypex_ZByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, []byte))(nil)).Elem(), emitMakerETTypex_ZByteSlice)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, bool))(nil)).Elem(), emitMakerTypex_ZBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, bool))(nil)).Elem(), emitMakerETTypex_ZBool)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, string))(nil)).Elem(), emitMakerTypex_ZString)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, string))(nil)).Elem(), emitMakerETTypex_ZString)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, int))(nil)).Elem(), emitMakerTypex_ZInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, int))(nil)).Elem(), emitMakerETTypex_ZInt)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, int8))(nil)).Elem(), emitMakerTypex_ZInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, int8))(nil)).Elem(), emitMakerETTypex_ZInt8)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, int16))(nil)).Elem(), emitMakerTypex_ZInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, int16))(nil)).Elem(), emitMakerETTypex_ZInt16)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, int32))(nil)).Elem(), emitMakerTypex_ZInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, int32))(nil)).Elem(), emitMakerETTypex_ZInt32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, int64))(nil)).Elem(), emitMakerTypex_ZInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, int64))(nil)).Elem(), emitMakerETTypex_ZInt64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, uint))(nil)).Elem(), emitMakerTypex_ZUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, uint))(nil)).Elem(), emitMakerETTypex_ZUint)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, uint8))(nil)).Elem(), emitMakerTypex_ZUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, uint8))(nil)).Elem(), emitMakerETTypex_ZUint8)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, uint16))(nil)).Elem(), emitMakerTypex_ZUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, uint16))(nil)).Elem(), emitMakerETTypex_ZUint16)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, uint32))(nil)).Elem(), emitMakerTypex_ZUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, uint32))(nil)).Elem(), emitMakerETTypex_ZUint32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, uint64))(nil)).Elem(), emitMakerTypex_ZUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, uint64))(nil)).Elem(), emitMakerETTypex_ZUint64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, float32))(nil)).Elem(), emitMakerTypex_ZFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, float32))(nil)).Elem(), emitMakerETTypex_ZFloat32)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, float64))(nil)).Elem(), emitMakerTypex_ZFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, float64))(nil)).Elem(), emitMakerETTypex_ZFloat64)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.T))(nil)).Elem(), emitMakerTypex_ZTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.T))(nil)).Elem(), emitMakerETTypex_ZTypex_T)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.U))(nil)).Elem(), emitMakerTypex_ZTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.U))(nil)).Elem(), emitMakerETTypex_ZTypex_U)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.V))(nil)).Elem(), emitMakerTypex_ZTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.V))(nil)).Elem(), emitMakerETTypex_ZTypex_V)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.W))(nil)).Elem(), emitMakerTypex_ZTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.W))(nil)).Elem(), emitMakerETTypex_ZTypex_W)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.X))(nil)).Elem(), emitMakerTypex_ZTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.X))(nil)).Elem(), emitMakerETTypex_ZTypex_X)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.Y))(nil)).Elem(), emitMakerTypex_ZTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.Y))(nil)).Elem(), emitMakerETTypex_ZTypex_Y)
- RegisterEmitter(reflect.TypeOf((*func(typex.Z, typex.Z))(nil)).Elem(), emitMakerTypex_ZTypex_Z)
- RegisterEmitter(reflect.TypeOf((*func(typex.EventTime, typex.Z, typex.Z))(nil)).Elem(), emitMakerETTypex_ZTypex_Z)
-}
-
-type emitNative struct {
- n ElementProcessor
- fn reflect.Value
-
- ctx context.Context
- et typex.EventTime
-}
-
-func (e *emitNative) Init(ctx context.Context, et typex.EventTime) error {
- e.ctx = ctx
- e.et = et
- return nil
-}
-
-func (e *emitNative) Value() reflect.Value {
- return e.fn
-}
-
-func emitMakerByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeByteSlice(elm []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETByteSlice(t typex.EventTime, elm []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceByteSlice(key []byte, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceByteSlice(t typex.EventTime, key []byte, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceBool)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceBool(key []byte, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceBool)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceBool(t typex.EventTime, key []byte, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceString)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceString(key []byte, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceString)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceString(t typex.EventTime, key []byte, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceInt)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceInt(key []byte, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceInt)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceInt(t typex.EventTime, key []byte, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceInt8)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceInt8(key []byte, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceInt8)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceInt8(t typex.EventTime, key []byte, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceInt16)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceInt16(key []byte, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceInt16)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceInt16(t typex.EventTime, key []byte, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceInt32)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceInt32(key []byte, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceInt32)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceInt32(t typex.EventTime, key []byte, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceInt64)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceInt64(key []byte, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceInt64)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceInt64(t typex.EventTime, key []byte, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceUint)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceUint(key []byte, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceUint)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceUint(t typex.EventTime, key []byte, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceUint8)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceUint8(key []byte, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceUint8)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceUint8(t typex.EventTime, key []byte, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceUint16)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceUint16(key []byte, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceUint16)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceUint16(t typex.EventTime, key []byte, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceUint32)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceUint32(key []byte, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceUint32)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceUint32(t typex.EventTime, key []byte, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceUint64)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceUint64(key []byte, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceUint64)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceUint64(t typex.EventTime, key []byte, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceFloat32)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceFloat32(key []byte, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceFloat32)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceFloat32(t typex.EventTime, key []byte, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceFloat64)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceFloat64(key []byte, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceFloat64)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceFloat64(t typex.EventTime, key []byte, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_T(key []byte, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_T(t typex.EventTime, key []byte, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_U(key []byte, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_U(t typex.EventTime, key []byte, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_V(key []byte, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_V(t typex.EventTime, key []byte, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_W(key []byte, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_W(t typex.EventTime, key []byte, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_X(key []byte, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_X(t typex.EventTime, key []byte, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_Y(key []byte, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_Y(t typex.EventTime, key []byte, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerByteSliceTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeByteSliceTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeByteSliceTypex_Z(key []byte, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETByteSliceTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETByteSliceTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETByteSliceTypex_Z(t typex.EventTime, key []byte, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBool)
- return ret
-}
-
-func (e *emitNative) invokeBool(elm bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBool)
- return ret
-}
-
-func (e *emitNative) invokeETBool(t typex.EventTime, elm bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeBoolByteSlice(key bool, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETBoolByteSlice(t typex.EventTime, key bool, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolBool)
- return ret
-}
-
-func (e *emitNative) invokeBoolBool(key bool, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolBool)
- return ret
-}
-
-func (e *emitNative) invokeETBoolBool(t typex.EventTime, key bool, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolString)
- return ret
-}
-
-func (e *emitNative) invokeBoolString(key bool, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolString)
- return ret
-}
-
-func (e *emitNative) invokeETBoolString(t typex.EventTime, key bool, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolInt)
- return ret
-}
-
-func (e *emitNative) invokeBoolInt(key bool, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolInt)
- return ret
-}
-
-func (e *emitNative) invokeETBoolInt(t typex.EventTime, key bool, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolInt8)
- return ret
-}
-
-func (e *emitNative) invokeBoolInt8(key bool, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolInt8)
- return ret
-}
-
-func (e *emitNative) invokeETBoolInt8(t typex.EventTime, key bool, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolInt16)
- return ret
-}
-
-func (e *emitNative) invokeBoolInt16(key bool, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolInt16)
- return ret
-}
-
-func (e *emitNative) invokeETBoolInt16(t typex.EventTime, key bool, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolInt32)
- return ret
-}
-
-func (e *emitNative) invokeBoolInt32(key bool, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolInt32)
- return ret
-}
-
-func (e *emitNative) invokeETBoolInt32(t typex.EventTime, key bool, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolInt64)
- return ret
-}
-
-func (e *emitNative) invokeBoolInt64(key bool, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolInt64)
- return ret
-}
-
-func (e *emitNative) invokeETBoolInt64(t typex.EventTime, key bool, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolUint)
- return ret
-}
-
-func (e *emitNative) invokeBoolUint(key bool, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolUint)
- return ret
-}
-
-func (e *emitNative) invokeETBoolUint(t typex.EventTime, key bool, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolUint8)
- return ret
-}
-
-func (e *emitNative) invokeBoolUint8(key bool, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolUint8)
- return ret
-}
-
-func (e *emitNative) invokeETBoolUint8(t typex.EventTime, key bool, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolUint16)
- return ret
-}
-
-func (e *emitNative) invokeBoolUint16(key bool, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolUint16)
- return ret
-}
-
-func (e *emitNative) invokeETBoolUint16(t typex.EventTime, key bool, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolUint32)
- return ret
-}
-
-func (e *emitNative) invokeBoolUint32(key bool, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolUint32)
- return ret
-}
-
-func (e *emitNative) invokeETBoolUint32(t typex.EventTime, key bool, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolUint64)
- return ret
-}
-
-func (e *emitNative) invokeBoolUint64(key bool, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolUint64)
- return ret
-}
-
-func (e *emitNative) invokeETBoolUint64(t typex.EventTime, key bool, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolFloat32)
- return ret
-}
-
-func (e *emitNative) invokeBoolFloat32(key bool, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolFloat32)
- return ret
-}
-
-func (e *emitNative) invokeETBoolFloat32(t typex.EventTime, key bool, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolFloat64)
- return ret
-}
-
-func (e *emitNative) invokeBoolFloat64(key bool, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolFloat64)
- return ret
-}
-
-func (e *emitNative) invokeETBoolFloat64(t typex.EventTime, key bool, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_T(key bool, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_T(t typex.EventTime, key bool, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_U(key bool, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_U(t typex.EventTime, key bool, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_V(key bool, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_V(t typex.EventTime, key bool, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_W(key bool, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_W(t typex.EventTime, key bool, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_X(key bool, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_X(t typex.EventTime, key bool, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_Y(key bool, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_Y(t typex.EventTime, key bool, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerBoolTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeBoolTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeBoolTypex_Z(key bool, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETBoolTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETBoolTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETBoolTypex_Z(t typex.EventTime, key bool, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeString)
- return ret
-}
-
-func (e *emitNative) invokeString(elm string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETString)
- return ret
-}
-
-func (e *emitNative) invokeETString(t typex.EventTime, elm string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeStringByteSlice(key string, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETStringByteSlice(t typex.EventTime, key string, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringBool)
- return ret
-}
-
-func (e *emitNative) invokeStringBool(key string, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringBool)
- return ret
-}
-
-func (e *emitNative) invokeETStringBool(t typex.EventTime, key string, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringString)
- return ret
-}
-
-func (e *emitNative) invokeStringString(key string, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringString)
- return ret
-}
-
-func (e *emitNative) invokeETStringString(t typex.EventTime, key string, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringInt)
- return ret
-}
-
-func (e *emitNative) invokeStringInt(key string, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringInt)
- return ret
-}
-
-func (e *emitNative) invokeETStringInt(t typex.EventTime, key string, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringInt8)
- return ret
-}
-
-func (e *emitNative) invokeStringInt8(key string, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringInt8)
- return ret
-}
-
-func (e *emitNative) invokeETStringInt8(t typex.EventTime, key string, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringInt16)
- return ret
-}
-
-func (e *emitNative) invokeStringInt16(key string, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringInt16)
- return ret
-}
-
-func (e *emitNative) invokeETStringInt16(t typex.EventTime, key string, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringInt32)
- return ret
-}
-
-func (e *emitNative) invokeStringInt32(key string, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringInt32)
- return ret
-}
-
-func (e *emitNative) invokeETStringInt32(t typex.EventTime, key string, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringInt64)
- return ret
-}
-
-func (e *emitNative) invokeStringInt64(key string, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringInt64)
- return ret
-}
-
-func (e *emitNative) invokeETStringInt64(t typex.EventTime, key string, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringUint)
- return ret
-}
-
-func (e *emitNative) invokeStringUint(key string, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringUint)
- return ret
-}
-
-func (e *emitNative) invokeETStringUint(t typex.EventTime, key string, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringUint8)
- return ret
-}
-
-func (e *emitNative) invokeStringUint8(key string, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringUint8)
- return ret
-}
-
-func (e *emitNative) invokeETStringUint8(t typex.EventTime, key string, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringUint16)
- return ret
-}
-
-func (e *emitNative) invokeStringUint16(key string, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringUint16)
- return ret
-}
-
-func (e *emitNative) invokeETStringUint16(t typex.EventTime, key string, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringUint32)
- return ret
-}
-
-func (e *emitNative) invokeStringUint32(key string, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringUint32)
- return ret
-}
-
-func (e *emitNative) invokeETStringUint32(t typex.EventTime, key string, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringUint64)
- return ret
-}
-
-func (e *emitNative) invokeStringUint64(key string, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringUint64)
- return ret
-}
-
-func (e *emitNative) invokeETStringUint64(t typex.EventTime, key string, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringFloat32)
- return ret
-}
-
-func (e *emitNative) invokeStringFloat32(key string, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringFloat32)
- return ret
-}
-
-func (e *emitNative) invokeETStringFloat32(t typex.EventTime, key string, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringFloat64)
- return ret
-}
-
-func (e *emitNative) invokeStringFloat64(key string, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringFloat64)
- return ret
-}
-
-func (e *emitNative) invokeETStringFloat64(t typex.EventTime, key string, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_T(key string, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_T(t typex.EventTime, key string, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_U(key string, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_U(t typex.EventTime, key string, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_V(key string, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_V(t typex.EventTime, key string, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_W(key string, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_W(t typex.EventTime, key string, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_X(key string, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_X(t typex.EventTime, key string, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_Y(key string, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_Y(t typex.EventTime, key string, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerStringTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeStringTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeStringTypex_Z(key string, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETStringTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETStringTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETStringTypex_Z(t typex.EventTime, key string, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt)
- return ret
-}
-
-func (e *emitNative) invokeInt(elm int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt)
- return ret
-}
-
-func (e *emitNative) invokeETInt(t typex.EventTime, elm int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeIntByteSlice(key int, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETIntByteSlice(t typex.EventTime, key int, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntBool)
- return ret
-}
-
-func (e *emitNative) invokeIntBool(key int, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntBool)
- return ret
-}
-
-func (e *emitNative) invokeETIntBool(t typex.EventTime, key int, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntString)
- return ret
-}
-
-func (e *emitNative) invokeIntString(key int, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntString)
- return ret
-}
-
-func (e *emitNative) invokeETIntString(t typex.EventTime, key int, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntInt)
- return ret
-}
-
-func (e *emitNative) invokeIntInt(key int, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntInt)
- return ret
-}
-
-func (e *emitNative) invokeETIntInt(t typex.EventTime, key int, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntInt8)
- return ret
-}
-
-func (e *emitNative) invokeIntInt8(key int, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntInt8)
- return ret
-}
-
-func (e *emitNative) invokeETIntInt8(t typex.EventTime, key int, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntInt16)
- return ret
-}
-
-func (e *emitNative) invokeIntInt16(key int, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntInt16)
- return ret
-}
-
-func (e *emitNative) invokeETIntInt16(t typex.EventTime, key int, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntInt32)
- return ret
-}
-
-func (e *emitNative) invokeIntInt32(key int, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntInt32)
- return ret
-}
-
-func (e *emitNative) invokeETIntInt32(t typex.EventTime, key int, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntInt64)
- return ret
-}
-
-func (e *emitNative) invokeIntInt64(key int, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntInt64)
- return ret
-}
-
-func (e *emitNative) invokeETIntInt64(t typex.EventTime, key int, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntUint)
- return ret
-}
-
-func (e *emitNative) invokeIntUint(key int, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntUint)
- return ret
-}
-
-func (e *emitNative) invokeETIntUint(t typex.EventTime, key int, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntUint8)
- return ret
-}
-
-func (e *emitNative) invokeIntUint8(key int, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntUint8)
- return ret
-}
-
-func (e *emitNative) invokeETIntUint8(t typex.EventTime, key int, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntUint16)
- return ret
-}
-
-func (e *emitNative) invokeIntUint16(key int, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntUint16)
- return ret
-}
-
-func (e *emitNative) invokeETIntUint16(t typex.EventTime, key int, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntUint32)
- return ret
-}
-
-func (e *emitNative) invokeIntUint32(key int, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntUint32)
- return ret
-}
-
-func (e *emitNative) invokeETIntUint32(t typex.EventTime, key int, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntUint64)
- return ret
-}
-
-func (e *emitNative) invokeIntUint64(key int, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntUint64)
- return ret
-}
-
-func (e *emitNative) invokeETIntUint64(t typex.EventTime, key int, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntFloat32)
- return ret
-}
-
-func (e *emitNative) invokeIntFloat32(key int, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntFloat32)
- return ret
-}
-
-func (e *emitNative) invokeETIntFloat32(t typex.EventTime, key int, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntFloat64)
- return ret
-}
-
-func (e *emitNative) invokeIntFloat64(key int, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntFloat64)
- return ret
-}
-
-func (e *emitNative) invokeETIntFloat64(t typex.EventTime, key int, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_T(key int, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_T(t typex.EventTime, key int, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_U(key int, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_U(t typex.EventTime, key int, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_V(key int, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_V(t typex.EventTime, key int, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_W(key int, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_W(t typex.EventTime, key int, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_X(key int, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_X(t typex.EventTime, key int, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_Y(key int, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_Y(t typex.EventTime, key int, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerIntTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeIntTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeIntTypex_Z(key int, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETIntTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETIntTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETIntTypex_Z(t typex.EventTime, key int, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8)
- return ret
-}
-
-func (e *emitNative) invokeInt8(elm int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8)
- return ret
-}
-
-func (e *emitNative) invokeETInt8(t typex.EventTime, elm int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeInt8ByteSlice(key int8, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETInt8ByteSlice(t typex.EventTime, key int8, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Bool)
- return ret
-}
-
-func (e *emitNative) invokeInt8Bool(key int8, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Bool)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Bool(t typex.EventTime, key int8, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8String)
- return ret
-}
-
-func (e *emitNative) invokeInt8String(key int8, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8String)
- return ret
-}
-
-func (e *emitNative) invokeETInt8String(t typex.EventTime, key int8, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Int)
- return ret
-}
-
-func (e *emitNative) invokeInt8Int(key int8, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Int)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Int(t typex.EventTime, key int8, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Int8)
- return ret
-}
-
-func (e *emitNative) invokeInt8Int8(key int8, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Int8)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Int8(t typex.EventTime, key int8, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Int16)
- return ret
-}
-
-func (e *emitNative) invokeInt8Int16(key int8, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Int16)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Int16(t typex.EventTime, key int8, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Int32)
- return ret
-}
-
-func (e *emitNative) invokeInt8Int32(key int8, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Int32)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Int32(t typex.EventTime, key int8, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Int64)
- return ret
-}
-
-func (e *emitNative) invokeInt8Int64(key int8, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Int64)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Int64(t typex.EventTime, key int8, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Uint)
- return ret
-}
-
-func (e *emitNative) invokeInt8Uint(key int8, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Uint)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Uint(t typex.EventTime, key int8, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Uint8)
- return ret
-}
-
-func (e *emitNative) invokeInt8Uint8(key int8, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Uint8(t typex.EventTime, key int8, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Uint16)
- return ret
-}
-
-func (e *emitNative) invokeInt8Uint16(key int8, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Uint16(t typex.EventTime, key int8, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Uint32)
- return ret
-}
-
-func (e *emitNative) invokeInt8Uint32(key int8, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Uint32(t typex.EventTime, key int8, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Uint64)
- return ret
-}
-
-func (e *emitNative) invokeInt8Uint64(key int8, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Uint64(t typex.EventTime, key int8, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Float32)
- return ret
-}
-
-func (e *emitNative) invokeInt8Float32(key int8, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Float32)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Float32(t typex.EventTime, key int8, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Float64)
- return ret
-}
-
-func (e *emitNative) invokeInt8Float64(key int8, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Float64)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Float64(t typex.EventTime, key int8, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_T(key int8, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_T(t typex.EventTime, key int8, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_U(key int8, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_U(t typex.EventTime, key int8, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_V(key int8, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_V(t typex.EventTime, key int8, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_W(key int8, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_W(t typex.EventTime, key int8, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_X(key int8, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_X(t typex.EventTime, key int8, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_Y(key int8, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_Y(t typex.EventTime, key int8, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt8Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt8Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeInt8Typex_Z(key int8, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt8Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt8Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETInt8Typex_Z(t typex.EventTime, key int8, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16)
- return ret
-}
-
-func (e *emitNative) invokeInt16(elm int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16)
- return ret
-}
-
-func (e *emitNative) invokeETInt16(t typex.EventTime, elm int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeInt16ByteSlice(key int16, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETInt16ByteSlice(t typex.EventTime, key int16, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Bool)
- return ret
-}
-
-func (e *emitNative) invokeInt16Bool(key int16, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Bool)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Bool(t typex.EventTime, key int16, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16String)
- return ret
-}
-
-func (e *emitNative) invokeInt16String(key int16, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16String)
- return ret
-}
-
-func (e *emitNative) invokeETInt16String(t typex.EventTime, key int16, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Int)
- return ret
-}
-
-func (e *emitNative) invokeInt16Int(key int16, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Int)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Int(t typex.EventTime, key int16, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Int8)
- return ret
-}
-
-func (e *emitNative) invokeInt16Int8(key int16, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Int8)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Int8(t typex.EventTime, key int16, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Int16)
- return ret
-}
-
-func (e *emitNative) invokeInt16Int16(key int16, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Int16)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Int16(t typex.EventTime, key int16, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Int32)
- return ret
-}
-
-func (e *emitNative) invokeInt16Int32(key int16, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Int32)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Int32(t typex.EventTime, key int16, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Int64)
- return ret
-}
-
-func (e *emitNative) invokeInt16Int64(key int16, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Int64)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Int64(t typex.EventTime, key int16, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Uint)
- return ret
-}
-
-func (e *emitNative) invokeInt16Uint(key int16, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Uint)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Uint(t typex.EventTime, key int16, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Uint8)
- return ret
-}
-
-func (e *emitNative) invokeInt16Uint8(key int16, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Uint8(t typex.EventTime, key int16, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Uint16)
- return ret
-}
-
-func (e *emitNative) invokeInt16Uint16(key int16, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Uint16(t typex.EventTime, key int16, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Uint32)
- return ret
-}
-
-func (e *emitNative) invokeInt16Uint32(key int16, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Uint32(t typex.EventTime, key int16, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Uint64)
- return ret
-}
-
-func (e *emitNative) invokeInt16Uint64(key int16, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Uint64(t typex.EventTime, key int16, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Float32)
- return ret
-}
-
-func (e *emitNative) invokeInt16Float32(key int16, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Float32)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Float32(t typex.EventTime, key int16, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Float64)
- return ret
-}
-
-func (e *emitNative) invokeInt16Float64(key int16, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Float64)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Float64(t typex.EventTime, key int16, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_T(key int16, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_T(t typex.EventTime, key int16, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_U(key int16, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_U(t typex.EventTime, key int16, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_V(key int16, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_V(t typex.EventTime, key int16, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_W(key int16, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_W(t typex.EventTime, key int16, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_X(key int16, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_X(t typex.EventTime, key int16, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_Y(key int16, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_Y(t typex.EventTime, key int16, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt16Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt16Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeInt16Typex_Z(key int16, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt16Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt16Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETInt16Typex_Z(t typex.EventTime, key int16, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32)
- return ret
-}
-
-func (e *emitNative) invokeInt32(elm int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32)
- return ret
-}
-
-func (e *emitNative) invokeETInt32(t typex.EventTime, elm int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeInt32ByteSlice(key int32, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETInt32ByteSlice(t typex.EventTime, key int32, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Bool)
- return ret
-}
-
-func (e *emitNative) invokeInt32Bool(key int32, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Bool)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Bool(t typex.EventTime, key int32, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32String)
- return ret
-}
-
-func (e *emitNative) invokeInt32String(key int32, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32String)
- return ret
-}
-
-func (e *emitNative) invokeETInt32String(t typex.EventTime, key int32, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Int)
- return ret
-}
-
-func (e *emitNative) invokeInt32Int(key int32, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Int)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Int(t typex.EventTime, key int32, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Int8)
- return ret
-}
-
-func (e *emitNative) invokeInt32Int8(key int32, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Int8)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Int8(t typex.EventTime, key int32, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Int16)
- return ret
-}
-
-func (e *emitNative) invokeInt32Int16(key int32, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Int16)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Int16(t typex.EventTime, key int32, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Int32)
- return ret
-}
-
-func (e *emitNative) invokeInt32Int32(key int32, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Int32)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Int32(t typex.EventTime, key int32, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Int64)
- return ret
-}
-
-func (e *emitNative) invokeInt32Int64(key int32, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Int64)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Int64(t typex.EventTime, key int32, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Uint)
- return ret
-}
-
-func (e *emitNative) invokeInt32Uint(key int32, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Uint)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Uint(t typex.EventTime, key int32, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Uint8)
- return ret
-}
-
-func (e *emitNative) invokeInt32Uint8(key int32, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Uint8(t typex.EventTime, key int32, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Uint16)
- return ret
-}
-
-func (e *emitNative) invokeInt32Uint16(key int32, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Uint16(t typex.EventTime, key int32, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Uint32)
- return ret
-}
-
-func (e *emitNative) invokeInt32Uint32(key int32, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Uint32(t typex.EventTime, key int32, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Uint64)
- return ret
-}
-
-func (e *emitNative) invokeInt32Uint64(key int32, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Uint64(t typex.EventTime, key int32, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Float32)
- return ret
-}
-
-func (e *emitNative) invokeInt32Float32(key int32, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Float32)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Float32(t typex.EventTime, key int32, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Float64)
- return ret
-}
-
-func (e *emitNative) invokeInt32Float64(key int32, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Float64)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Float64(t typex.EventTime, key int32, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_T(key int32, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_T(t typex.EventTime, key int32, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_U(key int32, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_U(t typex.EventTime, key int32, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_V(key int32, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_V(t typex.EventTime, key int32, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_W(key int32, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_W(t typex.EventTime, key int32, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_X(key int32, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_X(t typex.EventTime, key int32, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_Y(key int32, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_Y(t typex.EventTime, key int32, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt32Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt32Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeInt32Typex_Z(key int32, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt32Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt32Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETInt32Typex_Z(t typex.EventTime, key int32, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64)
- return ret
-}
-
-func (e *emitNative) invokeInt64(elm int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64)
- return ret
-}
-
-func (e *emitNative) invokeETInt64(t typex.EventTime, elm int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeInt64ByteSlice(key int64, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETInt64ByteSlice(t typex.EventTime, key int64, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Bool)
- return ret
-}
-
-func (e *emitNative) invokeInt64Bool(key int64, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Bool)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Bool(t typex.EventTime, key int64, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64String)
- return ret
-}
-
-func (e *emitNative) invokeInt64String(key int64, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64String)
- return ret
-}
-
-func (e *emitNative) invokeETInt64String(t typex.EventTime, key int64, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Int)
- return ret
-}
-
-func (e *emitNative) invokeInt64Int(key int64, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Int)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Int(t typex.EventTime, key int64, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Int8)
- return ret
-}
-
-func (e *emitNative) invokeInt64Int8(key int64, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Int8)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Int8(t typex.EventTime, key int64, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Int16)
- return ret
-}
-
-func (e *emitNative) invokeInt64Int16(key int64, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Int16)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Int16(t typex.EventTime, key int64, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Int32)
- return ret
-}
-
-func (e *emitNative) invokeInt64Int32(key int64, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Int32)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Int32(t typex.EventTime, key int64, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Int64)
- return ret
-}
-
-func (e *emitNative) invokeInt64Int64(key int64, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Int64)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Int64(t typex.EventTime, key int64, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Uint)
- return ret
-}
-
-func (e *emitNative) invokeInt64Uint(key int64, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Uint)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Uint(t typex.EventTime, key int64, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Uint8)
- return ret
-}
-
-func (e *emitNative) invokeInt64Uint8(key int64, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Uint8(t typex.EventTime, key int64, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Uint16)
- return ret
-}
-
-func (e *emitNative) invokeInt64Uint16(key int64, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Uint16(t typex.EventTime, key int64, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Uint32)
- return ret
-}
-
-func (e *emitNative) invokeInt64Uint32(key int64, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Uint32(t typex.EventTime, key int64, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Uint64)
- return ret
-}
-
-func (e *emitNative) invokeInt64Uint64(key int64, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Uint64(t typex.EventTime, key int64, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Float32)
- return ret
-}
-
-func (e *emitNative) invokeInt64Float32(key int64, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Float32)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Float32(t typex.EventTime, key int64, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Float64)
- return ret
-}
-
-func (e *emitNative) invokeInt64Float64(key int64, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Float64)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Float64(t typex.EventTime, key int64, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_T(key int64, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_T(t typex.EventTime, key int64, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_U(key int64, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_U(t typex.EventTime, key int64, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_V(key int64, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_V(t typex.EventTime, key int64, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_W(key int64, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_W(t typex.EventTime, key int64, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_X(key int64, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_X(t typex.EventTime, key int64, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_Y(key int64, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_Y(t typex.EventTime, key int64, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerInt64Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeInt64Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeInt64Typex_Z(key int64, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETInt64Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETInt64Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETInt64Typex_Z(t typex.EventTime, key int64, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint)
- return ret
-}
-
-func (e *emitNative) invokeUint(elm uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint)
- return ret
-}
-
-func (e *emitNative) invokeETUint(t typex.EventTime, elm uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeUintByteSlice(key uint, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETUintByteSlice(t typex.EventTime, key uint, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintBool)
- return ret
-}
-
-func (e *emitNative) invokeUintBool(key uint, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintBool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintBool)
- return ret
-}
-
-func (e *emitNative) invokeETUintBool(t typex.EventTime, key uint, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintString)
- return ret
-}
-
-func (e *emitNative) invokeUintString(key uint, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintString(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintString)
- return ret
-}
-
-func (e *emitNative) invokeETUintString(t typex.EventTime, key uint, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintInt)
- return ret
-}
-
-func (e *emitNative) invokeUintInt(key uint, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintInt(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintInt)
- return ret
-}
-
-func (e *emitNative) invokeETUintInt(t typex.EventTime, key uint, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintInt8)
- return ret
-}
-
-func (e *emitNative) invokeUintInt8(key uint, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintInt8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintInt8)
- return ret
-}
-
-func (e *emitNative) invokeETUintInt8(t typex.EventTime, key uint, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintInt16)
- return ret
-}
-
-func (e *emitNative) invokeUintInt16(key uint, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintInt16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintInt16)
- return ret
-}
-
-func (e *emitNative) invokeETUintInt16(t typex.EventTime, key uint, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintInt32)
- return ret
-}
-
-func (e *emitNative) invokeUintInt32(key uint, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintInt32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintInt32)
- return ret
-}
-
-func (e *emitNative) invokeETUintInt32(t typex.EventTime, key uint, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintInt64)
- return ret
-}
-
-func (e *emitNative) invokeUintInt64(key uint, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintInt64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintInt64)
- return ret
-}
-
-func (e *emitNative) invokeETUintInt64(t typex.EventTime, key uint, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintUint)
- return ret
-}
-
-func (e *emitNative) invokeUintUint(key uint, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintUint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintUint)
- return ret
-}
-
-func (e *emitNative) invokeETUintUint(t typex.EventTime, key uint, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintUint8)
- return ret
-}
-
-func (e *emitNative) invokeUintUint8(key uint, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintUint8)
- return ret
-}
-
-func (e *emitNative) invokeETUintUint8(t typex.EventTime, key uint, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintUint16)
- return ret
-}
-
-func (e *emitNative) invokeUintUint16(key uint, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintUint16)
- return ret
-}
-
-func (e *emitNative) invokeETUintUint16(t typex.EventTime, key uint, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintUint32)
- return ret
-}
-
-func (e *emitNative) invokeUintUint32(key uint, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintUint32)
- return ret
-}
-
-func (e *emitNative) invokeETUintUint32(t typex.EventTime, key uint, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintUint64)
- return ret
-}
-
-func (e *emitNative) invokeUintUint64(key uint, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintUint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintUint64)
- return ret
-}
-
-func (e *emitNative) invokeETUintUint64(t typex.EventTime, key uint, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintFloat32)
- return ret
-}
-
-func (e *emitNative) invokeUintFloat32(key uint, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintFloat32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintFloat32)
- return ret
-}
-
-func (e *emitNative) invokeETUintFloat32(t typex.EventTime, key uint, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintFloat64)
- return ret
-}
-
-func (e *emitNative) invokeUintFloat64(key uint, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintFloat64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintFloat64)
- return ret
-}
-
-func (e *emitNative) invokeETUintFloat64(t typex.EventTime, key uint, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_T(key uint, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_T)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_T(t typex.EventTime, key uint, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_U(key uint, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_U)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_U(t typex.EventTime, key uint, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_V(key uint, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_V)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_V(t typex.EventTime, key uint, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_W(key uint, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_W)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_W(t typex.EventTime, key uint, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_X(key uint, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_X)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_X(t typex.EventTime, key uint, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_Y(key uint, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_Y(t typex.EventTime, key uint, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUintTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUintTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeUintTypex_Z(key uint, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUintTypex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUintTypex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETUintTypex_Z(t typex.EventTime, key uint, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8)
- return ret
-}
-
-func (e *emitNative) invokeUint8(elm uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8)
- return ret
-}
-
-func (e *emitNative) invokeETUint8(t typex.EventTime, elm uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeUint8ByteSlice(key uint8, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETUint8ByteSlice(t typex.EventTime, key uint8, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Bool)
- return ret
-}
-
-func (e *emitNative) invokeUint8Bool(key uint8, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Bool)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Bool(t typex.EventTime, key uint8, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8String)
- return ret
-}
-
-func (e *emitNative) invokeUint8String(key uint8, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8String)
- return ret
-}
-
-func (e *emitNative) invokeETUint8String(t typex.EventTime, key uint8, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Int)
- return ret
-}
-
-func (e *emitNative) invokeUint8Int(key uint8, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Int)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Int(t typex.EventTime, key uint8, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Int8)
- return ret
-}
-
-func (e *emitNative) invokeUint8Int8(key uint8, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Int8)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Int8(t typex.EventTime, key uint8, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Int16)
- return ret
-}
-
-func (e *emitNative) invokeUint8Int16(key uint8, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Int16)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Int16(t typex.EventTime, key uint8, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Int32)
- return ret
-}
-
-func (e *emitNative) invokeUint8Int32(key uint8, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Int32)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Int32(t typex.EventTime, key uint8, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Int64)
- return ret
-}
-
-func (e *emitNative) invokeUint8Int64(key uint8, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Int64)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Int64(t typex.EventTime, key uint8, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Uint)
- return ret
-}
-
-func (e *emitNative) invokeUint8Uint(key uint8, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Uint)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Uint(t typex.EventTime, key uint8, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Uint8)
- return ret
-}
-
-func (e *emitNative) invokeUint8Uint8(key uint8, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Uint8(t typex.EventTime, key uint8, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Uint16)
- return ret
-}
-
-func (e *emitNative) invokeUint8Uint16(key uint8, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Uint16(t typex.EventTime, key uint8, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Uint32)
- return ret
-}
-
-func (e *emitNative) invokeUint8Uint32(key uint8, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Uint32(t typex.EventTime, key uint8, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Uint64)
- return ret
-}
-
-func (e *emitNative) invokeUint8Uint64(key uint8, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Uint64(t typex.EventTime, key uint8, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Float32)
- return ret
-}
-
-func (e *emitNative) invokeUint8Float32(key uint8, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Float32)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Float32(t typex.EventTime, key uint8, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Float64)
- return ret
-}
-
-func (e *emitNative) invokeUint8Float64(key uint8, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Float64)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Float64(t typex.EventTime, key uint8, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_T(key uint8, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_T(t typex.EventTime, key uint8, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_U(key uint8, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_U(t typex.EventTime, key uint8, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_V(key uint8, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_V(t typex.EventTime, key uint8, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_W(key uint8, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_W(t typex.EventTime, key uint8, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_X(key uint8, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_X(t typex.EventTime, key uint8, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_Y(key uint8, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_Y(t typex.EventTime, key uint8, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint8Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint8Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeUint8Typex_Z(key uint8, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint8Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint8Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETUint8Typex_Z(t typex.EventTime, key uint8, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16)
- return ret
-}
-
-func (e *emitNative) invokeUint16(elm uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16)
- return ret
-}
-
-func (e *emitNative) invokeETUint16(t typex.EventTime, elm uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeUint16ByteSlice(key uint16, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETUint16ByteSlice(t typex.EventTime, key uint16, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Bool)
- return ret
-}
-
-func (e *emitNative) invokeUint16Bool(key uint16, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Bool)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Bool(t typex.EventTime, key uint16, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16String)
- return ret
-}
-
-func (e *emitNative) invokeUint16String(key uint16, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16String)
- return ret
-}
-
-func (e *emitNative) invokeETUint16String(t typex.EventTime, key uint16, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Int)
- return ret
-}
-
-func (e *emitNative) invokeUint16Int(key uint16, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Int)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Int(t typex.EventTime, key uint16, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Int8)
- return ret
-}
-
-func (e *emitNative) invokeUint16Int8(key uint16, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Int8)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Int8(t typex.EventTime, key uint16, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Int16)
- return ret
-}
-
-func (e *emitNative) invokeUint16Int16(key uint16, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Int16)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Int16(t typex.EventTime, key uint16, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Int32)
- return ret
-}
-
-func (e *emitNative) invokeUint16Int32(key uint16, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Int32)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Int32(t typex.EventTime, key uint16, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Int64)
- return ret
-}
-
-func (e *emitNative) invokeUint16Int64(key uint16, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Int64)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Int64(t typex.EventTime, key uint16, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Uint)
- return ret
-}
-
-func (e *emitNative) invokeUint16Uint(key uint16, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Uint)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Uint(t typex.EventTime, key uint16, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Uint8)
- return ret
-}
-
-func (e *emitNative) invokeUint16Uint8(key uint16, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Uint8(t typex.EventTime, key uint16, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Uint16)
- return ret
-}
-
-func (e *emitNative) invokeUint16Uint16(key uint16, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Uint16(t typex.EventTime, key uint16, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Uint32)
- return ret
-}
-
-func (e *emitNative) invokeUint16Uint32(key uint16, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Uint32(t typex.EventTime, key uint16, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Uint64)
- return ret
-}
-
-func (e *emitNative) invokeUint16Uint64(key uint16, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Uint64(t typex.EventTime, key uint16, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Float32)
- return ret
-}
-
-func (e *emitNative) invokeUint16Float32(key uint16, val float32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Float32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Float32)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Float32(t typex.EventTime, key uint16, val float32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Float64)
- return ret
-}
-
-func (e *emitNative) invokeUint16Float64(key uint16, val float64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Float64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Float64)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Float64(t typex.EventTime, key uint16, val float64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_T(key uint16, val typex.T) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_T(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_T)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_T(t typex.EventTime, key uint16, val typex.T) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_U(key uint16, val typex.U) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_U(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_U)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_U(t typex.EventTime, key uint16, val typex.U) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_V(key uint16, val typex.V) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_V(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_V)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_V(t typex.EventTime, key uint16, val typex.V) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_W(key uint16, val typex.W) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_W(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_W)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_W(t typex.EventTime, key uint16, val typex.W) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_X(key uint16, val typex.X) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_X(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_X)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_X(t typex.EventTime, key uint16, val typex.X) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_Y(key uint16, val typex.Y) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_Y(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_Y)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_Y(t typex.EventTime, key uint16, val typex.Y) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint16Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint16Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeUint16Typex_Z(key uint16, val typex.Z) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint16Typex_Z(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint16Typex_Z)
- return ret
-}
-
-func (e *emitNative) invokeETUint16Typex_Z(t typex.EventTime, key uint16, val typex.Z) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32)
- return ret
-}
-
-func (e *emitNative) invokeUint32(elm uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32)
- return ret
-}
-
-func (e *emitNative) invokeETUint32(t typex.EventTime, elm uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(elm)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeUint32ByteSlice(key uint32, val []byte) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32ByteSlice(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32ByteSlice)
- return ret
-}
-
-func (e *emitNative) invokeETUint32ByteSlice(t typex.EventTime, key uint32, val []byte) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Bool)
- return ret
-}
-
-func (e *emitNative) invokeUint32Bool(key uint32, val bool) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Bool(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Bool)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Bool(t typex.EventTime, key uint32, val bool) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32String)
- return ret
-}
-
-func (e *emitNative) invokeUint32String(key uint32, val string) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32String(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32String)
- return ret
-}
-
-func (e *emitNative) invokeETUint32String(t typex.EventTime, key uint32, val string) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Int)
- return ret
-}
-
-func (e *emitNative) invokeUint32Int(key uint32, val int) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Int(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Int)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Int(t typex.EventTime, key uint32, val int) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Int8)
- return ret
-}
-
-func (e *emitNative) invokeUint32Int8(key uint32, val int8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Int8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Int8)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Int8(t typex.EventTime, key uint32, val int8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Int16)
- return ret
-}
-
-func (e *emitNative) invokeUint32Int16(key uint32, val int16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Int16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Int16)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Int16(t typex.EventTime, key uint32, val int16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Int32)
- return ret
-}
-
-func (e *emitNative) invokeUint32Int32(key uint32, val int32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Int32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Int32)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Int32(t typex.EventTime, key uint32, val int32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Int64)
- return ret
-}
-
-func (e *emitNative) invokeUint32Int64(key uint32, val int64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Int64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Int64)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Int64(t typex.EventTime, key uint32, val int64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Uint)
- return ret
-}
-
-func (e *emitNative) invokeUint32Uint(key uint32, val uint) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Uint(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Uint)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Uint(t typex.EventTime, key uint32, val uint) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Uint8)
- return ret
-}
-
-func (e *emitNative) invokeUint32Uint8(key uint32, val uint8) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Uint8(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Uint8)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Uint8(t typex.EventTime, key uint32, val uint8) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Uint16)
- return ret
-}
-
-func (e *emitNative) invokeUint32Uint16(key uint32, val uint16) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Uint16(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Uint16)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Uint16(t typex.EventTime, key uint32, val uint16) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Uint32)
- return ret
-}
-
-func (e *emitNative) invokeUint32Uint32(key uint32, val uint32) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Uint32(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Uint32)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Uint32(t typex.EventTime, key uint32, val uint32) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerUint32Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeUint32Uint64)
- return ret
-}
-
-func (e *emitNative) invokeUint32Uint64(key uint32, val uint64) {
- value := FullValue{Timestamp: e.et, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
- panic(err)
- }
-}
-
-func emitMakerETUint32Uint64(n ElementProcessor) ReusableEmitter {
- ret := &emitNative{n: n}
- ret.fn = reflect.ValueOf(ret.invokeETUint32Uint64)
- return ret
-}
-
-func (e *emitNative) invokeETUint32Uint64(t typex.EventTime, key uint32, val uint64) {
- value := FullValue{Timestamp: t, Elm: reflect.ValueOf(key), Elm2: reflect.ValueOf(val)}
- if err := e.n.ProcessElement(e.ctx, value); err != nil {
... 38952 lines suppressed ...
--
To stop receiving notification emails like this one, please contact
"commits@beam.apache.org" <co...@beam.apache.org>.
[beam] 03/04: CR: fix DynFn comments
Posted by lc...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
lcwik pushed a commit to branch go-sdk
in repository https://gitbox.apache.org/repos/asf/beam.git
commit 8a9d916be7b9945e9b7576dbf52f0a80b3249cbd
Author: Henning Rohde <he...@google.com>
AuthorDate: Thu Jan 18 19:04:21 2018 -0800
CR: fix DynFn comments
---
sdks/go/pkg/beam/core/graph/fn.go | 4 +++-
sdks/go/pkg/beam/core/runtime/exec/fn.go | 4 ----
2 files changed, 3 insertions(+), 5 deletions(-)
diff --git a/sdks/go/pkg/beam/core/graph/fn.go b/sdks/go/pkg/beam/core/graph/fn.go
index 032227f..6ed05a1 100644
--- a/sdks/go/pkg/beam/core/graph/fn.go
+++ b/sdks/go/pkg/beam/core/graph/fn.go
@@ -61,7 +61,9 @@ type DynFn struct {
Name string
// T is the type of the generated function
T reflect.Type
- // Data holds the data for the generator. This data is trivially serializable.
+ // Data holds the data, if any, for the generator. Each function
+ // generator typically needs some configuration data, which is
+ // required by the DynFn to be encoded.
Data []byte
// Gen is the function generator. The function generator itself must be a
// function with a unique symbol.
diff --git a/sdks/go/pkg/beam/core/runtime/exec/fn.go b/sdks/go/pkg/beam/core/runtime/exec/fn.go
index 49a9bac..9ad422f 100644
--- a/sdks/go/pkg/beam/core/runtime/exec/fn.go
+++ b/sdks/go/pkg/beam/core/runtime/exec/fn.go
@@ -26,10 +26,6 @@ import (
"github.com/apache/beam/sdks/go/pkg/beam/core/util/reflectx"
)
-// NOTE(herohde) 12/11/2017: the below helpers are ripe for type-specialization,
-// if the reflection overhead here turns out to be significant. It would
-// be nice to be able to quantify any potential improvements first, however.
-
// MainInput is the main input and is unfolded in the invocation, if present.
type MainInput struct {
Key FullValue
--
To stop receiving notification emails like this one, please contact
"commits@beam.apache.org" <co...@beam.apache.org>.