This is an automated email from the ASF dual-hosted git repository.
pabloem 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 fc47df5 Apply go formatter changes on ./gradlew build
new 58db009 Merge pull request #8029 from Ardagan/GoFormatter
fc47df5 is described below
commit fc47df5892ab7b45bb80bb77fec8950c0fd20721
Author: Mikhail Gryzykhin <[email protected]>
AuthorDate: Mon Mar 11 11:22:18 2019 -0700
Apply go formatter changes on ./gradlew build
---
sdks/go/pkg/beam/artifact/stage.go | 2 +-
sdks/go/pkg/beam/beam.shims.go | 79 ++++++------
.../pkg/beam/core/runtime/coderx/coderx.shims.go | 87 +++++++------
sdks/go/pkg/beam/io/bigqueryio/bigquery.go | 8 +-
sdks/go/pkg/beam/testing/passert/passert.shims.go | 87 ++++++-------
sdks/go/pkg/beam/transforms/filter/filter.shims.go | 51 ++++----
sdks/go/pkg/beam/transforms/stats/stats.shims.go | 143 ++++++++++-----------
sdks/go/pkg/beam/transforms/top/top.shims.go | 51 ++++----
sdks/go/pkg/beam/x/debug/debug.shims.go | 87 +++++++------
sdks/python/container/piputil.go | 8 +-
10 files changed, 303 insertions(+), 300 deletions(-)
diff --git a/sdks/go/pkg/beam/artifact/stage.go
b/sdks/go/pkg/beam/artifact/stage.go
index 1b05b0d..bf448cd 100644
--- a/sdks/go/pkg/beam/artifact/stage.go
+++ b/sdks/go/pkg/beam/artifact/stage.go
@@ -131,7 +131,7 @@ func Stage(ctx context.Context, client
pb.ArtifactStagingServiceClient, key, fil
md := &pb.ArtifactMetadata{
Name: key,
Permissions: uint32(stat.Mode()),
- Sha256: hash,
+ Sha256: hash,
}
pmd := &pb.PutArtifactMetadata{
Metadata: md,
diff --git a/sdks/go/pkg/beam/beam.shims.go b/sdks/go/pkg/beam/beam.shims.go
index 2c7d412..44d522f 100644
--- a/sdks/go/pkg/beam/beam.shims.go
+++ b/sdks/go/pkg/beam/beam.shims.go
@@ -44,31 +44,31 @@ func init() {
runtime.RegisterType(reflect.TypeOf((*reflect.Type)(nil)).Elem())
runtime.RegisterType(reflect.TypeOf((*reflectx.Func)(nil)).Elem())
reflectx.RegisterStructWrapper(reflect.TypeOf((*createFn)(nil)).Elem(),
wrapMakerCreateFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(reflect.Type,[]byte)
(typex.T,error))(nil)).Elem(), funcMakerReflect۰TypeSliceOfByteГTypex۰TError)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte,func(typex.T))
(error))(nil)).Elem(), funcMakerSliceOfByteEmitTypex۰TГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]typex.T,func(typex.T))
())(nil)).Elem(), funcMakerSliceOfTypex۰TEmitTypex۰TГ)
- reflectx.RegisterFunc(reflect.TypeOf((*func(string,reflect.Type,[]byte)
(reflectx.Func))(nil)).Elem(),
funcMakerStringReflect۰TypeSliceOfByteГReflectx۰Func)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
(int,typex.T))(nil)).Elem(), funcMakerTypex۰TГIntTypex۰T)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
([]byte,error))(nil)).Elem(), funcMakerTypex۰TГSliceOfByteError)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X,typex.Y)
(typex.X))(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰X)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X,typex.Y)
(typex.Y))(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰Y)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X,typex.Y)
(typex.Y,typex.X))(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰YTypex۰X)
- exec.RegisterEmitter(reflect.TypeOf((*func(typex.T) ())(nil)).Elem(),
emitMakerTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(reflect.Type, []byte)
(typex.T, error))(nil)).Elem(), funcMakerReflect۰TypeSliceOfByteГTypex۰TError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte, func(typex.T))
error)(nil)).Elem(), funcMakerSliceOfByteEmitTypex۰TГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]typex.T,
func(typex.T)))(nil)).Elem(), funcMakerSliceOfTypex۰TEmitTypex۰TГ)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(string, reflect.Type,
[]byte) reflectx.Func)(nil)).Elem(),
funcMakerStringReflect۰TypeSliceOfByteГReflectx۰Func)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T) (int,
typex.T))(nil)).Elem(), funcMakerTypex۰TГIntTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T) ([]byte,
error))(nil)).Elem(), funcMakerTypex۰TГSliceOfByteError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, typex.Y)
typex.X)(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰X)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, typex.Y)
typex.Y)(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰Y)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, typex.Y) (typex.Y,
typex.X))(nil)).Elem(), funcMakerTypex۰XTypex۰YГTypex۰YTypex۰X)
+ exec.RegisterEmitter(reflect.TypeOf((*func(typex.T))(nil)).Elem(),
emitMakerTypex۰T)
}
func wrapMakerCreateFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*createFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(typex.T)) (error) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(typex.T)) error { return dfn.ProcessElement(a0, a1) }),
}
}
type callerReflect۰TypeSliceOfByteГTypex۰TError struct {
- fn func(reflect.Type,[]byte) (typex.T,error)
+ fn func(reflect.Type, []byte) (typex.T, error)
}
func funcMakerReflect۰TypeSliceOfByteГTypex۰TError(fn interface{})
reflectx.Func {
- f := fn.(func(reflect.Type,[]byte) (typex.T,error))
+ f := fn.(func(reflect.Type, []byte) (typex.T, error))
return &callerReflect۰TypeSliceOfByteГTypex۰TError{fn: f}
}
@@ -90,11 +90,11 @@ func (c *callerReflect۰TypeSliceOfByteГTypex۰TError)
Call2x2(arg0, arg1 inter
}
type callerSliceOfByteEmitTypex۰TГError struct {
- fn func([]byte,func(typex.T)) (error)
+ fn func([]byte, func(typex.T)) error
}
func funcMakerSliceOfByteEmitTypex۰TГError(fn interface{}) reflectx.Func {
- f := fn.(func([]byte,func(typex.T)) (error))
+ f := fn.(func([]byte, func(typex.T)) error)
return &callerSliceOfByteEmitTypex۰TГError{fn: f}
}
@@ -111,16 +111,16 @@ func (c *callerSliceOfByteEmitTypex۰TГError) Call(args
[]interface{}) []interf
return []interface{}{out0}
}
-func (c *callerSliceOfByteEmitTypex۰TГError) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerSliceOfByteEmitTypex۰TГError) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.([]byte), arg1.(func(typex.T)))
}
type callerSliceOfTypex۰TEmitTypex۰TГ struct {
- fn func([]typex.T,func(typex.T)) ()
+ fn func([]typex.T, func(typex.T))
}
func funcMakerSliceOfTypex۰TEmitTypex۰TГ(fn interface{}) reflectx.Func {
- f := fn.(func([]typex.T,func(typex.T)) ())
+ f := fn.(func([]typex.T, func(typex.T)))
return &callerSliceOfTypex۰TEmitTypex۰TГ{fn: f}
}
@@ -137,16 +137,16 @@ func (c *callerSliceOfTypex۰TEmitTypex۰TГ) Call(args
[]interface{}) []interfa
return []interface{}{}
}
-func (c *callerSliceOfTypex۰TEmitTypex۰TГ) Call2x0(arg0, arg1 interface{}) () {
+func (c *callerSliceOfTypex۰TEmitTypex۰TГ) Call2x0(arg0, arg1 interface{}) {
c.fn(arg0.([]typex.T), arg1.(func(typex.T)))
}
type callerStringReflect۰TypeSliceOfByteГReflectx۰Func struct {
- fn func(string,reflect.Type,[]byte) (reflectx.Func)
+ fn func(string, reflect.Type, []byte) reflectx.Func
}
func funcMakerStringReflect۰TypeSliceOfByteГReflectx۰Func(fn interface{})
reflectx.Func {
- f := fn.(func(string,reflect.Type,[]byte) (reflectx.Func))
+ f := fn.(func(string, reflect.Type, []byte) reflectx.Func)
return &callerStringReflect۰TypeSliceOfByteГReflectx۰Func{fn: f}
}
@@ -163,16 +163,16 @@ func (c
*callerStringReflect۰TypeSliceOfByteГReflectx۰Func) Call(args []inter
return []interface{}{out0}
}
-func (c *callerStringReflect۰TypeSliceOfByteГReflectx۰Func) Call3x1(arg0,
arg1, arg2 interface{}) (interface{}) {
+func (c *callerStringReflect۰TypeSliceOfByteГReflectx۰Func) Call3x1(arg0,
arg1, arg2 interface{}) interface{} {
return c.fn(arg0.(string), arg1.(reflect.Type), arg2.([]byte))
}
type callerTypex۰TГIntTypex۰T struct {
- fn func(typex.T) (int,typex.T)
+ fn func(typex.T) (int, typex.T)
}
func funcMakerTypex۰TГIntTypex۰T(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) (int,typex.T))
+ f := fn.(func(typex.T) (int, typex.T))
return &callerTypex۰TГIntTypex۰T{fn: f}
}
@@ -194,11 +194,11 @@ func (c *callerTypex۰TГIntTypex۰T) Call1x2(arg0
interface{}) (interface{}, in
}
type callerTypex۰TГSliceOfByteError struct {
- fn func(typex.T) ([]byte,error)
+ fn func(typex.T) ([]byte, error)
}
func funcMakerTypex۰TГSliceOfByteError(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) ([]byte,error))
+ f := fn.(func(typex.T) ([]byte, error))
return &callerTypex۰TГSliceOfByteError{fn: f}
}
@@ -220,11 +220,11 @@ func (c *callerTypex۰TГSliceOfByteError) Call1x2(arg0
interface{}) (interface{
}
type callerTypex۰XTypex۰YГTypex۰X struct {
- fn func(typex.X,typex.Y) (typex.X)
+ fn func(typex.X, typex.Y) typex.X
}
func funcMakerTypex۰XTypex۰YГTypex۰X(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X,typex.Y) (typex.X))
+ f := fn.(func(typex.X, typex.Y) typex.X)
return &callerTypex۰XTypex۰YГTypex۰X{fn: f}
}
@@ -241,16 +241,16 @@ func (c *callerTypex۰XTypex۰YГTypex۰X) Call(args
[]interface{}) []interface{
return []interface{}{out0}
}
-func (c *callerTypex۰XTypex۰YГTypex۰X) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerTypex۰XTypex۰YГTypex۰X) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(typex.X), arg1.(typex.Y))
}
type callerTypex۰XTypex۰YГTypex۰Y struct {
- fn func(typex.X,typex.Y) (typex.Y)
+ fn func(typex.X, typex.Y) typex.Y
}
func funcMakerTypex۰XTypex۰YГTypex۰Y(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X,typex.Y) (typex.Y))
+ f := fn.(func(typex.X, typex.Y) typex.Y)
return &callerTypex۰XTypex۰YГTypex۰Y{fn: f}
}
@@ -267,16 +267,16 @@ func (c *callerTypex۰XTypex۰YГTypex۰Y) Call(args
[]interface{}) []interface{
return []interface{}{out0}
}
-func (c *callerTypex۰XTypex۰YГTypex۰Y) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerTypex۰XTypex۰YГTypex۰Y) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(typex.X), arg1.(typex.Y))
}
type callerTypex۰XTypex۰YГTypex۰YTypex۰X struct {
- fn func(typex.X,typex.Y) (typex.Y,typex.X)
+ fn func(typex.X, typex.Y) (typex.Y, typex.X)
}
func funcMakerTypex۰XTypex۰YГTypex۰YTypex۰X(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X,typex.Y) (typex.Y,typex.X))
+ f := fn.(func(typex.X, typex.Y) (typex.Y, typex.X))
return &callerTypex۰XTypex۰YГTypex۰YTypex۰X{fn: f}
}
@@ -298,12 +298,12 @@ func (c *callerTypex۰XTypex۰YГTypex۰YTypex۰X)
Call2x2(arg0, arg1 interface{
}
type emitNative struct {
- n exec.ElementProcessor
- fn interface{}
+ n exec.ElementProcessor
+ fn interface{}
- ctx context.Context
- ws []typex.Window
- et typex.EventTime
+ ctx context.Context
+ ws []typex.Window
+ et typex.EventTime
value exec.FullValue
}
@@ -331,5 +331,4 @@ func (e *emitNative) invokeTypex۰T(val typex.T) {
}
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/core/runtime/coderx/coderx.shims.go
b/sdks/go/pkg/beam/core/runtime/coderx/coderx.shims.go
index 91cc99f..be6e362 100644
--- a/sdks/go/pkg/beam/core/runtime/coderx/coderx.shims.go
+++ b/sdks/go/pkg/beam/core/runtime/coderx/coderx.shims.go
@@ -45,25 +45,25 @@ func init() {
runtime.RegisterFunction(encVarIntZ)
runtime.RegisterFunction(encVarUintZ)
runtime.RegisterType(reflect.TypeOf((*reflect.Type)(nil)).Elem())
- reflectx.RegisterFunc(reflect.TypeOf((*func(int32)
([]byte))(nil)).Elem(), funcMakerInt32ГSliceOfByte)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int64)
([]byte))(nil)).Elem(), funcMakerInt64ГSliceOfByte)
- reflectx.RegisterFunc(reflect.TypeOf((*func(reflect.Type,[]byte)
(typex.T,error))(nil)).Elem(), funcMakerReflect۰TypeSliceOfByteГTypex۰TError)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
(int32))(nil)).Elem(), funcMakerSliceOfByteГInt32)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
(int64))(nil)).Elem(), funcMakerSliceOfByteГInt64)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
(typex.T))(nil)).Elem(), funcMakerSliceOfByteГTypex۰T)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
(uint32))(nil)).Elem(), funcMakerSliceOfByteГUint32)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
(uint64))(nil)).Elem(), funcMakerSliceOfByteГUint64)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
([]byte))(nil)).Elem(), funcMakerTypex۰TГSliceOfByte)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint32)
([]byte))(nil)).Elem(), funcMakerUint32ГSliceOfByte)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint64)
([]byte))(nil)).Elem(), funcMakerUint64ГSliceOfByte)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int32)
[]byte)(nil)).Elem(), funcMakerInt32ГSliceOfByte)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int64)
[]byte)(nil)).Elem(), funcMakerInt64ГSliceOfByte)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(reflect.Type, []byte)
(typex.T, error))(nil)).Elem(), funcMakerReflect۰TypeSliceOfByteГTypex۰TError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
int32)(nil)).Elem(), funcMakerSliceOfByteГInt32)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
int64)(nil)).Elem(), funcMakerSliceOfByteГInt64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
typex.T)(nil)).Elem(), funcMakerSliceOfByteГTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
uint32)(nil)).Elem(), funcMakerSliceOfByteГUint32)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte)
uint64)(nil)).Elem(), funcMakerSliceOfByteГUint64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
[]byte)(nil)).Elem(), funcMakerTypex۰TГSliceOfByte)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint32)
[]byte)(nil)).Elem(), funcMakerUint32ГSliceOfByte)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint64)
[]byte)(nil)).Elem(), funcMakerUint64ГSliceOfByte)
}
type callerInt32ГSliceOfByte struct {
- fn func(int32) ([]byte)
+ fn func(int32) []byte
}
func funcMakerInt32ГSliceOfByte(fn interface{}) reflectx.Func {
- f := fn.(func(int32) ([]byte))
+ f := fn.(func(int32) []byte)
return &callerInt32ГSliceOfByte{fn: f}
}
@@ -80,16 +80,16 @@ func (c *callerInt32ГSliceOfByte) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerInt32ГSliceOfByte) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerInt32ГSliceOfByte) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(int32))
}
type callerInt64ГSliceOfByte struct {
- fn func(int64) ([]byte)
+ fn func(int64) []byte
}
func funcMakerInt64ГSliceOfByte(fn interface{}) reflectx.Func {
- f := fn.(func(int64) ([]byte))
+ f := fn.(func(int64) []byte)
return &callerInt64ГSliceOfByte{fn: f}
}
@@ -106,16 +106,16 @@ func (c *callerInt64ГSliceOfByte) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerInt64ГSliceOfByte) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerInt64ГSliceOfByte) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(int64))
}
type callerReflect۰TypeSliceOfByteГTypex۰TError struct {
- fn func(reflect.Type,[]byte) (typex.T,error)
+ fn func(reflect.Type, []byte) (typex.T, error)
}
func funcMakerReflect۰TypeSliceOfByteГTypex۰TError(fn interface{})
reflectx.Func {
- f := fn.(func(reflect.Type,[]byte) (typex.T,error))
+ f := fn.(func(reflect.Type, []byte) (typex.T, error))
return &callerReflect۰TypeSliceOfByteГTypex۰TError{fn: f}
}
@@ -137,11 +137,11 @@ func (c *callerReflect۰TypeSliceOfByteГTypex۰TError)
Call2x2(arg0, arg1 inter
}
type callerSliceOfByteГInt32 struct {
- fn func([]byte) (int32)
+ fn func([]byte) int32
}
func funcMakerSliceOfByteГInt32(fn interface{}) reflectx.Func {
- f := fn.(func([]byte) (int32))
+ f := fn.(func([]byte) int32)
return &callerSliceOfByteГInt32{fn: f}
}
@@ -158,16 +158,16 @@ func (c *callerSliceOfByteГInt32) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerSliceOfByteГInt32) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerSliceOfByteГInt32) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.([]byte))
}
type callerSliceOfByteГInt64 struct {
- fn func([]byte) (int64)
+ fn func([]byte) int64
}
func funcMakerSliceOfByteГInt64(fn interface{}) reflectx.Func {
- f := fn.(func([]byte) (int64))
+ f := fn.(func([]byte) int64)
return &callerSliceOfByteГInt64{fn: f}
}
@@ -184,16 +184,16 @@ func (c *callerSliceOfByteГInt64) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerSliceOfByteГInt64) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerSliceOfByteГInt64) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.([]byte))
}
type callerSliceOfByteГTypex۰T struct {
- fn func([]byte) (typex.T)
+ fn func([]byte) typex.T
}
func funcMakerSliceOfByteГTypex۰T(fn interface{}) reflectx.Func {
- f := fn.(func([]byte) (typex.T))
+ f := fn.(func([]byte) typex.T)
return &callerSliceOfByteГTypex۰T{fn: f}
}
@@ -210,16 +210,16 @@ func (c *callerSliceOfByteГTypex۰T) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerSliceOfByteГTypex۰T) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerSliceOfByteГTypex۰T) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.([]byte))
}
type callerSliceOfByteГUint32 struct {
- fn func([]byte) (uint32)
+ fn func([]byte) uint32
}
func funcMakerSliceOfByteГUint32(fn interface{}) reflectx.Func {
- f := fn.(func([]byte) (uint32))
+ f := fn.(func([]byte) uint32)
return &callerSliceOfByteГUint32{fn: f}
}
@@ -236,16 +236,16 @@ func (c *callerSliceOfByteГUint32) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerSliceOfByteГUint32) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerSliceOfByteГUint32) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.([]byte))
}
type callerSliceOfByteГUint64 struct {
- fn func([]byte) (uint64)
+ fn func([]byte) uint64
}
func funcMakerSliceOfByteГUint64(fn interface{}) reflectx.Func {
- f := fn.(func([]byte) (uint64))
+ f := fn.(func([]byte) uint64)
return &callerSliceOfByteГUint64{fn: f}
}
@@ -262,16 +262,16 @@ func (c *callerSliceOfByteГUint64) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerSliceOfByteГUint64) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerSliceOfByteГUint64) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.([]byte))
}
type callerTypex۰TГSliceOfByte struct {
- fn func(typex.T) ([]byte)
+ fn func(typex.T) []byte
}
func funcMakerTypex۰TГSliceOfByte(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) ([]byte))
+ f := fn.(func(typex.T) []byte)
return &callerTypex۰TГSliceOfByte{fn: f}
}
@@ -288,16 +288,16 @@ func (c *callerTypex۰TГSliceOfByte) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerTypex۰TГSliceOfByte) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerTypex۰TГSliceOfByte) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(typex.T))
}
type callerUint32ГSliceOfByte struct {
- fn func(uint32) ([]byte)
+ fn func(uint32) []byte
}
func funcMakerUint32ГSliceOfByte(fn interface{}) reflectx.Func {
- f := fn.(func(uint32) ([]byte))
+ f := fn.(func(uint32) []byte)
return &callerUint32ГSliceOfByte{fn: f}
}
@@ -314,16 +314,16 @@ func (c *callerUint32ГSliceOfByte) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerUint32ГSliceOfByte) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerUint32ГSliceOfByte) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(uint32))
}
type callerUint64ГSliceOfByte struct {
- fn func(uint64) ([]byte)
+ fn func(uint64) []byte
}
func funcMakerUint64ГSliceOfByte(fn interface{}) reflectx.Func {
- f := fn.(func(uint64) ([]byte))
+ f := fn.(func(uint64) []byte)
return &callerUint64ГSliceOfByte{fn: f}
}
@@ -340,9 +340,8 @@ func (c *callerUint64ГSliceOfByte) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerUint64ГSliceOfByte) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerUint64ГSliceOfByte) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(uint64))
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/io/bigqueryio/bigquery.go
b/sdks/go/pkg/beam/io/bigqueryio/bigquery.go
index cdc7ad9..626df12 100644
--- a/sdks/go/pkg/beam/io/bigqueryio/bigquery.go
+++ b/sdks/go/pkg/beam/io/bigqueryio/bigquery.go
@@ -35,8 +35,10 @@ import (
// writeSizeLimit is the maximum number of rows allowed by BQ in a write.
const writeRowLimit = 10000
+
// writeSizeLimit is the maximum number of bytes allowed in BQ write.
const writeSizeLimit = 10485760
+
// Estimate for overall message overhead.for a write message in bytes.
const writeOverheadBytes = 1024
@@ -206,10 +208,10 @@ func getInsertSize(v interface{}, schema bigquery.Schema)
(int, error) {
}
req := bq.TableDataInsertAllRequestRows{
InsertId: id,
- Json: m,
+ Json: m,
}
data, err := req.MarshalJSON()
- if (err != nil) {
+ if err != nil {
return 0, err
}
// Add 1 for comma separator between elements.
@@ -251,7 +253,7 @@ func (f *writeFn) ProcessElement(ctx context.Context, _
int, iter func(*beam.X)
if err != nil {
return fmt.Errorf("biquery write error: %v", err)
}
- if len(data) + 1 > writeRowLimit || size + current >
writeSizeLimit {
+ if len(data)+1 > writeRowLimit || size+current > writeSizeLimit
{
// Write rows in batches to comply with BQ limits.
if err := put(ctx, table, f.Type.T, data); err != nil {
return fmt.Errorf("bigquery write error
[len=%d, size=%d]: %v", len(data), size, err)
diff --git a/sdks/go/pkg/beam/testing/passert/passert.shims.go
b/sdks/go/pkg/beam/testing/passert/passert.shims.go
index df84817..8e541ab 100644
--- a/sdks/go/pkg/beam/testing/passert/passert.shims.go
+++ b/sdks/go/pkg/beam/testing/passert/passert.shims.go
@@ -44,67 +44,69 @@ func init() {
reflectx.RegisterStructWrapper(reflect.TypeOf((*failKVFn)(nil)).Elem(),
wrapMakerFailKVFn)
reflectx.RegisterStructWrapper(reflect.TypeOf((*hashFn)(nil)).Elem(),
wrapMakerHashFn)
reflectx.RegisterStructWrapper(reflect.TypeOf((*sumFn)(nil)).Elem(),
wrapMakerSumFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int,func(*int) bool)
(error))(nil)).Elem(), funcMakerIntIterIntГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int,func(*string) bool)
(error))(nil)).Elem(), funcMakerIntIterStringГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte,func(*typex.T)
bool,func(*typex.T) bool,func(t typex.T),func(t typex.T),func(t typex.T))
(error))(nil)).Elem(),
funcMakerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X,func(*typex.Y)
bool) (error))(nil)).Elem(), funcMakerTypex۰XIterTypex۰YГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X,typex.Y)
(error))(nil)).Elem(), funcMakerTypex۰XTypex۰YГError)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X)
(error))(nil)).Elem(), funcMakerTypex۰XГError)
- exec.RegisterEmitter(reflect.TypeOf((*func(typex.T) ())(nil)).Elem(),
emitMakerTypex۰T)
- exec.RegisterInput(reflect.TypeOf((*func(*int) (bool))(nil)).Elem(),
iterMakerInt)
- exec.RegisterInput(reflect.TypeOf((*func(*string) (bool))(nil)).Elem(),
iterMakerString)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.T)
(bool))(nil)).Elem(), iterMakerTypex۰T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.Y)
(bool))(nil)).Elem(), iterMakerTypex۰Y)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int, func(*int) bool)
error)(nil)).Elem(), funcMakerIntIterIntГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int, func(*string) bool)
error)(nil)).Elem(), funcMakerIntIterStringГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte, func(*typex.T)
bool, func(*typex.T) bool, func(t typex.T), func(t typex.T), func(t typex.T))
error)(nil)).Elem(),
funcMakerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, func(*typex.Y)
bool) error)(nil)).Elem(), funcMakerTypex۰XIterTypex۰YГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X, typex.Y)
error)(nil)).Elem(), funcMakerTypex۰XTypex۰YГError)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.X)
error)(nil)).Elem(), funcMakerTypex۰XГError)
+ exec.RegisterEmitter(reflect.TypeOf((*func(typex.T))(nil)).Elem(),
emitMakerTypex۰T)
+ exec.RegisterInput(reflect.TypeOf((*func(*int) bool)(nil)).Elem(),
iterMakerInt)
+ exec.RegisterInput(reflect.TypeOf((*func(*string) bool)(nil)).Elem(),
iterMakerString)
+ exec.RegisterInput(reflect.TypeOf((*func(*typex.T) bool)(nil)).Elem(),
iterMakerTypex۰T)
+ exec.RegisterInput(reflect.TypeOf((*func(*typex.Y) bool)(nil)).Elem(),
iterMakerTypex۰Y)
}
func wrapMakerDiffFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*diffFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(*typex.T) bool, a2 func(*typex.T) bool, a3 func(t typex.T), a4 func(t
typex.T), a5 func(t typex.T)) (error) { return dfn.ProcessElement(a0, a1, a2,
a3, a4, a5) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(*typex.T) bool, a2 func(*typex.T) bool, a3 func(t typex.T), a4 func(t
typex.T), a5 func(t typex.T)) error {
+ return dfn.ProcessElement(a0, a1, a2, a3, a4, a5)
+ }),
}
}
func wrapMakerFailFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*failFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 typex.X) (error) {
return dfn.ProcessElement(a0) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 typex.X) error {
return dfn.ProcessElement(a0) }),
}
}
func wrapMakerFailGBKFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*failGBKFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 typex.X, a1
func(*typex.Y) bool) (error) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 typex.X, a1
func(*typex.Y) bool) error { return dfn.ProcessElement(a0, a1) }),
}
}
func wrapMakerFailKVFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*failKVFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 typex.X, a1
typex.Y) (error) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 typex.X, a1
typex.Y) error { return dfn.ProcessElement(a0, a1) }),
}
}
func wrapMakerHashFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*hashFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 int, a1
func(*string) bool) (error) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 int, a1
func(*string) bool) error { return dfn.ProcessElement(a0, a1) }),
}
}
func wrapMakerSumFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*sumFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 int, a1 func(*int)
bool) (error) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 int, a1 func(*int)
bool) error { return dfn.ProcessElement(a0, a1) }),
}
}
type callerIntIterIntГError struct {
- fn func(int,func(*int) bool) (error)
+ fn func(int, func(*int) bool) error
}
func funcMakerIntIterIntГError(fn interface{}) reflectx.Func {
- f := fn.(func(int,func(*int) bool) (error))
+ f := fn.(func(int, func(*int) bool) error)
return &callerIntIterIntГError{fn: f}
}
@@ -121,16 +123,16 @@ func (c *callerIntIterIntГError) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerIntIterIntГError) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerIntIterIntГError) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int), arg1.(func(*int) bool))
}
type callerIntIterStringГError struct {
- fn func(int,func(*string) bool) (error)
+ fn func(int, func(*string) bool) error
}
func funcMakerIntIterStringГError(fn interface{}) reflectx.Func {
- f := fn.(func(int,func(*string) bool) (error))
+ f := fn.(func(int, func(*string) bool) error)
return &callerIntIterStringГError{fn: f}
}
@@ -147,16 +149,16 @@ func (c *callerIntIterStringГError) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerIntIterStringГError) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerIntIterStringГError) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(int), arg1.(func(*string) bool))
}
type
callerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError
struct {
- fn func([]byte,func(*typex.T) bool,func(*typex.T) bool,func(t
typex.T),func(t typex.T),func(t typex.T)) (error)
+ fn func([]byte, func(*typex.T) bool, func(*typex.T) bool, func(t
typex.T), func(t typex.T), func(t typex.T)) error
}
func
funcMakerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError(fn
interface{}) reflectx.Func {
- f := fn.(func([]byte,func(*typex.T) bool,func(*typex.T) bool,func(t
typex.T),func(t typex.T),func(t typex.T)) (error))
+ f := fn.(func([]byte, func(*typex.T) bool, func(*typex.T) bool, func(t
typex.T), func(t typex.T), func(t typex.T)) error)
return
&callerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError{fn:
f}
}
@@ -173,16 +175,16 @@ func (c
*callerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTy
return []interface{}{out0}
}
-func (c
*callerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError)
Call6x1(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) (interface{}) {
+func (c
*callerSliceOfByteIterTypex۰TIterTypex۰TEmitTypex۰TEmitTypex۰TEmitTypex۰TГError)
Call6x1(arg0, arg1, arg2, arg3, arg4, arg5 interface{}) interface{} {
return c.fn(arg0.([]byte), arg1.(func(*typex.T) bool),
arg2.(func(*typex.T) bool), arg3.(func(t typex.T)), arg4.(func(t typex.T)),
arg5.(func(t typex.T)))
}
type callerTypex۰XIterTypex۰YГError struct {
- fn func(typex.X,func(*typex.Y) bool) (error)
+ fn func(typex.X, func(*typex.Y) bool) error
}
func funcMakerTypex۰XIterTypex۰YГError(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X,func(*typex.Y) bool) (error))
+ f := fn.(func(typex.X, func(*typex.Y) bool) error)
return &callerTypex۰XIterTypex۰YГError{fn: f}
}
@@ -199,16 +201,16 @@ func (c *callerTypex۰XIterTypex۰YГError) Call(args
[]interface{}) []interface
return []interface{}{out0}
}
-func (c *callerTypex۰XIterTypex۰YГError) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerTypex۰XIterTypex۰YГError) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(typex.X), arg1.(func(*typex.Y) bool))
}
type callerTypex۰XTypex۰YГError struct {
- fn func(typex.X,typex.Y) (error)
+ fn func(typex.X, typex.Y) error
}
func funcMakerTypex۰XTypex۰YГError(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X,typex.Y) (error))
+ f := fn.(func(typex.X, typex.Y) error)
return &callerTypex۰XTypex۰YГError{fn: f}
}
@@ -225,16 +227,16 @@ func (c *callerTypex۰XTypex۰YГError) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerTypex۰XTypex۰YГError) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerTypex۰XTypex۰YГError) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(typex.X), arg1.(typex.Y))
}
type callerTypex۰XГError struct {
- fn func(typex.X) (error)
+ fn func(typex.X) error
}
func funcMakerTypex۰XГError(fn interface{}) reflectx.Func {
- f := fn.(func(typex.X) (error))
+ f := fn.(func(typex.X) error)
return &callerTypex۰XГError{fn: f}
}
@@ -251,17 +253,17 @@ func (c *callerTypex۰XГError) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerTypex۰XГError) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerTypex۰XГError) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(typex.X))
}
type emitNative struct {
- n exec.ElementProcessor
- fn interface{}
+ n exec.ElementProcessor
+ fn interface{}
- ctx context.Context
- ws []typex.Window
- et typex.EventTime
+ ctx context.Context
+ ws []typex.Window
+ et typex.EventTime
value exec.FullValue
}
@@ -290,8 +292,8 @@ func (e *emitNative) invokeTypex۰T(val typex.T) {
}
type iterNative struct {
- s exec.ReStream
- fn interface{}
+ s exec.ReStream
+ fn interface{}
// cur is the "current" stream, if any.
cur exec.Stream
@@ -390,5 +392,4 @@ func (v *iterNative) readTypex۰Y(value *typex.Y) bool {
return true
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/transforms/filter/filter.shims.go
b/sdks/go/pkg/beam/transforms/filter/filter.shims.go
index a24046d..830ee5a 100644
--- a/sdks/go/pkg/beam/transforms/filter/filter.shims.go
+++ b/sdks/go/pkg/beam/transforms/filter/filter.shims.go
@@ -36,28 +36,28 @@ func init() {
runtime.RegisterFunction(mapFn)
runtime.RegisterType(reflect.TypeOf((*filterFn)(nil)).Elem())
reflectx.RegisterStructWrapper(reflect.TypeOf((*filterFn)(nil)).Elem(),
wrapMakerFilterFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T,func(typex.T))
())(nil)).Elem(), funcMakerTypex۰TEmitTypex۰TГ)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T,func(*int) bool)
(typex.T))(nil)).Elem(), funcMakerTypex۰TIterIntГTypex۰T)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
(typex.T,int))(nil)).Elem(), funcMakerTypex۰TГTypex۰TInt)
- reflectx.RegisterFunc(reflect.TypeOf((*func() ())(nil)).Elem(),
funcMakerГ)
- exec.RegisterEmitter(reflect.TypeOf((*func(typex.T) ())(nil)).Elem(),
emitMakerTypex۰T)
- exec.RegisterInput(reflect.TypeOf((*func(*int) (bool))(nil)).Elem(),
iterMakerInt)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T,
func(typex.T)))(nil)).Elem(), funcMakerTypex۰TEmitTypex۰TГ)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T, func(*int) bool)
typex.T)(nil)).Elem(), funcMakerTypex۰TIterIntГTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T) (typex.T,
int))(nil)).Elem(), funcMakerTypex۰TГTypex۰TInt)
+ reflectx.RegisterFunc(reflect.TypeOf((*func())(nil)).Elem(), funcMakerГ)
+ exec.RegisterEmitter(reflect.TypeOf((*func(typex.T))(nil)).Elem(),
emitMakerTypex۰T)
+ exec.RegisterInput(reflect.TypeOf((*func(*int) bool)(nil)).Elem(),
iterMakerInt)
}
func wrapMakerFilterFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*filterFn)
return map[string]reflectx.Func{
"ProcessElement": reflectx.MakeFunc(func(a0 typex.T, a1
func(typex.T)) { dfn.ProcessElement(a0, a1) }),
- "Setup": reflectx.MakeFunc(func() { dfn.Setup() }),
+ "Setup": reflectx.MakeFunc(func() { dfn.Setup() }),
}
}
type callerTypex۰TEmitTypex۰TГ struct {
- fn func(typex.T,func(typex.T)) ()
+ fn func(typex.T, func(typex.T))
}
func funcMakerTypex۰TEmitTypex۰TГ(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T,func(typex.T)) ())
+ f := fn.(func(typex.T, func(typex.T)))
return &callerTypex۰TEmitTypex۰TГ{fn: f}
}
@@ -74,16 +74,16 @@ func (c *callerTypex۰TEmitTypex۰TГ) Call(args
[]interface{}) []interface{} {
return []interface{}{}
}
-func (c *callerTypex۰TEmitTypex۰TГ) Call2x0(arg0, arg1 interface{}) () {
+func (c *callerTypex۰TEmitTypex۰TГ) Call2x0(arg0, arg1 interface{}) {
c.fn(arg0.(typex.T), arg1.(func(typex.T)))
}
type callerTypex۰TIterIntГTypex۰T struct {
- fn func(typex.T,func(*int) bool) (typex.T)
+ fn func(typex.T, func(*int) bool) typex.T
}
func funcMakerTypex۰TIterIntГTypex۰T(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T,func(*int) bool) (typex.T))
+ f := fn.(func(typex.T, func(*int) bool) typex.T)
return &callerTypex۰TIterIntГTypex۰T{fn: f}
}
@@ -100,16 +100,16 @@ func (c *callerTypex۰TIterIntГTypex۰T) Call(args
[]interface{}) []interface{}
return []interface{}{out0}
}
-func (c *callerTypex۰TIterIntГTypex۰T) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerTypex۰TIterIntГTypex۰T) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(typex.T), arg1.(func(*int) bool))
}
type callerTypex۰TГTypex۰TInt struct {
- fn func(typex.T) (typex.T,int)
+ fn func(typex.T) (typex.T, int)
}
func funcMakerTypex۰TГTypex۰TInt(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) (typex.T,int))
+ f := fn.(func(typex.T) (typex.T, int))
return &callerTypex۰TГTypex۰TInt{fn: f}
}
@@ -131,11 +131,11 @@ func (c *callerTypex۰TГTypex۰TInt) Call1x2(arg0
interface{}) (interface{}, in
}
type callerГ struct {
- fn func() ()
+ fn func()
}
func funcMakerГ(fn interface{}) reflectx.Func {
- f := fn.(func() ())
+ f := fn.(func())
return &callerГ{fn: f}
}
@@ -152,17 +152,17 @@ func (c *callerГ) Call(args []interface{}) []interface{} {
return []interface{}{}
}
-func (c *callerГ) Call0x0() () {
+func (c *callerГ) Call0x0() {
c.fn()
}
type emitNative struct {
- n exec.ElementProcessor
- fn interface{}
+ n exec.ElementProcessor
+ fn interface{}
- ctx context.Context
- ws []typex.Window
- et typex.EventTime
+ ctx context.Context
+ ws []typex.Window
+ et typex.EventTime
value exec.FullValue
}
@@ -191,8 +191,8 @@ func (e *emitNative) invokeTypex۰T(val typex.T) {
}
type iterNative struct {
- s exec.ReStream
- fn interface{}
+ s exec.ReStream
+ fn interface{}
// cur is the "current" stream, if any.
cur exec.Stream
@@ -237,5 +237,4 @@ func (v *iterNative) readInt(value *int) bool {
return true
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/transforms/stats/stats.shims.go
b/sdks/go/pkg/beam/transforms/stats/stats.shims.go
index a72fe33..3af95fb 100644
--- a/sdks/go/pkg/beam/transforms/stats/stats.shims.go
+++ b/sdks/go/pkg/beam/transforms/stats/stats.shims.go
@@ -68,41 +68,41 @@ func init() {
runtime.RegisterType(reflect.TypeOf((*meanAccum)(nil)).Elem())
runtime.RegisterType(reflect.TypeOf((*meanFn)(nil)).Elem())
reflectx.RegisterStructWrapper(reflect.TypeOf((*meanFn)(nil)).Elem(),
wrapMakerMeanFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(float32,float32)
(float32))(nil)).Elem(), funcMakerFloat32Float32ГFloat32)
- reflectx.RegisterFunc(reflect.TypeOf((*func(float64,float64)
(float64))(nil)).Elem(), funcMakerFloat64Float64ГFloat64)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int16,int16)
(int16))(nil)).Elem(), funcMakerInt16Int16ГInt16)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int32,int32)
(int32))(nil)).Elem(), funcMakerInt32Int32ГInt32)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int64,int64)
(int64))(nil)).Elem(), funcMakerInt64Int64ГInt64)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int8,int8)
(int8))(nil)).Elem(), funcMakerInt8Int8ГInt8)
- reflectx.RegisterFunc(reflect.TypeOf((*func(int,int)
(int))(nil)).Elem(), funcMakerIntIntГInt)
- reflectx.RegisterFunc(reflect.TypeOf((*func(meanAccum,typex.T)
(meanAccum))(nil)).Elem(), funcMakerMeanAccumTypex۰TГMeanAccum)
- reflectx.RegisterFunc(reflect.TypeOf((*func(meanAccum)
(float64))(nil)).Elem(), funcMakerMeanAccumГFloat64)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]meanAccum)
(meanAccum))(nil)).Elem(), funcMakerSliceOfMeanAccumГMeanAccum)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T)
(typex.T,int))(nil)).Elem(), funcMakerTypex۰TГTypex۰TInt)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint16,uint16)
(uint16))(nil)).Elem(), funcMakerUint16Uint16ГUint16)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint32,uint32)
(uint32))(nil)).Elem(), funcMakerUint32Uint32ГUint32)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint64,uint64)
(uint64))(nil)).Elem(), funcMakerUint64Uint64ГUint64)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint8,uint8)
(uint8))(nil)).Elem(), funcMakerUint8Uint8ГUint8)
- reflectx.RegisterFunc(reflect.TypeOf((*func(uint,uint)
(uint))(nil)).Elem(), funcMakerUintUintГUint)
- reflectx.RegisterFunc(reflect.TypeOf((*func()
(meanAccum))(nil)).Elem(), funcMakerГMeanAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(float32, float32)
float32)(nil)).Elem(), funcMakerFloat32Float32ГFloat32)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(float64, float64)
float64)(nil)).Elem(), funcMakerFloat64Float64ГFloat64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int16, int16)
int16)(nil)).Elem(), funcMakerInt16Int16ГInt16)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int32, int32)
int32)(nil)).Elem(), funcMakerInt32Int32ГInt32)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int64, int64)
int64)(nil)).Elem(), funcMakerInt64Int64ГInt64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int8, int8)
int8)(nil)).Elem(), funcMakerInt8Int8ГInt8)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(int, int)
int)(nil)).Elem(), funcMakerIntIntГInt)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(meanAccum, typex.T)
meanAccum)(nil)).Elem(), funcMakerMeanAccumTypex۰TГMeanAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(meanAccum)
float64)(nil)).Elem(), funcMakerMeanAccumГFloat64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]meanAccum)
meanAccum)(nil)).Elem(), funcMakerSliceOfMeanAccumГMeanAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T) (typex.T,
int))(nil)).Elem(), funcMakerTypex۰TГTypex۰TInt)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint16, uint16)
uint16)(nil)).Elem(), funcMakerUint16Uint16ГUint16)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint32, uint32)
uint32)(nil)).Elem(), funcMakerUint32Uint32ГUint32)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint64, uint64)
uint64)(nil)).Elem(), funcMakerUint64Uint64ГUint64)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint8, uint8)
uint8)(nil)).Elem(), funcMakerUint8Uint8ГUint8)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(uint, uint)
uint)(nil)).Elem(), funcMakerUintUintГUint)
+ reflectx.RegisterFunc(reflect.TypeOf((*func() meanAccum)(nil)).Elem(),
funcMakerГMeanAccum)
}
func wrapMakerMeanFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*meanFn)
return map[string]reflectx.Func{
- "AddInput": reflectx.MakeFunc(func(a0 meanAccum, a1 typex.T)
(meanAccum) { return dfn.AddInput(a0, a1) }),
- "CreateAccumulator": reflectx.MakeFunc(func() (meanAccum) {
return dfn.CreateAccumulator() }),
- "ExtractOutput": reflectx.MakeFunc(func(a0 meanAccum) (float64)
{ return dfn.ExtractOutput(a0) }),
- "MergeAccumulators": reflectx.MakeFunc(func(a0 []meanAccum)
(meanAccum) { return dfn.MergeAccumulators(a0) }),
+ "AddInput": reflectx.MakeFunc(func(a0 meanAccum, a1
typex.T) meanAccum { return dfn.AddInput(a0, a1) }),
+ "CreateAccumulator": reflectx.MakeFunc(func() meanAccum {
return dfn.CreateAccumulator() }),
+ "ExtractOutput": reflectx.MakeFunc(func(a0 meanAccum)
float64 { return dfn.ExtractOutput(a0) }),
+ "MergeAccumulators": reflectx.MakeFunc(func(a0 []meanAccum)
meanAccum { return dfn.MergeAccumulators(a0) }),
}
}
type callerFloat32Float32ГFloat32 struct {
- fn func(float32,float32) (float32)
+ fn func(float32, float32) float32
}
func funcMakerFloat32Float32ГFloat32(fn interface{}) reflectx.Func {
- f := fn.(func(float32,float32) (float32))
+ f := fn.(func(float32, float32) float32)
return &callerFloat32Float32ГFloat32{fn: f}
}
@@ -119,16 +119,16 @@ func (c *callerFloat32Float32ГFloat32) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerFloat32Float32ГFloat32) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerFloat32Float32ГFloat32) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(float32), arg1.(float32))
}
type callerFloat64Float64ГFloat64 struct {
- fn func(float64,float64) (float64)
+ fn func(float64, float64) float64
}
func funcMakerFloat64Float64ГFloat64(fn interface{}) reflectx.Func {
- f := fn.(func(float64,float64) (float64))
+ f := fn.(func(float64, float64) float64)
return &callerFloat64Float64ГFloat64{fn: f}
}
@@ -145,16 +145,16 @@ func (c *callerFloat64Float64ГFloat64) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerFloat64Float64ГFloat64) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerFloat64Float64ГFloat64) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(float64), arg1.(float64))
}
type callerInt16Int16ГInt16 struct {
- fn func(int16,int16) (int16)
+ fn func(int16, int16) int16
}
func funcMakerInt16Int16ГInt16(fn interface{}) reflectx.Func {
- f := fn.(func(int16,int16) (int16))
+ f := fn.(func(int16, int16) int16)
return &callerInt16Int16ГInt16{fn: f}
}
@@ -171,16 +171,16 @@ func (c *callerInt16Int16ГInt16) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerInt16Int16ГInt16) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerInt16Int16ГInt16) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int16), arg1.(int16))
}
type callerInt32Int32ГInt32 struct {
- fn func(int32,int32) (int32)
+ fn func(int32, int32) int32
}
func funcMakerInt32Int32ГInt32(fn interface{}) reflectx.Func {
- f := fn.(func(int32,int32) (int32))
+ f := fn.(func(int32, int32) int32)
return &callerInt32Int32ГInt32{fn: f}
}
@@ -197,16 +197,16 @@ func (c *callerInt32Int32ГInt32) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerInt32Int32ГInt32) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerInt32Int32ГInt32) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int32), arg1.(int32))
}
type callerInt64Int64ГInt64 struct {
- fn func(int64,int64) (int64)
+ fn func(int64, int64) int64
}
func funcMakerInt64Int64ГInt64(fn interface{}) reflectx.Func {
- f := fn.(func(int64,int64) (int64))
+ f := fn.(func(int64, int64) int64)
return &callerInt64Int64ГInt64{fn: f}
}
@@ -223,16 +223,16 @@ func (c *callerInt64Int64ГInt64) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerInt64Int64ГInt64) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerInt64Int64ГInt64) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int64), arg1.(int64))
}
type callerInt8Int8ГInt8 struct {
- fn func(int8,int8) (int8)
+ fn func(int8, int8) int8
}
func funcMakerInt8Int8ГInt8(fn interface{}) reflectx.Func {
- f := fn.(func(int8,int8) (int8))
+ f := fn.(func(int8, int8) int8)
return &callerInt8Int8ГInt8{fn: f}
}
@@ -249,16 +249,16 @@ func (c *callerInt8Int8ГInt8) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerInt8Int8ГInt8) Call2x1(arg0, arg1 interface{}) (interface{}) {
+func (c *callerInt8Int8ГInt8) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int8), arg1.(int8))
}
type callerIntIntГInt struct {
- fn func(int,int) (int)
+ fn func(int, int) int
}
func funcMakerIntIntГInt(fn interface{}) reflectx.Func {
- f := fn.(func(int,int) (int))
+ f := fn.(func(int, int) int)
return &callerIntIntГInt{fn: f}
}
@@ -275,16 +275,16 @@ func (c *callerIntIntГInt) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerIntIntГInt) Call2x1(arg0, arg1 interface{}) (interface{}) {
+func (c *callerIntIntГInt) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(int), arg1.(int))
}
type callerMeanAccumTypex۰TГMeanAccum struct {
- fn func(meanAccum,typex.T) (meanAccum)
+ fn func(meanAccum, typex.T) meanAccum
}
func funcMakerMeanAccumTypex۰TГMeanAccum(fn interface{}) reflectx.Func {
- f := fn.(func(meanAccum,typex.T) (meanAccum))
+ f := fn.(func(meanAccum, typex.T) meanAccum)
return &callerMeanAccumTypex۰TГMeanAccum{fn: f}
}
@@ -301,16 +301,16 @@ func (c *callerMeanAccumTypex۰TГMeanAccum) Call(args
[]interface{}) []interfac
return []interface{}{out0}
}
-func (c *callerMeanAccumTypex۰TГMeanAccum) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerMeanAccumTypex۰TГMeanAccum) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(meanAccum), arg1.(typex.T))
}
type callerMeanAccumГFloat64 struct {
- fn func(meanAccum) (float64)
+ fn func(meanAccum) float64
}
func funcMakerMeanAccumГFloat64(fn interface{}) reflectx.Func {
- f := fn.(func(meanAccum) (float64))
+ f := fn.(func(meanAccum) float64)
return &callerMeanAccumГFloat64{fn: f}
}
@@ -327,16 +327,16 @@ func (c *callerMeanAccumГFloat64) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerMeanAccumГFloat64) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerMeanAccumГFloat64) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(meanAccum))
}
type callerSliceOfMeanAccumГMeanAccum struct {
- fn func([]meanAccum) (meanAccum)
+ fn func([]meanAccum) meanAccum
}
func funcMakerSliceOfMeanAccumГMeanAccum(fn interface{}) reflectx.Func {
- f := fn.(func([]meanAccum) (meanAccum))
+ f := fn.(func([]meanAccum) meanAccum)
return &callerSliceOfMeanAccumГMeanAccum{fn: f}
}
@@ -353,16 +353,16 @@ func (c *callerSliceOfMeanAccumГMeanAccum) Call(args
[]interface{}) []interface
return []interface{}{out0}
}
-func (c *callerSliceOfMeanAccumГMeanAccum) Call1x1(arg0 interface{})
(interface{}) {
+func (c *callerSliceOfMeanAccumГMeanAccum) Call1x1(arg0 interface{})
interface{} {
return c.fn(arg0.([]meanAccum))
}
type callerTypex۰TГTypex۰TInt struct {
- fn func(typex.T) (typex.T,int)
+ fn func(typex.T) (typex.T, int)
}
func funcMakerTypex۰TГTypex۰TInt(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) (typex.T,int))
+ f := fn.(func(typex.T) (typex.T, int))
return &callerTypex۰TГTypex۰TInt{fn: f}
}
@@ -384,11 +384,11 @@ func (c *callerTypex۰TГTypex۰TInt) Call1x2(arg0
interface{}) (interface{}, in
}
type callerUint16Uint16ГUint16 struct {
- fn func(uint16,uint16) (uint16)
+ fn func(uint16, uint16) uint16
}
func funcMakerUint16Uint16ГUint16(fn interface{}) reflectx.Func {
- f := fn.(func(uint16,uint16) (uint16))
+ f := fn.(func(uint16, uint16) uint16)
return &callerUint16Uint16ГUint16{fn: f}
}
@@ -405,16 +405,16 @@ func (c *callerUint16Uint16ГUint16) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerUint16Uint16ГUint16) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerUint16Uint16ГUint16) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(uint16), arg1.(uint16))
}
type callerUint32Uint32ГUint32 struct {
- fn func(uint32,uint32) (uint32)
+ fn func(uint32, uint32) uint32
}
func funcMakerUint32Uint32ГUint32(fn interface{}) reflectx.Func {
- f := fn.(func(uint32,uint32) (uint32))
+ f := fn.(func(uint32, uint32) uint32)
return &callerUint32Uint32ГUint32{fn: f}
}
@@ -431,16 +431,16 @@ func (c *callerUint32Uint32ГUint32) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerUint32Uint32ГUint32) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerUint32Uint32ГUint32) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(uint32), arg1.(uint32))
}
type callerUint64Uint64ГUint64 struct {
- fn func(uint64,uint64) (uint64)
+ fn func(uint64, uint64) uint64
}
func funcMakerUint64Uint64ГUint64(fn interface{}) reflectx.Func {
- f := fn.(func(uint64,uint64) (uint64))
+ f := fn.(func(uint64, uint64) uint64)
return &callerUint64Uint64ГUint64{fn: f}
}
@@ -457,16 +457,16 @@ func (c *callerUint64Uint64ГUint64) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerUint64Uint64ГUint64) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerUint64Uint64ГUint64) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(uint64), arg1.(uint64))
}
type callerUint8Uint8ГUint8 struct {
- fn func(uint8,uint8) (uint8)
+ fn func(uint8, uint8) uint8
}
func funcMakerUint8Uint8ГUint8(fn interface{}) reflectx.Func {
- f := fn.(func(uint8,uint8) (uint8))
+ f := fn.(func(uint8, uint8) uint8)
return &callerUint8Uint8ГUint8{fn: f}
}
@@ -483,16 +483,16 @@ func (c *callerUint8Uint8ГUint8) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerUint8Uint8ГUint8) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerUint8Uint8ГUint8) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(uint8), arg1.(uint8))
}
type callerUintUintГUint struct {
- fn func(uint,uint) (uint)
+ fn func(uint, uint) uint
}
func funcMakerUintUintГUint(fn interface{}) reflectx.Func {
- f := fn.(func(uint,uint) (uint))
+ f := fn.(func(uint, uint) uint)
return &callerUintUintГUint{fn: f}
}
@@ -509,16 +509,16 @@ func (c *callerUintUintГUint) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerUintUintГUint) Call2x1(arg0, arg1 interface{}) (interface{}) {
+func (c *callerUintUintГUint) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(uint), arg1.(uint))
}
type callerГMeanAccum struct {
- fn func() (meanAccum)
+ fn func() meanAccum
}
func funcMakerГMeanAccum(fn interface{}) reflectx.Func {
- f := fn.(func() (meanAccum))
+ f := fn.(func() meanAccum)
return &callerГMeanAccum{fn: f}
}
@@ -535,9 +535,8 @@ func (c *callerГMeanAccum) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerГMeanAccum) Call0x1() (interface{}) {
+func (c *callerГMeanAccum) Call0x1() interface{} {
return c.fn()
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/transforms/top/top.shims.go
b/sdks/go/pkg/beam/transforms/top/top.shims.go
index a0559d9..ac93f91 100644
--- a/sdks/go/pkg/beam/transforms/top/top.shims.go
+++ b/sdks/go/pkg/beam/transforms/top/top.shims.go
@@ -31,30 +31,30 @@ func init() {
runtime.RegisterType(reflect.TypeOf((*accum)(nil)).Elem())
runtime.RegisterType(reflect.TypeOf((*combineFn)(nil)).Elem())
reflectx.RegisterStructWrapper(reflect.TypeOf((*combineFn)(nil)).Elem(),
wrapMakerCombineFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(accum,accum)
(accum))(nil)).Elem(), funcMakerAccumAccumГAccum)
- reflectx.RegisterFunc(reflect.TypeOf((*func(accum,typex.T)
(accum))(nil)).Elem(), funcMakerAccumTypex۰TГAccum)
- reflectx.RegisterFunc(reflect.TypeOf((*func(accum)
([]typex.T))(nil)).Elem(), funcMakerAccumГSliceOfTypex۰T)
- reflectx.RegisterFunc(reflect.TypeOf((*func() ())(nil)).Elem(),
funcMakerГ)
- reflectx.RegisterFunc(reflect.TypeOf((*func() (accum))(nil)).Elem(),
funcMakerГAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(accum, accum)
accum)(nil)).Elem(), funcMakerAccumAccumГAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(accum, typex.T)
accum)(nil)).Elem(), funcMakerAccumTypex۰TГAccum)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(accum)
[]typex.T)(nil)).Elem(), funcMakerAccumГSliceOfTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func())(nil)).Elem(), funcMakerГ)
+ reflectx.RegisterFunc(reflect.TypeOf((*func() accum)(nil)).Elem(),
funcMakerГAccum)
}
func wrapMakerCombineFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*combineFn)
return map[string]reflectx.Func{
- "AddInput": reflectx.MakeFunc(func(a0 accum, a1 typex.T)
(accum) { return dfn.AddInput(a0, a1) }),
- "CreateAccumulator": reflectx.MakeFunc(func() (accum) { return
dfn.CreateAccumulator() }),
- "ExtractOutput": reflectx.MakeFunc(func(a0 accum) ([]typex.T) {
return dfn.ExtractOutput(a0) }),
- "MergeAccumulators": reflectx.MakeFunc(func(a0 accum, a1 accum)
(accum) { return dfn.MergeAccumulators(a0, a1) }),
- "Setup": reflectx.MakeFunc(func() { dfn.Setup() }),
+ "AddInput": reflectx.MakeFunc(func(a0 accum, a1
typex.T) accum { return dfn.AddInput(a0, a1) }),
+ "CreateAccumulator": reflectx.MakeFunc(func() accum { return
dfn.CreateAccumulator() }),
+ "ExtractOutput": reflectx.MakeFunc(func(a0 accum) []typex.T
{ return dfn.ExtractOutput(a0) }),
+ "MergeAccumulators": reflectx.MakeFunc(func(a0 accum, a1 accum)
accum { return dfn.MergeAccumulators(a0, a1) }),
+ "Setup": reflectx.MakeFunc(func() { dfn.Setup() }),
}
}
type callerAccumAccumГAccum struct {
- fn func(accum,accum) (accum)
+ fn func(accum, accum) accum
}
func funcMakerAccumAccumГAccum(fn interface{}) reflectx.Func {
- f := fn.(func(accum,accum) (accum))
+ f := fn.(func(accum, accum) accum)
return &callerAccumAccumГAccum{fn: f}
}
@@ -71,16 +71,16 @@ func (c *callerAccumAccumГAccum) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerAccumAccumГAccum) Call2x1(arg0, arg1 interface{}) (interface{})
{
+func (c *callerAccumAccumГAccum) Call2x1(arg0, arg1 interface{}) interface{} {
return c.fn(arg0.(accum), arg1.(accum))
}
type callerAccumTypex۰TГAccum struct {
- fn func(accum,typex.T) (accum)
+ fn func(accum, typex.T) accum
}
func funcMakerAccumTypex۰TГAccum(fn interface{}) reflectx.Func {
- f := fn.(func(accum,typex.T) (accum))
+ f := fn.(func(accum, typex.T) accum)
return &callerAccumTypex۰TГAccum{fn: f}
}
@@ -97,16 +97,16 @@ func (c *callerAccumTypex۰TГAccum) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerAccumTypex۰TГAccum) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerAccumTypex۰TГAccum) Call2x1(arg0, arg1 interface{}) interface{}
{
return c.fn(arg0.(accum), arg1.(typex.T))
}
type callerAccumГSliceOfTypex۰T struct {
- fn func(accum) ([]typex.T)
+ fn func(accum) []typex.T
}
func funcMakerAccumГSliceOfTypex۰T(fn interface{}) reflectx.Func {
- f := fn.(func(accum) ([]typex.T))
+ f := fn.(func(accum) []typex.T)
return &callerAccumГSliceOfTypex۰T{fn: f}
}
@@ -123,16 +123,16 @@ func (c *callerAccumГSliceOfTypex۰T) Call(args
[]interface{}) []interface{} {
return []interface{}{out0}
}
-func (c *callerAccumГSliceOfTypex۰T) Call1x1(arg0 interface{}) (interface{}) {
+func (c *callerAccumГSliceOfTypex۰T) Call1x1(arg0 interface{}) interface{} {
return c.fn(arg0.(accum))
}
type callerГ struct {
- fn func() ()
+ fn func()
}
func funcMakerГ(fn interface{}) reflectx.Func {
- f := fn.(func() ())
+ f := fn.(func())
return &callerГ{fn: f}
}
@@ -149,16 +149,16 @@ func (c *callerГ) Call(args []interface{}) []interface{} {
return []interface{}{}
}
-func (c *callerГ) Call0x0() () {
+func (c *callerГ) Call0x0() {
c.fn()
}
type callerГAccum struct {
- fn func() (accum)
+ fn func() accum
}
func funcMakerГAccum(fn interface{}) reflectx.Func {
- f := fn.(func() (accum))
+ f := fn.(func() accum)
return &callerГAccum{fn: f}
}
@@ -175,9 +175,8 @@ func (c *callerГAccum) Call(args []interface{})
[]interface{} {
return []interface{}{out0}
}
-func (c *callerГAccum) Call0x1() (interface{}) {
+func (c *callerГAccum) Call0x1() interface{} {
return c.fn()
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/go/pkg/beam/x/debug/debug.shims.go
b/sdks/go/pkg/beam/x/debug/debug.shims.go
index 67dda11..94b9034 100644
--- a/sdks/go/pkg/beam/x/debug/debug.shims.go
+++ b/sdks/go/pkg/beam/x/debug/debug.shims.go
@@ -44,17 +44,17 @@ func init() {
reflectx.RegisterStructWrapper(reflect.TypeOf((*printFn)(nil)).Elem(),
wrapMakerPrintFn)
reflectx.RegisterStructWrapper(reflect.TypeOf((*printGBKFn)(nil)).Elem(),
wrapMakerPrintGBKFn)
reflectx.RegisterStructWrapper(reflect.TypeOf((*printKVFn)(nil)).Elem(),
wrapMakerPrintKVFn)
- reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context,typex.T)
(typex.T))(nil)).Elem(), funcMakerContext۰ContextTypex۰TГTypex۰T)
-
reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context,typex.X,func(*typex.Y)
bool) (typex.X))(nil)).Elem(),
funcMakerContext۰ContextTypex۰XIterTypex۰YГTypex۰X)
-
reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context,typex.X,typex.Y)
(typex.X,typex.Y))(nil)).Elem(),
funcMakerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte,func(*typex.T)
bool,func(typex.T)) ())(nil)).Elem(),
funcMakerSliceOfByteIterTypex۰TEmitTypex۰TГ)
- reflectx.RegisterFunc(reflect.TypeOf((*func([]byte,func(*typex.X,
*typex.Y) bool,func(typex.X, typex.Y)) ())(nil)).Elem(),
funcMakerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ)
- reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T) ())(nil)).Elem(),
funcMakerTypex۰TГ)
- exec.RegisterEmitter(reflect.TypeOf((*func(typex.T) ())(nil)).Elem(),
emitMakerTypex۰T)
- exec.RegisterEmitter(reflect.TypeOf((*func(typex.X,typex.Y)
())(nil)).Elem(), emitMakerTypex۰XTypex۰Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.T)
(bool))(nil)).Elem(), iterMakerTypex۰T)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.X,*typex.Y)
(bool))(nil)).Elem(), iterMakerTypex۰XTypex۰Y)
- exec.RegisterInput(reflect.TypeOf((*func(*typex.Y)
(bool))(nil)).Elem(), iterMakerTypex۰Y)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context, typex.T)
typex.T)(nil)).Elem(), funcMakerContext۰ContextTypex۰TГTypex۰T)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context, typex.X,
func(*typex.Y) bool) typex.X)(nil)).Elem(),
funcMakerContext۰ContextTypex۰XIterTypex۰YГTypex۰X)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(context.Context, typex.X,
typex.Y) (typex.X, typex.Y))(nil)).Elem(),
funcMakerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte, func(*typex.T)
bool, func(typex.T)))(nil)).Elem(), funcMakerSliceOfByteIterTypex۰TEmitTypex۰TГ)
+ reflectx.RegisterFunc(reflect.TypeOf((*func([]byte, func(*typex.X,
*typex.Y) bool, func(typex.X, typex.Y)))(nil)).Elem(),
funcMakerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ)
+ reflectx.RegisterFunc(reflect.TypeOf((*func(typex.T))(nil)).Elem(),
funcMakerTypex۰TГ)
+ exec.RegisterEmitter(reflect.TypeOf((*func(typex.T))(nil)).Elem(),
emitMakerTypex۰T)
+ exec.RegisterEmitter(reflect.TypeOf((*func(typex.X,
typex.Y))(nil)).Elem(), emitMakerTypex۰XTypex۰Y)
+ exec.RegisterInput(reflect.TypeOf((*func(*typex.T) bool)(nil)).Elem(),
iterMakerTypex۰T)
+ exec.RegisterInput(reflect.TypeOf((*func(*typex.X, *typex.Y)
bool)(nil)).Elem(), iterMakerTypex۰XTypex۰Y)
+ exec.RegisterInput(reflect.TypeOf((*func(*typex.Y) bool)(nil)).Elem(),
iterMakerTypex۰Y)
}
func wrapMakerHeadFn(fn interface{}) map[string]reflectx.Func {
@@ -67,37 +67,43 @@ func wrapMakerHeadFn(fn interface{})
map[string]reflectx.Func {
func wrapMakerHeadKVFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*headKVFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(*typex.X, *typex.Y) bool, a2 func(typex.X, typex.Y)) {
dfn.ProcessElement(a0, a1, a2) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 []byte, a1
func(*typex.X, *typex.Y) bool, a2 func(typex.X, typex.Y)) {
+ dfn.ProcessElement(a0, a1, a2)
+ }),
}
}
func wrapMakerPrintFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*printFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.T) (typex.T) { return dfn.ProcessElement(a0, a1) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.T) typex.T { return dfn.ProcessElement(a0, a1) }),
}
}
func wrapMakerPrintGBKFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*printGBKFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.X, a2 func(*typex.Y) bool) (typex.X) { return dfn.ProcessElement(a0, a1,
a2) }),
+ "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.X, a2 func(*typex.Y) bool) typex.X {
+ return dfn.ProcessElement(a0, a1, a2)
+ }),
}
}
func wrapMakerPrintKVFn(fn interface{}) map[string]reflectx.Func {
dfn := fn.(*printKVFn)
return map[string]reflectx.Func{
- "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.X, a2 typex.Y) (typex.X, typex.Y) { return dfn.ProcessElement(a0, a1, a2)
}),
+ "ProcessElement": reflectx.MakeFunc(func(a0 context.Context, a1
typex.X, a2 typex.Y) (typex.X, typex.Y) {
+ return dfn.ProcessElement(a0, a1, a2)
+ }),
}
}
type callerContext۰ContextTypex۰TГTypex۰T struct {
- fn func(context.Context,typex.T) (typex.T)
+ fn func(context.Context, typex.T) typex.T
}
func funcMakerContext۰ContextTypex۰TГTypex۰T(fn interface{}) reflectx.Func {
- f := fn.(func(context.Context,typex.T) (typex.T))
+ f := fn.(func(context.Context, typex.T) typex.T)
return &callerContext۰ContextTypex۰TГTypex۰T{fn: f}
}
@@ -114,16 +120,16 @@ func (c *callerContext۰ContextTypex۰TГTypex۰T) Call(args
[]interface{}) []in
return []interface{}{out0}
}
-func (c *callerContext۰ContextTypex۰TГTypex۰T) Call2x1(arg0, arg1 interface{})
(interface{}) {
+func (c *callerContext۰ContextTypex۰TГTypex۰T) Call2x1(arg0, arg1 interface{})
interface{} {
return c.fn(arg0.(context.Context), arg1.(typex.T))
}
type callerContext۰ContextTypex۰XIterTypex۰YГTypex۰X struct {
- fn func(context.Context,typex.X,func(*typex.Y) bool) (typex.X)
+ fn func(context.Context, typex.X, func(*typex.Y) bool) typex.X
}
func funcMakerContext۰ContextTypex۰XIterTypex۰YГTypex۰X(fn interface{})
reflectx.Func {
- f := fn.(func(context.Context,typex.X,func(*typex.Y) bool) (typex.X))
+ f := fn.(func(context.Context, typex.X, func(*typex.Y) bool) typex.X)
return &callerContext۰ContextTypex۰XIterTypex۰YГTypex۰X{fn: f}
}
@@ -140,16 +146,16 @@ func (c *callerContext۰ContextTypex۰XIterTypex۰YГTypex۰X)
Call(args []inter
return []interface{}{out0}
}
-func (c *callerContext۰ContextTypex۰XIterTypex۰YГTypex۰X) Call3x1(arg0, arg1,
arg2 interface{}) (interface{}) {
+func (c *callerContext۰ContextTypex۰XIterTypex۰YГTypex۰X) Call3x1(arg0, arg1,
arg2 interface{}) interface{} {
return c.fn(arg0.(context.Context), arg1.(typex.X),
arg2.(func(*typex.Y) bool))
}
type callerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y struct {
- fn func(context.Context,typex.X,typex.Y) (typex.X,typex.Y)
+ fn func(context.Context, typex.X, typex.Y) (typex.X, typex.Y)
}
func funcMakerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y(fn interface{})
reflectx.Func {
- f := fn.(func(context.Context,typex.X,typex.Y) (typex.X,typex.Y))
+ f := fn.(func(context.Context, typex.X, typex.Y) (typex.X, typex.Y))
return &callerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y{fn: f}
}
@@ -171,11 +177,11 @@ func (c
*callerContext۰ContextTypex۰XTypex۰YГTypex۰XTypex۰Y) Call3x2(arg0,
}
type callerSliceOfByteIterTypex۰TEmitTypex۰TГ struct {
- fn func([]byte,func(*typex.T) bool,func(typex.T)) ()
+ fn func([]byte, func(*typex.T) bool, func(typex.T))
}
func funcMakerSliceOfByteIterTypex۰TEmitTypex۰TГ(fn interface{}) reflectx.Func
{
- f := fn.(func([]byte,func(*typex.T) bool,func(typex.T)) ())
+ f := fn.(func([]byte, func(*typex.T) bool, func(typex.T)))
return &callerSliceOfByteIterTypex۰TEmitTypex۰TГ{fn: f}
}
@@ -192,16 +198,16 @@ func (c *callerSliceOfByteIterTypex۰TEmitTypex۰TГ)
Call(args []interface{}) [
return []interface{}{}
}
-func (c *callerSliceOfByteIterTypex۰TEmitTypex۰TГ) Call3x0(arg0, arg1, arg2
interface{}) () {
+func (c *callerSliceOfByteIterTypex۰TEmitTypex۰TГ) Call3x0(arg0, arg1, arg2
interface{}) {
c.fn(arg0.([]byte), arg1.(func(*typex.T) bool), arg2.(func(typex.T)))
}
type callerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ struct {
- fn func([]byte,func(*typex.X, *typex.Y) bool,func(typex.X, typex.Y)) ()
+ fn func([]byte, func(*typex.X, *typex.Y) bool, func(typex.X, typex.Y))
}
func funcMakerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ(fn interface{})
reflectx.Func {
- f := fn.(func([]byte,func(*typex.X, *typex.Y) bool,func(typex.X,
typex.Y)) ())
+ f := fn.(func([]byte, func(*typex.X, *typex.Y) bool, func(typex.X,
typex.Y)))
return &callerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ{fn: f}
}
@@ -218,16 +224,16 @@ func (c
*callerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ) Call(args
return []interface{}{}
}
-func (c *callerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ) Call3x0(arg0,
arg1, arg2 interface{}) () {
+func (c *callerSliceOfByteIterTypex۰XTypex۰YEmitTypex۰XTypex۰YГ) Call3x0(arg0,
arg1, arg2 interface{}) {
c.fn(arg0.([]byte), arg1.(func(*typex.X, *typex.Y) bool),
arg2.(func(typex.X, typex.Y)))
}
type callerTypex۰TГ struct {
- fn func(typex.T) ()
+ fn func(typex.T)
}
func funcMakerTypex۰TГ(fn interface{}) reflectx.Func {
- f := fn.(func(typex.T) ())
+ f := fn.(func(typex.T))
return &callerTypex۰TГ{fn: f}
}
@@ -244,17 +250,17 @@ func (c *callerTypex۰TГ) Call(args []interface{})
[]interface{} {
return []interface{}{}
}
-func (c *callerTypex۰TГ) Call1x0(arg0 interface{}) () {
+func (c *callerTypex۰TГ) Call1x0(arg0 interface{}) {
c.fn(arg0.(typex.T))
}
type emitNative struct {
- n exec.ElementProcessor
- fn interface{}
+ n exec.ElementProcessor
+ fn interface{}
- ctx context.Context
- ws []typex.Window
- et typex.EventTime
+ ctx context.Context
+ ws []typex.Window
+ et typex.EventTime
value exec.FullValue
}
@@ -289,15 +295,15 @@ func emitMakerTypex۰XTypex۰Y(n exec.ElementProcessor)
exec.ReusableEmitter {
}
func (e *emitNative) invokeTypex۰XTypex۰Y(key typex.X, val typex.Y) {
- e.value = exec.FullValue{Windows: e.ws, Timestamp: e.et, Elm: key,
Elm2: val }
+ e.value = exec.FullValue{Windows: e.ws, Timestamp: e.et, Elm: key,
Elm2: val}
if err := e.n.ProcessElement(e.ctx, &e.value); err != nil {
panic(err)
}
}
type iterNative struct {
- s exec.ReStream
- fn interface{}
+ s exec.ReStream
+ fn interface{}
// cur is the "current" stream, if any.
cur exec.Stream
@@ -379,5 +385,4 @@ func (v *iterNative) readTypex۰Y(value *typex.Y) bool {
return true
}
-
// DO NOT MODIFY: GENERATED CODE
diff --git a/sdks/python/container/piputil.go b/sdks/python/container/piputil.go
index 6f3ecf3..8157a6d 100644
--- a/sdks/python/container/piputil.go
+++ b/sdks/python/container/piputil.go
@@ -34,10 +34,10 @@ var (
)
func pipLocation() string {
- if v, ok := os.LookupEnv("pip"); ok {
- return v
- }
- return "/usr/local/bin/pip"
+ if v, ok := os.LookupEnv("pip"); ok {
+ return v
+ }
+ return "/usr/local/bin/pip"
}
// pipInstallRequirements installs the given requirement, if present.
