You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@beam.apache.org by lo...@apache.org on 2022/05/13 02:12:59 UTC
[beam] branch master updated: [BEAM-14347] Add function for simple function registration (#17650)
This is an automated email from the ASF dual-hosted git repository.
lostluck pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/beam.git
The following commit(s) were added to refs/heads/master by this push:
new 969f5b85acb [BEAM-14347] Add function for simple function registration (#17650)
969f5b85acb is described below
commit 969f5b85acbfc60c28e34048f6a23660a382dd71
Author: Danny McCormick <da...@google.com>
AuthorDate: Thu May 12 22:12:53 2022 -0400
[BEAM-14347] Add function for simple function registration (#17650)
---
sdks/go/pkg/beam/register/register.go | 923 ++++++++++++++++++++++++++---
sdks/go/pkg/beam/register/register.tmpl | 14 +-
sdks/go/pkg/beam/register/register_test.go | 160 +++--
3 files changed, 995 insertions(+), 102 deletions(-)
diff --git a/sdks/go/pkg/beam/register/register.go b/sdks/go/pkg/beam/register/register.go
index f8f6895f361..6cf4cfa9efc 100644
--- a/sdks/go/pkg/beam/register/register.go
+++ b/sdks/go/pkg/beam/register/register.go
@@ -2250,12 +2250,23 @@ func registerDoFn0x0StructWrappersAndFuncs(doFn genericDoFn0x0) {
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x0 registers your DoFn to optimize execution at runtime.
+// DoFn0x0 registers your structural DoFn to optimize execution at runtime.
func DoFn0x0(doFn genericDoFn0x0) {
registerDoFnTypes(doFn)
registerDoFn0x0StructWrappersAndFuncs(doFn)
}
+// Function0x0 registers your functional DoFn to optimize execution at runtime.
+func Function0x0(doFn func()) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func())
+ return &caller0x0{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func())(nil)).Elem(), caller)
+}
+
type genericDoFn1x0[I0 any] interface {
ProcessElement(i0 I0)
}
@@ -2320,13 +2331,25 @@ func registerDoFn1x0StructWrappersAndFuncs[I0 any](doFn genericDoFn1x0[I0]) {
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x0[I0 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x0[I0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x0[I0 any](doFn genericDoFn1x0[I0]) {
registerDoFnTypes(doFn)
registerDoFn1x0StructWrappersAndFuncs[I0](doFn)
}
+// Function1x0[I0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x0[I0 any](doFn func(I0)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0))
+ return &caller1x0[I0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0))(nil)).Elem(), caller)
+}
+
type genericDoFn2x0[I0, I1 any] interface {
ProcessElement(i0 I0, i1 I1)
}
@@ -2391,13 +2414,25 @@ func registerDoFn2x0StructWrappersAndFuncs[I0, I1 any](doFn genericDoFn2x0[I0, I
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x0[I0, I1 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x0[I0, I1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x0[I0, I1 any](doFn genericDoFn2x0[I0, I1]) {
registerDoFnTypes(doFn)
registerDoFn2x0StructWrappersAndFuncs[I0, I1](doFn)
}
+// Function2x0[I0, I1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x0[I0, I1 any](doFn func(I0, I1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1))
+ return &caller2x0[I0, I1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1))(nil)).Elem(), caller)
+}
+
type genericDoFn3x0[I0, I1, I2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2)
}
@@ -2462,13 +2497,25 @@ func registerDoFn3x0StructWrappersAndFuncs[I0, I1, I2 any](doFn genericDoFn3x0[I
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x0[I0, I1, I2 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x0[I0, I1, I2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x0[I0, I1, I2 any](doFn genericDoFn3x0[I0, I1, I2]) {
registerDoFnTypes(doFn)
registerDoFn3x0StructWrappersAndFuncs[I0, I1, I2](doFn)
}
+// Function3x0[I0, I1, I2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x0[I0, I1, I2 any](doFn func(I0, I1, I2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2))
+ return &caller3x0[I0, I1, I2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2))(nil)).Elem(), caller)
+}
+
type genericDoFn4x0[I0, I1, I2, I3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3)
}
@@ -2533,13 +2580,25 @@ func registerDoFn4x0StructWrappersAndFuncs[I0, I1, I2, I3 any](doFn genericDoFn4
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x0[I0, I1, I2, I3 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x0[I0, I1, I2, I3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x0[I0, I1, I2, I3 any](doFn genericDoFn4x0[I0, I1, I2, I3]) {
registerDoFnTypes(doFn)
registerDoFn4x0StructWrappersAndFuncs[I0, I1, I2, I3](doFn)
}
+// Function4x0[I0, I1, I2, I3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x0[I0, I1, I2, I3 any](doFn func(I0, I1, I2, I3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3))
+ return &caller4x0[I0, I1, I2, I3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3))(nil)).Elem(), caller)
+}
+
type genericDoFn5x0[I0, I1, I2, I3, I4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4)
}
@@ -2604,13 +2663,25 @@ func registerDoFn5x0StructWrappersAndFuncs[I0, I1, I2, I3, I4 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x0[I0, I1, I2, I3, I4 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x0[I0, I1, I2, I3, I4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x0[I0, I1, I2, I3, I4 any](doFn genericDoFn5x0[I0, I1, I2, I3, I4]) {
registerDoFnTypes(doFn)
registerDoFn5x0StructWrappersAndFuncs[I0, I1, I2, I3, I4](doFn)
}
+// Function5x0[I0, I1, I2, I3, I4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x0[I0, I1, I2, I3, I4 any](doFn func(I0, I1, I2, I3, I4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4))
+ return &caller5x0[I0, I1, I2, I3, I4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4))(nil)).Elem(), caller)
+}
+
type genericDoFn6x0[I0, I1, I2, I3, I4, I5 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5)
}
@@ -2675,13 +2746,25 @@ func registerDoFn6x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x0[I0, I1, I2, I3, I4, I5 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x0[I0, I1, I2, I3, I4, I5 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x0[I0, I1, I2, I3, I4, I5 any](doFn genericDoFn6x0[I0, I1, I2, I3, I4, I5]) {
registerDoFnTypes(doFn)
registerDoFn6x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5](doFn)
}
+// Function6x0[I0, I1, I2, I3, I4, I5 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x0[I0, I1, I2, I3, I4, I5 any](doFn func(I0, I1, I2, I3, I4, I5)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5))
+ return &caller6x0[I0, I1, I2, I3, I4, I5]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5))(nil)).Elem(), caller)
+}
+
type genericDoFn7x0[I0, I1, I2, I3, I4, I5, I6 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6)
}
@@ -2746,13 +2829,25 @@ func registerDoFn7x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x0[I0, I1, I2, I3, I4, I5, I6 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x0[I0, I1, I2, I3, I4, I5, I6 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x0[I0, I1, I2, I3, I4, I5, I6 any](doFn genericDoFn7x0[I0, I1, I2, I3, I4, I5, I6]) {
registerDoFnTypes(doFn)
registerDoFn7x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6](doFn)
}
+// Function7x0[I0, I1, I2, I3, I4, I5, I6 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x0[I0, I1, I2, I3, I4, I5, I6 any](doFn func(I0, I1, I2, I3, I4, I5, I6)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6))
+ return &caller7x0[I0, I1, I2, I3, I4, I5, I6]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6))(nil)).Elem(), caller)
+}
+
type genericDoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7)
}
@@ -2817,13 +2912,25 @@ func registerDoFn8x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7 any](doFn genericDoFn8x0[I0, I1, I2, I3, I4, I5, I6, I7]) {
registerDoFnTypes(doFn)
registerDoFn8x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7](doFn)
}
+// Function8x0[I0, I1, I2, I3, I4, I5, I6, I7 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x0[I0, I1, I2, I3, I4, I5, I6, I7 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7))
+ return &caller8x0[I0, I1, I2, I3, I4, I5, I6, I7]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7))(nil)).Elem(), caller)
+}
+
type genericDoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8)
}
@@ -2888,13 +2995,25 @@ func registerDoFn9x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any](doFn genericDoFn9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8]) {
registerDoFnTypes(doFn)
registerDoFn9x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8](doFn)
}
+// Function9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8))
+ return &caller9x0[I0, I1, I2, I3, I4, I5, I6, I7, I8]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8))(nil)).Elem(), caller)
+}
+
type genericDoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9)
}
@@ -2959,13 +3078,25 @@ func registerDoFn10x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any](doFn genericDoFn10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9]) {
registerDoFnTypes(doFn)
registerDoFn10x0StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9](doFn)
}
+// Function10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9))
+ return &caller10x0[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9))(nil)).Elem(), caller)
+}
+
type genericDoFn0x1[R0 any] interface {
ProcessElement() R0
}
@@ -3030,13 +3161,25 @@ func registerDoFn0x1StructWrappersAndFuncs[R0 any](doFn genericDoFn0x1[R0]) {
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x1[R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn0x1[R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn0x1[R0 any](doFn genericDoFn0x1[R0]) {
registerDoFnTypes(doFn)
registerDoFn0x1StructWrappersAndFuncs[R0](doFn)
}
+// Function0x1[R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function0x1[R0 any](doFn func() R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func() R0)
+ return &caller0x1[R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func() R0)(nil)).Elem(), caller)
+}
+
type genericDoFn1x1[I0, R0 any] interface {
ProcessElement(i0 I0) R0
}
@@ -3101,13 +3244,25 @@ func registerDoFn1x1StructWrappersAndFuncs[I0, R0 any](doFn genericDoFn1x1[I0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x1[I0, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x1[I0, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x1[I0, R0 any](doFn genericDoFn1x1[I0, R0]) {
registerDoFnTypes(doFn)
registerDoFn1x1StructWrappersAndFuncs[I0, R0](doFn)
}
+// Function1x1[I0, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x1[I0, R0 any](doFn func(I0) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0) R0)
+ return &caller1x1[I0, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn2x1[I0, I1, R0 any] interface {
ProcessElement(i0 I0, i1 I1) R0
}
@@ -3172,13 +3327,25 @@ func registerDoFn2x1StructWrappersAndFuncs[I0, I1, R0 any](doFn genericDoFn2x1[I
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x1[I0, I1, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x1[I0, I1, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x1[I0, I1, R0 any](doFn genericDoFn2x1[I0, I1, R0]) {
registerDoFnTypes(doFn)
registerDoFn2x1StructWrappersAndFuncs[I0, I1, R0](doFn)
}
+// Function2x1[I0, I1, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x1[I0, I1, R0 any](doFn func(I0, I1) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1) R0)
+ return &caller2x1[I0, I1, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn3x1[I0, I1, I2, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2) R0
}
@@ -3243,13 +3410,25 @@ func registerDoFn3x1StructWrappersAndFuncs[I0, I1, I2, R0 any](doFn genericDoFn3
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x1[I0, I1, I2, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x1[I0, I1, I2, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x1[I0, I1, I2, R0 any](doFn genericDoFn3x1[I0, I1, I2, R0]) {
registerDoFnTypes(doFn)
registerDoFn3x1StructWrappersAndFuncs[I0, I1, I2, R0](doFn)
}
+// Function3x1[I0, I1, I2, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x1[I0, I1, I2, R0 any](doFn func(I0, I1, I2) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2) R0)
+ return &caller3x1[I0, I1, I2, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn4x1[I0, I1, I2, I3, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3) R0
}
@@ -3314,13 +3493,25 @@ func registerDoFn4x1StructWrappersAndFuncs[I0, I1, I2, I3, R0 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x1[I0, I1, I2, I3, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x1[I0, I1, I2, I3, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x1[I0, I1, I2, I3, R0 any](doFn genericDoFn4x1[I0, I1, I2, I3, R0]) {
registerDoFnTypes(doFn)
registerDoFn4x1StructWrappersAndFuncs[I0, I1, I2, I3, R0](doFn)
}
+// Function4x1[I0, I1, I2, I3, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x1[I0, I1, I2, I3, R0 any](doFn func(I0, I1, I2, I3) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3) R0)
+ return &caller4x1[I0, I1, I2, I3, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn5x1[I0, I1, I2, I3, I4, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4) R0
}
@@ -3385,13 +3576,25 @@ func registerDoFn5x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x1[I0, I1, I2, I3, I4, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x1[I0, I1, I2, I3, I4, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x1[I0, I1, I2, I3, I4, R0 any](doFn genericDoFn5x1[I0, I1, I2, I3, I4, R0]) {
registerDoFnTypes(doFn)
registerDoFn5x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0](doFn)
}
+// Function5x1[I0, I1, I2, I3, I4, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x1[I0, I1, I2, I3, I4, R0 any](doFn func(I0, I1, I2, I3, I4) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4) R0)
+ return &caller5x1[I0, I1, I2, I3, I4, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn6x1[I0, I1, I2, I3, I4, I5, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5) R0
}
@@ -3456,13 +3659,25 @@ func registerDoFn6x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x1[I0, I1, I2, I3, I4, I5, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x1[I0, I1, I2, I3, I4, I5, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x1[I0, I1, I2, I3, I4, I5, R0 any](doFn genericDoFn6x1[I0, I1, I2, I3, I4, I5, R0]) {
registerDoFnTypes(doFn)
registerDoFn6x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0](doFn)
}
+// Function6x1[I0, I1, I2, I3, I4, I5, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x1[I0, I1, I2, I3, I4, I5, R0 any](doFn func(I0, I1, I2, I3, I4, I5) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5) R0)
+ return &caller6x1[I0, I1, I2, I3, I4, I5, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6) R0
}
@@ -3527,13 +3742,25 @@ func registerDoFn7x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0 any](doFn genericDoFn7x1[I0, I1, I2, I3, I4, I5, I6, R0]) {
registerDoFnTypes(doFn)
registerDoFn7x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0](doFn)
}
+// Function7x1[I0, I1, I2, I3, I4, I5, I6, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x1[I0, I1, I2, I3, I4, I5, I6, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6) R0)
+ return &caller7x1[I0, I1, I2, I3, I4, I5, I6, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7) R0
}
@@ -3598,13 +3825,25 @@ func registerDoFn8x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any](doFn genericDoFn8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0]) {
registerDoFnTypes(doFn)
registerDoFn8x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0](doFn)
}
+// Function8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7) R0)
+ return &caller8x1[I0, I1, I2, I3, I4, I5, I6, I7, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8) R0
}
@@ -3669,13 +3908,25 @@ func registerDoFn9x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any](doFn genericDoFn9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0]) {
registerDoFnTypes(doFn)
registerDoFn9x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0](doFn)
}
+// Function9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8) R0)
+ return &caller9x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9) R0
}
@@ -3740,13 +3991,25 @@ func registerDoFn10x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any](doFn genericDoFn10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0]) {
registerDoFnTypes(doFn)
registerDoFn10x1StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0](doFn)
}
+// Function10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) R0) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) R0)
+ return &caller10x1[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) R0)(nil)).Elem(), caller)
+}
+
type genericDoFn0x2[R0, R1 any] interface {
ProcessElement() (R0, R1)
}
@@ -3811,13 +4074,25 @@ func registerDoFn0x2StructWrappersAndFuncs[R0, R1 any](doFn genericDoFn0x2[R0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x2[R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn0x2[R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn0x2[R0, R1 any](doFn genericDoFn0x2[R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn0x2StructWrappersAndFuncs[R0, R1](doFn)
}
+// Function0x2[R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function0x2[R0, R1 any](doFn func() (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func() (R0, R1))
+ return &caller0x2[R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func() (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn1x2[I0, R0, R1 any] interface {
ProcessElement(i0 I0) (R0, R1)
}
@@ -3882,13 +4157,25 @@ func registerDoFn1x2StructWrappersAndFuncs[I0, R0, R1 any](doFn genericDoFn1x2[I
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x2[I0, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x2[I0, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x2[I0, R0, R1 any](doFn genericDoFn1x2[I0, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn1x2StructWrappersAndFuncs[I0, R0, R1](doFn)
}
+// Function1x2[I0, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x2[I0, R0, R1 any](doFn func(I0) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0) (R0, R1))
+ return &caller1x2[I0, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn2x2[I0, I1, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1) (R0, R1)
}
@@ -3953,13 +4240,25 @@ func registerDoFn2x2StructWrappersAndFuncs[I0, I1, R0, R1 any](doFn genericDoFn2
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x2[I0, I1, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x2[I0, I1, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x2[I0, I1, R0, R1 any](doFn genericDoFn2x2[I0, I1, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn2x2StructWrappersAndFuncs[I0, I1, R0, R1](doFn)
}
+// Function2x2[I0, I1, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x2[I0, I1, R0, R1 any](doFn func(I0, I1) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1) (R0, R1))
+ return &caller2x2[I0, I1, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn3x2[I0, I1, I2, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2) (R0, R1)
}
@@ -4024,13 +4323,25 @@ func registerDoFn3x2StructWrappersAndFuncs[I0, I1, I2, R0, R1 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x2[I0, I1, I2, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x2[I0, I1, I2, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x2[I0, I1, I2, R0, R1 any](doFn genericDoFn3x2[I0, I1, I2, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn3x2StructWrappersAndFuncs[I0, I1, I2, R0, R1](doFn)
}
+// Function3x2[I0, I1, I2, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x2[I0, I1, I2, R0, R1 any](doFn func(I0, I1, I2) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2) (R0, R1))
+ return &caller3x2[I0, I1, I2, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn4x2[I0, I1, I2, I3, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3) (R0, R1)
}
@@ -4095,13 +4406,25 @@ func registerDoFn4x2StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x2[I0, I1, I2, I3, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x2[I0, I1, I2, I3, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x2[I0, I1, I2, I3, R0, R1 any](doFn genericDoFn4x2[I0, I1, I2, I3, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn4x2StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1](doFn)
}
+// Function4x2[I0, I1, I2, I3, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x2[I0, I1, I2, I3, R0, R1 any](doFn func(I0, I1, I2, I3) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3) (R0, R1))
+ return &caller4x2[I0, I1, I2, I3, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn5x2[I0, I1, I2, I3, I4, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4) (R0, R1)
}
@@ -4166,13 +4489,25 @@ func registerDoFn5x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x2[I0, I1, I2, I3, I4, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x2[I0, I1, I2, I3, I4, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x2[I0, I1, I2, I3, I4, R0, R1 any](doFn genericDoFn5x2[I0, I1, I2, I3, I4, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn5x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1](doFn)
}
+// Function5x2[I0, I1, I2, I3, I4, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x2[I0, I1, I2, I3, I4, R0, R1 any](doFn func(I0, I1, I2, I3, I4) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4) (R0, R1))
+ return &caller5x2[I0, I1, I2, I3, I4, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5) (R0, R1)
}
@@ -4237,13 +4572,25 @@ func registerDoFn6x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1 any](doFn genericDoFn6x2[I0, I1, I2, I3, I4, I5, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn6x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1](doFn)
}
+// Function6x2[I0, I1, I2, I3, I4, I5, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x2[I0, I1, I2, I3, I4, I5, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5) (R0, R1))
+ return &caller6x2[I0, I1, I2, I3, I4, I5, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6) (R0, R1)
}
@@ -4308,13 +4655,25 @@ func registerDoFn7x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any](doFn genericDoFn7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn7x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1](doFn)
}
+// Function7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6) (R0, R1))
+ return &caller7x2[I0, I1, I2, I3, I4, I5, I6, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7) (R0, R1)
}
@@ -4379,13 +4738,25 @@ func registerDoFn8x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any](doFn genericDoFn8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn8x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1](doFn)
}
+// Function8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1))
+ return &caller8x2[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8) (R0, R1)
}
@@ -4450,13 +4821,25 @@ func registerDoFn9x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any](doFn genericDoFn9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn9x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1](doFn)
}
+// Function9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1))
+ return &caller9x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9) (R0, R1)
}
@@ -4521,13 +4904,25 @@ func registerDoFn10x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any](doFn genericDoFn10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1]) {
registerDoFnTypes(doFn)
registerDoFn10x2StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1](doFn)
}
+// Function10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1))
+ return &caller10x2[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1))(nil)).Elem(), caller)
+}
+
type genericDoFn0x3[R0, R1, R2 any] interface {
ProcessElement() (R0, R1, R2)
}
@@ -4592,13 +4987,25 @@ func registerDoFn0x3StructWrappersAndFuncs[R0, R1, R2 any](doFn genericDoFn0x3[R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x3[R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn0x3[R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn0x3[R0, R1, R2 any](doFn genericDoFn0x3[R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn0x3StructWrappersAndFuncs[R0, R1, R2](doFn)
}
+// Function0x3[R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function0x3[R0, R1, R2 any](doFn func() (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func() (R0, R1, R2))
+ return &caller0x3[R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func() (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn1x3[I0, R0, R1, R2 any] interface {
ProcessElement(i0 I0) (R0, R1, R2)
}
@@ -4663,13 +5070,25 @@ func registerDoFn1x3StructWrappersAndFuncs[I0, R0, R1, R2 any](doFn genericDoFn1
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x3[I0, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x3[I0, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x3[I0, R0, R1, R2 any](doFn genericDoFn1x3[I0, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn1x3StructWrappersAndFuncs[I0, R0, R1, R2](doFn)
}
+// Function1x3[I0, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x3[I0, R0, R1, R2 any](doFn func(I0) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0) (R0, R1, R2))
+ return &caller1x3[I0, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn2x3[I0, I1, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1) (R0, R1, R2)
}
@@ -4734,13 +5153,25 @@ func registerDoFn2x3StructWrappersAndFuncs[I0, I1, R0, R1, R2 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x3[I0, I1, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x3[I0, I1, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x3[I0, I1, R0, R1, R2 any](doFn genericDoFn2x3[I0, I1, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn2x3StructWrappersAndFuncs[I0, I1, R0, R1, R2](doFn)
}
+// Function2x3[I0, I1, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x3[I0, I1, R0, R1, R2 any](doFn func(I0, I1) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1) (R0, R1, R2))
+ return &caller2x3[I0, I1, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn3x3[I0, I1, I2, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2) (R0, R1, R2)
}
@@ -4805,13 +5236,25 @@ func registerDoFn3x3StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x3[I0, I1, I2, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x3[I0, I1, I2, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x3[I0, I1, I2, R0, R1, R2 any](doFn genericDoFn3x3[I0, I1, I2, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn3x3StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2](doFn)
}
+// Function3x3[I0, I1, I2, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x3[I0, I1, I2, R0, R1, R2 any](doFn func(I0, I1, I2) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2) (R0, R1, R2))
+ return &caller3x3[I0, I1, I2, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn4x3[I0, I1, I2, I3, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3) (R0, R1, R2)
}
@@ -4876,13 +5319,25 @@ func registerDoFn4x3StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x3[I0, I1, I2, I3, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x3[I0, I1, I2, I3, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x3[I0, I1, I2, I3, R0, R1, R2 any](doFn genericDoFn4x3[I0, I1, I2, I3, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn4x3StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2](doFn)
}
+// Function4x3[I0, I1, I2, I3, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x3[I0, I1, I2, I3, R0, R1, R2 any](doFn func(I0, I1, I2, I3) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3) (R0, R1, R2))
+ return &caller4x3[I0, I1, I2, I3, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4) (R0, R1, R2)
}
@@ -4947,13 +5402,25 @@ func registerDoFn5x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2 any](doFn genericDoFn5x3[I0, I1, I2, I3, I4, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn5x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2](doFn)
}
+// Function5x3[I0, I1, I2, I3, I4, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x3[I0, I1, I2, I3, I4, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4) (R0, R1, R2))
+ return &caller5x3[I0, I1, I2, I3, I4, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5) (R0, R1, R2)
}
@@ -5018,13 +5485,25 @@ func registerDoFn6x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any](doFn genericDoFn6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn6x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2](doFn)
}
+// Function6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5) (R0, R1, R2))
+ return &caller6x3[I0, I1, I2, I3, I4, I5, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6) (R0, R1, R2)
}
@@ -5089,13 +5568,25 @@ func registerDoFn7x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any](doFn genericDoFn7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn7x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2](doFn)
}
+// Function7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2))
+ return &caller7x3[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7) (R0, R1, R2)
}
@@ -5160,13 +5651,25 @@ func registerDoFn8x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any](doFn genericDoFn8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn8x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2](doFn)
}
+// Function8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2))
+ return &caller8x3[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8) (R0, R1, R2)
}
@@ -5231,13 +5734,25 @@ func registerDoFn9x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any](doFn genericDoFn9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn9x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2](doFn)
}
+// Function9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2))
+ return &caller9x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9) (R0, R1, R2)
}
@@ -5302,13 +5817,25 @@ func registerDoFn10x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any](doFn genericDoFn10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2]) {
registerDoFnTypes(doFn)
registerDoFn10x3StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2](doFn)
}
+// Function10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2))
+ return &caller10x3[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2))(nil)).Elem(), caller)
+}
+
type genericDoFn0x4[R0, R1, R2, R3 any] interface {
ProcessElement() (R0, R1, R2, R3)
}
@@ -5373,13 +5900,25 @@ func registerDoFn0x4StructWrappersAndFuncs[R0, R1, R2, R3 any](doFn genericDoFn0
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x4[R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn0x4[R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn0x4[R0, R1, R2, R3 any](doFn genericDoFn0x4[R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn0x4StructWrappersAndFuncs[R0, R1, R2, R3](doFn)
}
+// Function0x4[R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function0x4[R0, R1, R2, R3 any](doFn func() (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func() (R0, R1, R2, R3))
+ return &caller0x4[R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func() (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn1x4[I0, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0) (R0, R1, R2, R3)
}
@@ -5444,13 +5983,25 @@ func registerDoFn1x4StructWrappersAndFuncs[I0, R0, R1, R2, R3 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x4[I0, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x4[I0, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x4[I0, R0, R1, R2, R3 any](doFn genericDoFn1x4[I0, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn1x4StructWrappersAndFuncs[I0, R0, R1, R2, R3](doFn)
}
+// Function1x4[I0, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x4[I0, R0, R1, R2, R3 any](doFn func(I0) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0) (R0, R1, R2, R3))
+ return &caller1x4[I0, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn2x4[I0, I1, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1) (R0, R1, R2, R3)
}
@@ -5515,13 +6066,25 @@ func registerDoFn2x4StructWrappersAndFuncs[I0, I1, R0, R1, R2, R3 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x4[I0, I1, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x4[I0, I1, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x4[I0, I1, R0, R1, R2, R3 any](doFn genericDoFn2x4[I0, I1, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn2x4StructWrappersAndFuncs[I0, I1, R0, R1, R2, R3](doFn)
}
+// Function2x4[I0, I1, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x4[I0, I1, R0, R1, R2, R3 any](doFn func(I0, I1) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1) (R0, R1, R2, R3))
+ return &caller2x4[I0, I1, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn3x4[I0, I1, I2, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2) (R0, R1, R2, R3)
}
@@ -5586,13 +6149,25 @@ func registerDoFn3x4StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2, R3 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x4[I0, I1, I2, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x4[I0, I1, I2, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x4[I0, I1, I2, R0, R1, R2, R3 any](doFn genericDoFn3x4[I0, I1, I2, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn3x4StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2, R3](doFn)
}
+// Function3x4[I0, I1, I2, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x4[I0, I1, I2, R0, R1, R2, R3 any](doFn func(I0, I1, I2) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2) (R0, R1, R2, R3))
+ return &caller3x4[I0, I1, I2, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3) (R0, R1, R2, R3)
}
@@ -5657,13 +6232,25 @@ func registerDoFn4x4StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2, R3 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3 any](doFn genericDoFn4x4[I0, I1, I2, I3, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn4x4StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2, R3](doFn)
}
+// Function4x4[I0, I1, I2, I3, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x4[I0, I1, I2, I3, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3) (R0, R1, R2, R3))
+ return &caller4x4[I0, I1, I2, I3, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4) (R0, R1, R2, R3)
}
@@ -5728,13 +6315,25 @@ func registerDoFn5x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2, R3 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any](doFn genericDoFn5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn5x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2, R3](doFn)
}
+// Function5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4) (R0, R1, R2, R3))
+ return &caller5x4[I0, I1, I2, I3, I4, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5) (R0, R1, R2, R3)
}
@@ -5799,13 +6398,25 @@ func registerDoFn6x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any](doFn genericDoFn6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn6x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3](doFn)
}
+// Function6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3))
+ return &caller6x4[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6) (R0, R1, R2, R3)
}
@@ -5870,13 +6481,25 @@ func registerDoFn7x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any](doFn genericDoFn7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn7x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3](doFn)
}
+// Function7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3))
+ return &caller7x4[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7) (R0, R1, R2, R3)
}
@@ -5941,13 +6564,25 @@ func registerDoFn8x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any](doFn genericDoFn8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn8x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3](doFn)
}
+// Function8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3))
+ return &caller8x4[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8) (R0, R1, R2, R3)
}
@@ -6012,13 +6647,25 @@ func registerDoFn9x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any](doFn genericDoFn9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn9x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3](doFn)
}
+// Function9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3))
+ return &caller9x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9) (R0, R1, R2, R3)
}
@@ -6083,13 +6730,25 @@ func registerDoFn10x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any](doFn genericDoFn10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3]) {
registerDoFnTypes(doFn)
registerDoFn10x4StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3](doFn)
}
+// Function10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3))
+ return &caller10x4[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3))(nil)).Elem(), caller)
+}
+
type genericDoFn0x5[R0, R1, R2, R3, R4 any] interface {
ProcessElement() (R0, R1, R2, R3, R4)
}
@@ -6154,13 +6813,25 @@ func registerDoFn0x5StructWrappersAndFuncs[R0, R1, R2, R3, R4 any](doFn genericD
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn0x5[R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn0x5[R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn0x5[R0, R1, R2, R3, R4 any](doFn genericDoFn0x5[R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn0x5StructWrappersAndFuncs[R0, R1, R2, R3, R4](doFn)
}
+// Function0x5[R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function0x5[R0, R1, R2, R3, R4 any](doFn func() (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func() (R0, R1, R2, R3, R4))
+ return &caller0x5[R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func() (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn1x5[I0, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0) (R0, R1, R2, R3, R4)
}
@@ -6225,13 +6896,25 @@ func registerDoFn1x5StructWrappersAndFuncs[I0, R0, R1, R2, R3, R4 any](doFn gene
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn1x5[I0, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn1x5[I0, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn1x5[I0, R0, R1, R2, R3, R4 any](doFn genericDoFn1x5[I0, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn1x5StructWrappersAndFuncs[I0, R0, R1, R2, R3, R4](doFn)
}
+// Function1x5[I0, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function1x5[I0, R0, R1, R2, R3, R4 any](doFn func(I0) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0) (R0, R1, R2, R3, R4))
+ return &caller1x5[I0, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn2x5[I0, I1, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1) (R0, R1, R2, R3, R4)
}
@@ -6296,13 +6979,25 @@ func registerDoFn2x5StructWrappersAndFuncs[I0, I1, R0, R1, R2, R3, R4 any](doFn
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn2x5[I0, I1, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn2x5[I0, I1, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn2x5[I0, I1, R0, R1, R2, R3, R4 any](doFn genericDoFn2x5[I0, I1, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn2x5StructWrappersAndFuncs[I0, I1, R0, R1, R2, R3, R4](doFn)
}
+// Function2x5[I0, I1, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function2x5[I0, I1, R0, R1, R2, R3, R4 any](doFn func(I0, I1) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1) (R0, R1, R2, R3, R4))
+ return &caller2x5[I0, I1, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2) (R0, R1, R2, R3, R4)
}
@@ -6367,13 +7062,25 @@ func registerDoFn3x5StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2, R3, R4 any](d
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4 any](doFn genericDoFn3x5[I0, I1, I2, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn3x5StructWrappersAndFuncs[I0, I1, I2, R0, R1, R2, R3, R4](doFn)
}
+// Function3x5[I0, I1, I2, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function3x5[I0, I1, I2, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2) (R0, R1, R2, R3, R4))
+ return &caller3x5[I0, I1, I2, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3) (R0, R1, R2, R3, R4)
}
@@ -6438,13 +7145,25 @@ func registerDoFn4x5StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2, R3, R4 an
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any](doFn genericDoFn4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn4x5StructWrappersAndFuncs[I0, I1, I2, I3, R0, R1, R2, R3, R4](doFn)
}
+// Function4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3) (R0, R1, R2, R3, R4))
+ return &caller4x5[I0, I1, I2, I3, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4) (R0, R1, R2, R3, R4)
}
@@ -6509,13 +7228,25 @@ func registerDoFn5x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2, R3, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any](doFn genericDoFn5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn5x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4](doFn)
}
+// Function5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4) (R0, R1, R2, R3, R4))
+ return &caller5x5[I0, I1, I2, I3, I4, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5) (R0, R1, R2, R3, R4)
}
@@ -6580,13 +7311,25 @@ func registerDoFn6x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any](doFn genericDoFn6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn6x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4](doFn)
}
+// Function6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3, R4))
+ return &caller6x5[I0, I1, I2, I3, I4, I5, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6) (R0, R1, R2, R3, R4)
}
@@ -6651,13 +7394,25 @@ func registerDoFn7x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any](doFn genericDoFn7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn7x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4](doFn)
}
+// Function7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3, R4))
+ return &caller7x5[I0, I1, I2, I3, I4, I5, I6, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7) (R0, R1, R2, R3, R4)
}
@@ -6722,13 +7477,25 @@ func registerDoFn8x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any](doFn genericDoFn8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn8x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4](doFn)
}
+// Function8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3, R4))
+ return &caller8x5[I0, I1, I2, I3, I4, I5, I6, I7, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8) (R0, R1, R2, R3, R4)
}
@@ -6793,13 +7560,25 @@ func registerDoFn9x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any](doFn genericDoFn9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn9x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4](doFn)
}
+// Function9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3, R4))
+ return &caller9x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type genericDoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] interface {
ProcessElement(i0 I0, i1 I1, i2 I2, i3 I3, i4 I4, i5 I5, i6 I6, i7 I7, i8 I8, i9 I9) (R0, R1, R2, R3, R4)
}
@@ -6864,13 +7643,25 @@ func registerDoFn10x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8,
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] registers your DoFn to optimize execution at runtime.
+// DoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] registers your structural DoFn to optimize execution at runtime.
// DoFn input and output parameter types should be provided in order as the generic constraints.
func DoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any](doFn genericDoFn10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4]) {
registerDoFnTypes(doFn)
registerDoFn10x5StructWrappersAndFuncs[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4](doFn)
}
+// Function10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any] registers your functional DoFn to optimize execution at runtime.
+// Function input and output parameter types should be provided in order as the generic constraints.
+func Function10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4 any](doFn func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3, R4)) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3, R4))
+ return &caller10x5[I0, I1, I2, I3, I4, I5, I6, I7, I8, I9, R0, R1, R2, R3, R4]{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func(I0, I1, I2, I3, I4, I5, I6, I7, I8, I9) (R0, R1, R2, R3, R4))(nil)).Elem(), caller)
+}
+
type startBundle0x0 interface {
StartBundle()
}
diff --git a/sdks/go/pkg/beam/register/register.tmpl b/sdks/go/pkg/beam/register/register.tmpl
index b615c784a71..b701be45686 100644
--- a/sdks/go/pkg/beam/register/register.tmpl
+++ b/sdks/go/pkg/beam/register/register.tmpl
@@ -194,11 +194,23 @@ func registerDoFn{{$processElementIn}}x{{$processElementOut}}StructWrappersAndFu
reflectx.RegisterStructWrapper(reflect.TypeOf(doFn).Elem(), wrapperFn)
}
-// DoFn{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut true)}} registers your DoFn to optimize execution at runtime.
+// DoFn{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut true)}} registers your structural DoFn to optimize execution at runtime.
{{if (or $processElementIn $processElementOut)}}// DoFn input and output parameter types should be provided in order as the generic constraints.
{{end}}func DoFn{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut true)}}(doFn genericDoFn{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut false)}}) {
registerDoFnTypes(doFn)
registerDoFn{{$processElementIn}}x{{$processElementOut}}StructWrappersAndFuncs{{(genericTypingRepresentation $processElementIn $processElementOut false)}}(doFn)
+}
+
+// Function{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut true)}} registers your functional DoFn to optimize execution at runtime.
+{{if (or $processElementIn $processElementOut)}}// Function input and output parameter types should be provided in order as the generic constraints.
+{{end}}func Function{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut true)}}(doFn func({{range $in := upto $processElementIn}}{{if $in}}, {{end}}I{{$in}}{{end}}) {{if (gt $processElementOut 1)}}({{end}}{{range $out := upto $processElementOut}}{{if $out}}, {{end}}R{{$out}}{{end}}{{if (gt $processElementOut 1)}}){{end}}) {
+ runtime.RegisterFunction(doFn)
+ registerMethodTypes(reflect.TypeOf(doFn))
+ caller := func(fn interface{}) reflectx.Func {
+ f := fn.(func({{range $in := upto $processElementIn}}{{if $in}}, {{end}}I{{$in}}{{end}}) {{if (gt $processElementOut 1)}}({{end}}{{range $out := upto $processElementOut}}{{if $out}}, {{end}}R{{$out}}{{end}}{{if (gt $processElementOut 1)}}){{end}})
+ return &caller{{$processElementIn}}x{{$processElementOut}}{{(genericTypingRepresentation $processElementIn $processElementOut false)}}{fn: f}
+ }
+ reflectx.RegisterFunc(reflect.TypeOf((*func({{range $in := upto $processElementIn}}{{if $in}}, {{end}}I{{$in}}{{end}}) {{if (gt $processElementOut 1)}}({{end}}{{range $out := upto $processElementOut}}{{if $out}}, {{end}}R{{$out}}{{end}}{{if (gt $processElementOut 1)}}){{end}})(nil)).Elem(), caller)
}{{end}}{{end}}
{{range $startFinishBundleOut := upto $startFinishBundleOutRange}}{{range $startFinishBundleIn := upto $startFinishBundleInRange}}
diff --git a/sdks/go/pkg/beam/register/register_test.go b/sdks/go/pkg/beam/register/register_test.go
index 9aee375b14a..39962ab3c42 100644
--- a/sdks/go/pkg/beam/register/register_test.go
+++ b/sdks/go/pkg/beam/register/register_test.go
@@ -537,6 +537,36 @@ func TestIter2_Struct(t *testing.T) {
}
}
+type CustomFunctionParameter struct {
+ key string
+ val int
+}
+
+type CustomFunctionReturn struct {
+ key int
+ val string
+}
+
+func customFunction(a CustomFunctionParameter) CustomFunctionReturn {
+ return CustomFunctionReturn{
+ key: a.val,
+ val: a.key,
+ }
+}
+
+func TestFunction(t *testing.T) {
+ Function1x1[CustomFunctionParameter, CustomFunctionReturn](customFunction)
+
+ // Need to call FromType so that the registry will reconcile its registrations
+ schema.FromType(reflect.TypeOf(CustomFunctionParameter{}))
+ if !schema.Registered(reflect.TypeOf(CustomFunctionParameter{})) {
+ t.Errorf("schema.Registered(reflect.TypeOf(CustomFunctionParameter{})) = false, want true")
+ }
+ if !schema.Registered(reflect.TypeOf(CustomFunctionReturn{})) {
+ t.Errorf("schema.Registered(reflect.TypeOf(CustomFunctionReturn{})) = false, want true")
+ }
+}
+
type elementProcessor struct {
inFV exec.FullValue
}
@@ -697,11 +727,6 @@ type callerCustomTypeГint struct {
fn func(CustomType) int
}
-func funcMakerCustomTypeГint(fn interface{}) reflectx.Func {
- f := fn.(func(CustomType) int)
- return &callerCustomTypeГint{fn: f}
-}
-
func (c *callerCustomTypeГint) Name() string {
return reflectx.FunctionName(c.fn)
}
@@ -719,6 +744,37 @@ func (c *callerCustomTypeГint) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(CustomType))
}
+type callerCustomType2CustomType2ГCustomType2 struct {
+ fn func(CustomType2, CustomType2) CustomType2
+}
+
+func (c *callerCustomType2CustomType2ГCustomType2) Name() string {
+ return reflectx.FunctionName(c.fn)
+}
+
+func (c *callerCustomType2CustomType2ГCustomType2) Type() reflect.Type {
+ return reflect.TypeOf(c.fn)
+}
+
+func (c *callerCustomType2CustomType2ГCustomType2) Call(args []interface{}) []interface{} {
+ out0 := c.fn(args[0].(CustomType2), args[0].(CustomType2))
+ return []interface{}{out0}
+}
+
+func (c *callerCustomType2CustomType2ГCustomType2) Call2x1(arg0, arg1 interface{}) interface{} {
+ return c.fn(arg0.(CustomType2), arg1.(CustomType2))
+}
+
+func funcMakerCustomTypeГint(fn interface{}) reflectx.Func {
+ f := fn.(func(CustomType) int)
+ return &callerCustomTypeГint{fn: f}
+}
+
+func funcMakerCustomType2CustomType2ГCustomType2(fn interface{}) reflectx.Func {
+ f := fn.(func(CustomType2, CustomType2) CustomType2)
+ return &callerCustomType2CustomType2ГCustomType2{fn: f}
+}
+
func wrapMakerFoo(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*Foo)
return map[string]reflectx.Func{
@@ -726,12 +782,21 @@ func wrapMakerFoo(fn interface{}) map[string]reflectx.Func {
}
}
+func addCustomType2(a CustomType2, b CustomType2) CustomType2 {
+ return CustomType2{
+ val2: a.val2 + b.val2,
+ }
+}
+
func GeneratedOptimizationCalls() {
runtime.RegisterType(reflect.TypeOf((*Foo)(nil)).Elem())
schema.RegisterType(reflect.TypeOf((*Foo)(nil)).Elem())
runtime.RegisterType(reflect.TypeOf((*CustomType)(nil)).Elem())
schema.RegisterType(reflect.TypeOf((*CustomType)(nil)).Elem())
+ runtime.RegisterType(reflect.TypeOf((*CustomType2)(nil)).Elem())
+ schema.RegisterType(reflect.TypeOf((*CustomType2)(nil)).Elem())
reflectx.RegisterFunc(reflect.TypeOf((*func(CustomType) int)(nil)).Elem(), funcMakerCustomTypeГint)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(CustomType2, CustomType2) CustomType2)(nil)).Elem(), funcMakerCustomType2CustomType2ГCustomType2)
reflectx.RegisterStructWrapper(reflect.TypeOf((*Foo)(nil)).Elem(), wrapMakerFoo)
}
@@ -743,23 +808,32 @@ func GeneratedOptimizationCalls() {
// recommended path for most users - if these are materially better than the generic benchmarks,
// this package requires further optimization.
//
-// BenchmarkMethodCalls/MakeFunc_Unoptimized-16 11480814 88.35 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call_Unoptimized-16 3525211 324.0 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call1x1_Unoptimized-16 3450822 343.0 ns/op
-// BenchmarkMethodCalls/NewFn_Unoptimized-16 875199 1385 ns/op
-// BenchmarkMethodCalls/EncodeMultiEdge_Unoptimized-16 1000000 1063 ns/op
+// BenchmarkMethodCalls/MakeFunc_Unoptimized-16 11480814 88.35 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call_Unoptimized-16 3525211 324.0 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call1x1_Unoptimized-16 3450822 343.0 ns/op
+// BenchmarkMethodCalls/NewFn_Unoptimized-16 875199 1385 ns/op
+// BenchmarkMethodCalls/EncodeMultiEdge_Unoptimized-16 1000000 1063 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn_Unoptimized-16 11984484 110.6 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call_Unoptimized-16 1574622 744.4 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call1x1_Unoptimized-16 1504969 795.9 ns/op
//
-// BenchmarkMethodCalls/MakeFunc_GenericRegistration-16 16266259 72.07 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call_GenericRegistration-16 38331327 32.70 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call1x1_GenericRegistration-16 135934086 8.434 ns/op
-// BenchmarkMethodCalls/NewFn_GenericRegistration-16 1000000 1108 ns/op
-// BenchmarkMethodCalls/EncodeMultiEdge_GenericRegistration-16 1000000 1052 ns/op
+// BenchmarkMethodCalls/MakeFunc_GenericRegistration-16 16266259 72.07 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call_GenericRegistration-16 38331327 32.70 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call1x1_GenericRegistration-16 135934086 8.434 ns/op
+// BenchmarkMethodCalls/NewFn_GenericRegistration-16 1000000 1108 ns/op
+// BenchmarkMethodCalls/EncodeMultiEdge_GenericRegistration-16 1000000 1052 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn_GenericRegistration-16 11295202 95.43 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call_GenericRegistration-16 20299956 54.15 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call1x1_GenericRegistration-16 92858212 12.86 ns/op
//
-// BenchmarkMethodCalls/MakeFunc_GeneratedShims-16 16400914 69.17 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call_GeneratedShims-16 37106445 33.69 ns/op
-// BenchmarkMethodCalls/MakeFunc.Call1x1_GeneratedShims-16 141127965 8.312 ns/op
-// BenchmarkMethodCalls/NewFn_GeneratedShims-16 1000000 1099 ns/op
-// BenchmarkMethodCalls/EncodeMultiEdge_GeneratedShims-16 1000000 1071 ns/op
+// BenchmarkMethodCalls/MakeFunc_GeneratedShims-16 16400914 69.17 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call_GeneratedShims-16 37106445 33.69 ns/op
+// BenchmarkMethodCalls/MakeFunc.Call1x1_GeneratedShims-16 141127965 8.312 ns/op
+// BenchmarkMethodCalls/NewFn_GeneratedShims-16 1000000 1099 ns/op
+// BenchmarkMethodCalls/EncodeMultiEdge_GeneratedShims-16 1000000 1071 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn_GeneratedShims-16 12444930 90.77 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call_GeneratedShims-16 19462878 51.92 ns/op
+// BenchmarkMethodCalls/MakeFunc_FunctionalDoFn.Call2x1_GeneratedShims-16 85194289 15.76 ns/op
func BenchmarkMethodCalls(b *testing.B) {
f := &Foo{A: 3}
g, err := graph.NewFn(&Foo{A: 5})
@@ -776,8 +850,11 @@ func BenchmarkMethodCalls(b *testing.B) {
var aFn *graph.Fn
var aME interface{}
var aFnCall int
+ var aFnCall2 CustomType2
var aFunc1x1 reflectx.Func1x1
+ var aFunc2x1 reflectx.Func2x1
funcIn := []interface{}{CustomType{val: 4}}
+ funcIn2 := []interface{}{CustomType2{val2: 4}, CustomType2{val2: 3}}
// We need to do this registration just to get it to not panic when encoding the multi-edge with no additional optimization.
// This is currently required of users anyways
@@ -788,25 +865,37 @@ func BenchmarkMethodCalls(b *testing.B) {
registration func()
}{
// No optimization performed at all
- {"MakeFunc_Unoptimized", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { /*No op*/ }}, // Used in graph deserialization
- {"MakeFunc.Call_Unoptimized", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { /*No op*/ }}, // Used to call the function repeatedly
- {"MakeFunc.Call1x1_Unoptimized", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 4}).(int) }, func() { aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
- {"NewFn_Unoptimized", func() { aFn, _ = graph.NewFn(f) }, func() { /*No op*/ }}, // Used in graph construction (less valuable)
- {"EncodeMultiEdge_Unoptimized", func() { aME, _ = graphx.EncodeMultiEdge(&me) }, func() { /*No op*/ }}, // Used in graph serialization at execution time
+ {"MakeFunc_Unoptimized", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { /*No op*/ }}, // Used in graph deserialization
+ {"MakeFunc.Call_Unoptimized", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { /*No op*/ }}, // Used to call the function repeatedly
+ {"MakeFunc.Call1x1_Unoptimized", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 4}).(int) }, func() { aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
+ {"NewFn_Unoptimized", func() { aFn, _ = graph.NewFn(f) }, func() { /*No op*/ }}, // Used in graph construction (less valuable)
+ {"EncodeMultiEdge_Unoptimized", func() { aME, _ = graphx.EncodeMultiEdge(&me) }, func() { /*No op*/ }}, // Used in graph serialization at execution time
+ {"MakeFunc_FunctionalDoFn_Unoptimized", func() { aFunc = reflectx.MakeFunc(addCustomType2) }, func() { /*No op*/ }}, // Used in graph deserialization
+ {"MakeFunc_FunctionalDoFn.Call_Unoptimized", func() { aFnCall2 = aFunc.Call(funcIn2)[0].(CustomType2) }, func() { /*No op*/ }}, // Used to call the function repeatedly
+ {"MakeFunc_FunctionalDoFn.Call2x1_Unoptimized", func() { aFnCall2 = aFunc2x1.Call2x1(CustomType2{val2: 4}, CustomType2{val2: 3}).(CustomType2) }, func() { aFunc2x1 = reflectx.ToFunc2x1(aFunc) }}, // Used to call the function repeatedly
// Perform some generic registration to optimize execution
- {"MakeFunc_GenericRegistration", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph deserialization
- {"MakeFunc.Call_GenericRegistration", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { DoFn1x1[CustomType, int](f) }}, // Used to call the function repeatedly
- {"MakeFunc.Call1x1_GenericRegistration", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 3}).(int) }, func() { DoFn1x1[CustomType, int](f); aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
- {"NewFn_GenericRegistration", func() { aFn, _ = graph.NewFn(f) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph construction (less valuable)
- {"EncodeMultiEdge_GenericRegistration", func() { aME, _ = graphx.EncodeMultiEdge(&me) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph serialization at execution time
+ {"MakeFunc_GenericRegistration", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph deserialization
+ {"MakeFunc.Call_GenericRegistration", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { DoFn1x1[CustomType, int](f) }}, // Used to call the function repeatedly
+ {"MakeFunc.Call1x1_GenericRegistration", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 3}).(int) }, func() { DoFn1x1[CustomType, int](f); aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
+ {"NewFn_GenericRegistration", func() { aFn, _ = graph.NewFn(f) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph construction (less valuable)
+ {"EncodeMultiEdge_GenericRegistration", func() { aME, _ = graphx.EncodeMultiEdge(&me) }, func() { DoFn1x1[CustomType, int](f) }}, // Used in graph serialization at execution time
+ {"MakeFunc_FunctionalDoFn_GenericRegistration", func() { aFunc = reflectx.MakeFunc(addCustomType2) }, func() { Function2x1[CustomType2, CustomType2, CustomType2](addCustomType2) }}, // Used in graph deserialization
+ {"MakeFunc_FunctionalDoFn.Call_GenericRegistration", func() { aFnCall2 = aFunc.Call(funcIn2)[0].(CustomType2) }, func() { Function2x1[CustomType2, CustomType2, CustomType2](addCustomType2) }}, // Used to call the function repeatedly
+ {"MakeFunc_FunctionalDoFn.Call2x1_GenericRegistration", func() { aFnCall2 = aFunc2x1.Call2x1(CustomType2{val2: 4}, CustomType2{val2: 3}).(CustomType2) }, func() {
+ Function2x1[CustomType2, CustomType2, CustomType2](addCustomType2)
+ aFunc2x1 = reflectx.ToFunc2x1(aFunc)
+ }}, // Used to call the function repeatedly
// Perform some registration via copies of the code generator's shims
- {"MakeFunc_GeneratedShims", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { GeneratedOptimizationCalls() }}, // Used in graph deserialization
- {"MakeFunc.Call_GeneratedShims", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { GeneratedOptimizationCalls() }}, // Used to call the function repeatedly
- {"MakeFunc.Call1x1_GeneratedShims", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 5}).(int) }, func() { GeneratedOptimizationCalls(); aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
- {"NewFn_GeneratedShims", func() { aFn, _ = graph.NewFn(f) }, func() { GeneratedOptimizationCalls() }}, // Used in graph construction (less valuable)
- {"EncodeMultiEdge_GeneratedShims", func() { aME, err = graphx.EncodeMultiEdge(&me) }, func() { GeneratedOptimizationCalls() }}, // Used in graph serialization at execution time
+ {"MakeFunc_GeneratedShims", func() { aFunc = reflectx.MakeFunc(f.ProcessElement) }, func() { GeneratedOptimizationCalls() }}, // Used in graph deserialization
+ {"MakeFunc.Call_GeneratedShims", func() { aFnCall = aFunc.Call(funcIn)[0].(int) }, func() { GeneratedOptimizationCalls() }}, // Used to call the function repeatedly
+ {"MakeFunc.Call1x1_GeneratedShims", func() { aFnCall = aFunc1x1.Call1x1(CustomType{val: 5}).(int) }, func() { GeneratedOptimizationCalls(); aFunc1x1 = reflectx.ToFunc1x1(aFunc) }}, // Used to call the function repeatedly
+ {"NewFn_GeneratedShims", func() { aFn, _ = graph.NewFn(f) }, func() { GeneratedOptimizationCalls() }}, // Used in graph construction (less valuable)
+ {"EncodeMultiEdge_GeneratedShims", func() { aME, err = graphx.EncodeMultiEdge(&me) }, func() { GeneratedOptimizationCalls() }}, // Used in graph serialization at execution time
+ {"MakeFunc_FunctionalDoFn_GeneratedShims", func() { aFunc = reflectx.MakeFunc(addCustomType2) }, func() { GeneratedOptimizationCalls() }}, // Used in graph deserialization
+ {"MakeFunc_FunctionalDoFn.Call_GeneratedShims", func() { aFnCall2 = aFunc.Call(funcIn2)[0].(CustomType2) }, func() { GeneratedOptimizationCalls() }}, // Used to call the function repeatedly
+ {"MakeFunc_FunctionalDoFn.Call2x1_GeneratedShims", func() { aFnCall2 = aFunc2x1.Call2x1(CustomType2{val2: 4}, CustomType2{val2: 3}).(CustomType2) }, func() { GeneratedOptimizationCalls(); aFunc2x1 = reflectx.ToFunc2x1(aFunc) }}, // Used to call the function repeatedly
}
for _, test := range tests {
test.registration()
@@ -818,6 +907,7 @@ func BenchmarkMethodCalls(b *testing.B) {
}
b.Log(aFunc)
b.Log(aFnCall)
+ b.Log(aFnCall2)
b.Log(aFn)
b.Log(aME)
}