Move Apply<TypeName> functions to global
This commit is contained in:
parent
b82b850af0
commit
353c5154b3
|
@ -82,17 +82,17 @@ func (a Alias) collapseToURN(defaultName, defaultType string, defaultParent Reso
|
|||
func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
|
||||
var parentPrefix StringInput
|
||||
if parent != nil {
|
||||
parentPrefix = parent.ToStringOutput().ApplyString(func(p string) string {
|
||||
parentPrefix = ApplyString(parent.ToStringOutput(), func(p string) string {
|
||||
return p[0:strings.LastIndex(p, "::")] + "$"
|
||||
})
|
||||
} else {
|
||||
parentPrefix = All(stack, project).ApplyString(func(a []interface{}) string {
|
||||
parentPrefix = ApplyString(All(stack, project), func(a []interface{}) string {
|
||||
return "urn:pulumi:" + a[0].(string) + "::" + a[1].(string) + "::"
|
||||
})
|
||||
|
||||
}
|
||||
|
||||
return All(parentPrefix, t, name).ApplyURN(func(a []interface{}) URN {
|
||||
return ApplyURN(All(parentPrefix, t, name), func(a []interface{}) URN {
|
||||
return URN(a[0].(string) + a[1].(string) + "::" + a[2].(string))
|
||||
})
|
||||
}
|
||||
|
@ -103,7 +103,7 @@ func CreateURN(name, t, parent, project, stack StringInput) URNOutput {
|
|||
func inheritedChildAlias(childName, parentName, childType, project, stack string, parentURN URNOutput) URNOutput {
|
||||
aliasName := StringInput(String(childName))
|
||||
if strings.HasPrefix(childName, parentName) {
|
||||
aliasName = parentURN.ApplyString(func(urn URN) string {
|
||||
aliasName = ApplyString(parentURN, func(urn URN) string {
|
||||
parentPrefix := urn[strings.LastIndex(string(urn), "::")+2:]
|
||||
return string(parentPrefix) + childName[len(parentName):]
|
||||
})
|
||||
|
|
|
@ -23,7 +23,7 @@ func (s *StackReference) GetOutput(name StringInput) AnyOutput {
|
|||
|
||||
// GetStringOutput returns a stack output keyed by the given name as an StringOutput
|
||||
func (s *StackReference) GetStringOutput(name StringInput) StringOutput {
|
||||
return s.GetOutput(name).ApplyString(func(out interface{}) string {
|
||||
return ApplyString(s.GetOutput(name), func(out interface{}) string {
|
||||
var res string
|
||||
if out != nil {
|
||||
res = out.(string)
|
||||
|
@ -34,7 +34,7 @@ func (s *StackReference) GetStringOutput(name StringInput) StringOutput {
|
|||
|
||||
// GetIDOutput returns a stack output keyed by the given name as an IDOutput
|
||||
func (s *StackReference) GetIDOutput(name StringInput) IDOutput {
|
||||
return s.GetStringOutput(name).ApplyID(func(out string) ID {
|
||||
return ApplyID(s.GetStringOutput(name), func(out string) ID {
|
||||
return ID(out)
|
||||
})
|
||||
}
|
||||
|
|
|
@ -22,12 +22,12 @@ import (
|
|||
|
||||
{{range .Builtins}}
|
||||
// Apply{{.Name}} is like ApplyT, but returns a {{.Name}}Output.
|
||||
func (o *OutputState) Apply{{.Name}}(applier interface{}) {{.Name}}Output {
|
||||
func Apply{{.Name}}(o Output, applier interface{}) {{.Name}}Output {
|
||||
return o.ApplyT(applier).({{.Name}}Output)
|
||||
}
|
||||
|
||||
// Apply{{.Name}}WithContext is like ApplyTWithContext, but returns a {{.Name}}Output.
|
||||
func (o *OutputState) Apply{{.Name}}WithContext(ctx context.Context, applier interface{}) {{.Name}}Output {
|
||||
func Apply{{.Name}}WithContext(ctx context.Context, o Output, applier interface{}) {{.Name}}Output {
|
||||
return o.ApplyTWithContext(ctx, applier).({{.Name}}Output)
|
||||
}
|
||||
{{end}}
|
||||
|
|
|
@ -133,12 +133,12 @@ func TestOutputApply(t *testing.T) {
|
|||
|
||||
{{range .Builtins}}
|
||||
t.Run("Apply{{.Name}}", func(t *testing.T) {
|
||||
o2 := out.Apply{{.Name}}(func(v int) {{.ElementType}} { return *new({{.ElementType}}) })
|
||||
o2 := Apply{{.Name}}(out, func(v int) {{.ElementType}} { return *new({{.ElementType}}) })
|
||||
_, known, _, _, err := await(o2)
|
||||
assert.True(t, known)
|
||||
assert.NoError(t, err)
|
||||
|
||||
o2 = out.Apply{{.Name}}WithContext(context.Background(), func(_ context.Context, v int) {{.ElementType}} { return *new({{.ElementType}}) })
|
||||
o2 = Apply{{.Name}}WithContext(context.Background(), out, func(_ context.Context, v int) {{.ElementType}} { return *new({{.ElementType}}) })
|
||||
_, known, _, _, err = await(o2)
|
||||
assert.True(t, known)
|
||||
assert.NoError(t, err)
|
||||
|
|
|
@ -21,752 +21,752 @@ import (
|
|||
)
|
||||
|
||||
// ApplyArchive is like ApplyT, but returns a ArchiveOutput.
|
||||
func (o *OutputState) ApplyArchive(applier interface{}) ArchiveOutput {
|
||||
func ApplyArchive(o Output, applier interface{}) ArchiveOutput {
|
||||
return o.ApplyT(applier).(ArchiveOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveWithContext is like ApplyTWithContext, but returns a ArchiveOutput.
|
||||
func (o *OutputState) ApplyArchiveWithContext(ctx context.Context, applier interface{}) ArchiveOutput {
|
||||
func ApplyArchiveWithContext(ctx context.Context, o Output, applier interface{}) ArchiveOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArray is like ApplyT, but returns a ArchiveArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveArray(applier interface{}) ArchiveArrayOutput {
|
||||
func ApplyArchiveArray(o Output, applier interface{}) ArchiveArrayOutput {
|
||||
return o.ApplyT(applier).(ArchiveArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayOutput {
|
||||
func ApplyArchiveArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMap is like ApplyT, but returns a ArchiveMapOutput.
|
||||
func (o *OutputState) ApplyArchiveMap(applier interface{}) ArchiveMapOutput {
|
||||
func ApplyArchiveMap(o Output, applier interface{}) ArchiveMapOutput {
|
||||
return o.ApplyT(applier).(ArchiveMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMapWithContext is like ApplyTWithContext, but returns a ArchiveMapOutput.
|
||||
func (o *OutputState) ApplyArchiveMapWithContext(ctx context.Context, applier interface{}) ArchiveMapOutput {
|
||||
func ApplyArchiveMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArrayMap is like ApplyT, but returns a ArchiveArrayMapOutput.
|
||||
func (o *OutputState) ApplyArchiveArrayMap(applier interface{}) ArchiveArrayMapOutput {
|
||||
func ApplyArchiveArrayMap(o Output, applier interface{}) ArchiveArrayMapOutput {
|
||||
return o.ApplyT(applier).(ArchiveArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArrayMapWithContext is like ApplyTWithContext, but returns a ArchiveArrayMapOutput.
|
||||
func (o *OutputState) ApplyArchiveArrayMapWithContext(ctx context.Context, applier interface{}) ArchiveArrayMapOutput {
|
||||
func ApplyArchiveArrayMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMapArray is like ApplyT, but returns a ArchiveMapArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveMapArray(applier interface{}) ArchiveMapArrayOutput {
|
||||
func ApplyArchiveMapArray(o Output, applier interface{}) ArchiveMapArrayOutput {
|
||||
return o.ApplyT(applier).(ArchiveMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMapArrayWithContext is like ApplyTWithContext, but returns a ArchiveMapArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveMapArrayWithContext(ctx context.Context, applier interface{}) ArchiveMapArrayOutput {
|
||||
func ApplyArchiveMapArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMapMap is like ApplyT, but returns a ArchiveMapMapOutput.
|
||||
func (o *OutputState) ApplyArchiveMapMap(applier interface{}) ArchiveMapMapOutput {
|
||||
func ApplyArchiveMapMap(o Output, applier interface{}) ArchiveMapMapOutput {
|
||||
return o.ApplyT(applier).(ArchiveMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveMapMapWithContext is like ApplyTWithContext, but returns a ArchiveMapMapOutput.
|
||||
func (o *OutputState) ApplyArchiveMapMapWithContext(ctx context.Context, applier interface{}) ArchiveMapMapOutput {
|
||||
func ApplyArchiveMapMapWithContext(ctx context.Context, o Output, applier interface{}) ArchiveMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArrayArray is like ApplyT, but returns a ArchiveArrayArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveArrayArray(applier interface{}) ArchiveArrayArrayOutput {
|
||||
func ApplyArchiveArrayArray(o Output, applier interface{}) ArchiveArrayArrayOutput {
|
||||
return o.ApplyT(applier).(ArchiveArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a ArchiveArrayArrayOutput.
|
||||
func (o *OutputState) ApplyArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) ArchiveArrayArrayOutput {
|
||||
func ApplyArchiveArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) ArchiveArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArchiveArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAsset is like ApplyT, but returns a AssetOutput.
|
||||
func (o *OutputState) ApplyAsset(applier interface{}) AssetOutput {
|
||||
func ApplyAsset(o Output, applier interface{}) AssetOutput {
|
||||
return o.ApplyT(applier).(AssetOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetWithContext is like ApplyTWithContext, but returns a AssetOutput.
|
||||
func (o *OutputState) ApplyAssetWithContext(ctx context.Context, applier interface{}) AssetOutput {
|
||||
func ApplyAssetWithContext(ctx context.Context, o Output, applier interface{}) AssetOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArray is like ApplyT, but returns a AssetArrayOutput.
|
||||
func (o *OutputState) ApplyAssetArray(applier interface{}) AssetArrayOutput {
|
||||
func ApplyAssetArray(o Output, applier interface{}) AssetArrayOutput {
|
||||
return o.ApplyT(applier).(AssetArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArrayWithContext is like ApplyTWithContext, but returns a AssetArrayOutput.
|
||||
func (o *OutputState) ApplyAssetArrayWithContext(ctx context.Context, applier interface{}) AssetArrayOutput {
|
||||
func ApplyAssetArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMap is like ApplyT, but returns a AssetMapOutput.
|
||||
func (o *OutputState) ApplyAssetMap(applier interface{}) AssetMapOutput {
|
||||
func ApplyAssetMap(o Output, applier interface{}) AssetMapOutput {
|
||||
return o.ApplyT(applier).(AssetMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMapWithContext is like ApplyTWithContext, but returns a AssetMapOutput.
|
||||
func (o *OutputState) ApplyAssetMapWithContext(ctx context.Context, applier interface{}) AssetMapOutput {
|
||||
func ApplyAssetMapWithContext(ctx context.Context, o Output, applier interface{}) AssetMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArrayMap is like ApplyT, but returns a AssetArrayMapOutput.
|
||||
func (o *OutputState) ApplyAssetArrayMap(applier interface{}) AssetArrayMapOutput {
|
||||
func ApplyAssetArrayMap(o Output, applier interface{}) AssetArrayMapOutput {
|
||||
return o.ApplyT(applier).(AssetArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArrayMapWithContext is like ApplyTWithContext, but returns a AssetArrayMapOutput.
|
||||
func (o *OutputState) ApplyAssetArrayMapWithContext(ctx context.Context, applier interface{}) AssetArrayMapOutput {
|
||||
func ApplyAssetArrayMapWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMapArray is like ApplyT, but returns a AssetMapArrayOutput.
|
||||
func (o *OutputState) ApplyAssetMapArray(applier interface{}) AssetMapArrayOutput {
|
||||
func ApplyAssetMapArray(o Output, applier interface{}) AssetMapArrayOutput {
|
||||
return o.ApplyT(applier).(AssetMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMapArrayWithContext is like ApplyTWithContext, but returns a AssetMapArrayOutput.
|
||||
func (o *OutputState) ApplyAssetMapArrayWithContext(ctx context.Context, applier interface{}) AssetMapArrayOutput {
|
||||
func ApplyAssetMapArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMapMap is like ApplyT, but returns a AssetMapMapOutput.
|
||||
func (o *OutputState) ApplyAssetMapMap(applier interface{}) AssetMapMapOutput {
|
||||
func ApplyAssetMapMap(o Output, applier interface{}) AssetMapMapOutput {
|
||||
return o.ApplyT(applier).(AssetMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetMapMapWithContext is like ApplyTWithContext, but returns a AssetMapMapOutput.
|
||||
func (o *OutputState) ApplyAssetMapMapWithContext(ctx context.Context, applier interface{}) AssetMapMapOutput {
|
||||
func ApplyAssetMapMapWithContext(ctx context.Context, o Output, applier interface{}) AssetMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArrayArray is like ApplyT, but returns a AssetArrayArrayOutput.
|
||||
func (o *OutputState) ApplyAssetArrayArray(applier interface{}) AssetArrayArrayOutput {
|
||||
func ApplyAssetArrayArray(o Output, applier interface{}) AssetArrayArrayOutput {
|
||||
return o.ApplyT(applier).(AssetArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetArrayArrayWithContext is like ApplyTWithContext, but returns a AssetArrayArrayOutput.
|
||||
func (o *OutputState) ApplyAssetArrayArrayWithContext(ctx context.Context, applier interface{}) AssetArrayArrayOutput {
|
||||
func ApplyAssetArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchive is like ApplyT, but returns a AssetOrArchiveOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchive(applier interface{}) AssetOrArchiveOutput {
|
||||
func ApplyAssetOrArchive(o Output, applier interface{}) AssetOrArchiveOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveWithContext is like ApplyTWithContext, but returns a AssetOrArchiveOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveWithContext(ctx context.Context, applier interface{}) AssetOrArchiveOutput {
|
||||
func ApplyAssetOrArchiveWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArray is like ApplyT, but returns a AssetOrArchiveArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArray(applier interface{}) AssetOrArchiveArrayOutput {
|
||||
func ApplyAssetOrArchiveArray(o Output, applier interface{}) AssetOrArchiveArrayOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayOutput {
|
||||
func ApplyAssetOrArchiveArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMap is like ApplyT, but returns a AssetOrArchiveMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMap(applier interface{}) AssetOrArchiveMapOutput {
|
||||
func ApplyAssetOrArchiveMap(o Output, applier interface{}) AssetOrArchiveMapOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapOutput {
|
||||
func ApplyAssetOrArchiveMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArrayMap is like ApplyT, but returns a AssetOrArchiveArrayMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArrayMap(applier interface{}) AssetOrArchiveArrayMapOutput {
|
||||
func ApplyAssetOrArchiveArrayMap(o Output, applier interface{}) AssetOrArchiveArrayMapOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArrayMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayMapOutput {
|
||||
func ApplyAssetOrArchiveArrayMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMapArray is like ApplyT, but returns a AssetOrArchiveMapArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMapArray(applier interface{}) AssetOrArchiveMapArrayOutput {
|
||||
func ApplyAssetOrArchiveMapArray(o Output, applier interface{}) AssetOrArchiveMapArrayOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMapArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapArrayOutput {
|
||||
func ApplyAssetOrArchiveMapArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMapMap is like ApplyT, but returns a AssetOrArchiveMapMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMapMap(applier interface{}) AssetOrArchiveMapMapOutput {
|
||||
func ApplyAssetOrArchiveMapMap(o Output, applier interface{}) AssetOrArchiveMapMapOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveMapMapWithContext is like ApplyTWithContext, but returns a AssetOrArchiveMapMapOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveMapMapWithContext(ctx context.Context, applier interface{}) AssetOrArchiveMapMapOutput {
|
||||
func ApplyAssetOrArchiveMapMapWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArrayArray is like ApplyT, but returns a AssetOrArchiveArrayArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArrayArray(applier interface{}) AssetOrArchiveArrayArrayOutput {
|
||||
func ApplyAssetOrArchiveArrayArray(o Output, applier interface{}) AssetOrArchiveArrayArrayOutput {
|
||||
return o.ApplyT(applier).(AssetOrArchiveArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyAssetOrArchiveArrayArrayWithContext is like ApplyTWithContext, but returns a AssetOrArchiveArrayArrayOutput.
|
||||
func (o *OutputState) ApplyAssetOrArchiveArrayArrayWithContext(ctx context.Context, applier interface{}) AssetOrArchiveArrayArrayOutput {
|
||||
func ApplyAssetOrArchiveArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) AssetOrArchiveArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(AssetOrArchiveArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBool is like ApplyT, but returns a BoolOutput.
|
||||
func (o *OutputState) ApplyBool(applier interface{}) BoolOutput {
|
||||
func ApplyBool(o Output, applier interface{}) BoolOutput {
|
||||
return o.ApplyT(applier).(BoolOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolWithContext is like ApplyTWithContext, but returns a BoolOutput.
|
||||
func (o *OutputState) ApplyBoolWithContext(ctx context.Context, applier interface{}) BoolOutput {
|
||||
func ApplyBoolWithContext(ctx context.Context, o Output, applier interface{}) BoolOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolPtr is like ApplyT, but returns a BoolPtrOutput.
|
||||
func (o *OutputState) ApplyBoolPtr(applier interface{}) BoolPtrOutput {
|
||||
func ApplyBoolPtr(o Output, applier interface{}) BoolPtrOutput {
|
||||
return o.ApplyT(applier).(BoolPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolPtrWithContext is like ApplyTWithContext, but returns a BoolPtrOutput.
|
||||
func (o *OutputState) ApplyBoolPtrWithContext(ctx context.Context, applier interface{}) BoolPtrOutput {
|
||||
func ApplyBoolPtrWithContext(ctx context.Context, o Output, applier interface{}) BoolPtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArray is like ApplyT, but returns a BoolArrayOutput.
|
||||
func (o *OutputState) ApplyBoolArray(applier interface{}) BoolArrayOutput {
|
||||
func ApplyBoolArray(o Output, applier interface{}) BoolArrayOutput {
|
||||
return o.ApplyT(applier).(BoolArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArrayWithContext is like ApplyTWithContext, but returns a BoolArrayOutput.
|
||||
func (o *OutputState) ApplyBoolArrayWithContext(ctx context.Context, applier interface{}) BoolArrayOutput {
|
||||
func ApplyBoolArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMap is like ApplyT, but returns a BoolMapOutput.
|
||||
func (o *OutputState) ApplyBoolMap(applier interface{}) BoolMapOutput {
|
||||
func ApplyBoolMap(o Output, applier interface{}) BoolMapOutput {
|
||||
return o.ApplyT(applier).(BoolMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMapWithContext is like ApplyTWithContext, but returns a BoolMapOutput.
|
||||
func (o *OutputState) ApplyBoolMapWithContext(ctx context.Context, applier interface{}) BoolMapOutput {
|
||||
func ApplyBoolMapWithContext(ctx context.Context, o Output, applier interface{}) BoolMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArrayMap is like ApplyT, but returns a BoolArrayMapOutput.
|
||||
func (o *OutputState) ApplyBoolArrayMap(applier interface{}) BoolArrayMapOutput {
|
||||
func ApplyBoolArrayMap(o Output, applier interface{}) BoolArrayMapOutput {
|
||||
return o.ApplyT(applier).(BoolArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArrayMapWithContext is like ApplyTWithContext, but returns a BoolArrayMapOutput.
|
||||
func (o *OutputState) ApplyBoolArrayMapWithContext(ctx context.Context, applier interface{}) BoolArrayMapOutput {
|
||||
func ApplyBoolArrayMapWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMapArray is like ApplyT, but returns a BoolMapArrayOutput.
|
||||
func (o *OutputState) ApplyBoolMapArray(applier interface{}) BoolMapArrayOutput {
|
||||
func ApplyBoolMapArray(o Output, applier interface{}) BoolMapArrayOutput {
|
||||
return o.ApplyT(applier).(BoolMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMapArrayWithContext is like ApplyTWithContext, but returns a BoolMapArrayOutput.
|
||||
func (o *OutputState) ApplyBoolMapArrayWithContext(ctx context.Context, applier interface{}) BoolMapArrayOutput {
|
||||
func ApplyBoolMapArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMapMap is like ApplyT, but returns a BoolMapMapOutput.
|
||||
func (o *OutputState) ApplyBoolMapMap(applier interface{}) BoolMapMapOutput {
|
||||
func ApplyBoolMapMap(o Output, applier interface{}) BoolMapMapOutput {
|
||||
return o.ApplyT(applier).(BoolMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolMapMapWithContext is like ApplyTWithContext, but returns a BoolMapMapOutput.
|
||||
func (o *OutputState) ApplyBoolMapMapWithContext(ctx context.Context, applier interface{}) BoolMapMapOutput {
|
||||
func ApplyBoolMapMapWithContext(ctx context.Context, o Output, applier interface{}) BoolMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArrayArray is like ApplyT, but returns a BoolArrayArrayOutput.
|
||||
func (o *OutputState) ApplyBoolArrayArray(applier interface{}) BoolArrayArrayOutput {
|
||||
func ApplyBoolArrayArray(o Output, applier interface{}) BoolArrayArrayOutput {
|
||||
return o.ApplyT(applier).(BoolArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyBoolArrayArrayWithContext is like ApplyTWithContext, but returns a BoolArrayArrayOutput.
|
||||
func (o *OutputState) ApplyBoolArrayArrayWithContext(ctx context.Context, applier interface{}) BoolArrayArrayOutput {
|
||||
func ApplyBoolArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) BoolArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(BoolArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64 is like ApplyT, but returns a Float64Output.
|
||||
func (o *OutputState) ApplyFloat64(applier interface{}) Float64Output {
|
||||
func ApplyFloat64(o Output, applier interface{}) Float64Output {
|
||||
return o.ApplyT(applier).(Float64Output)
|
||||
}
|
||||
|
||||
// ApplyFloat64WithContext is like ApplyTWithContext, but returns a Float64Output.
|
||||
func (o *OutputState) ApplyFloat64WithContext(ctx context.Context, applier interface{}) Float64Output {
|
||||
func ApplyFloat64WithContext(ctx context.Context, o Output, applier interface{}) Float64Output {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64Output)
|
||||
}
|
||||
|
||||
// ApplyFloat64Ptr is like ApplyT, but returns a Float64PtrOutput.
|
||||
func (o *OutputState) ApplyFloat64Ptr(applier interface{}) Float64PtrOutput {
|
||||
func ApplyFloat64Ptr(o Output, applier interface{}) Float64PtrOutput {
|
||||
return o.ApplyT(applier).(Float64PtrOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64PtrWithContext is like ApplyTWithContext, but returns a Float64PtrOutput.
|
||||
func (o *OutputState) ApplyFloat64PtrWithContext(ctx context.Context, applier interface{}) Float64PtrOutput {
|
||||
func ApplyFloat64PtrWithContext(ctx context.Context, o Output, applier interface{}) Float64PtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64PtrOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64Array is like ApplyT, but returns a Float64ArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64Array(applier interface{}) Float64ArrayOutput {
|
||||
func ApplyFloat64Array(o Output, applier interface{}) Float64ArrayOutput {
|
||||
return o.ApplyT(applier).(Float64ArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64ArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64ArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayOutput {
|
||||
func ApplyFloat64ArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64ArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64Map is like ApplyT, but returns a Float64MapOutput.
|
||||
func (o *OutputState) ApplyFloat64Map(applier interface{}) Float64MapOutput {
|
||||
func ApplyFloat64Map(o Output, applier interface{}) Float64MapOutput {
|
||||
return o.ApplyT(applier).(Float64MapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64MapWithContext is like ApplyTWithContext, but returns a Float64MapOutput.
|
||||
func (o *OutputState) ApplyFloat64MapWithContext(ctx context.Context, applier interface{}) Float64MapOutput {
|
||||
func ApplyFloat64MapWithContext(ctx context.Context, o Output, applier interface{}) Float64MapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64MapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64ArrayMap is like ApplyT, but returns a Float64ArrayMapOutput.
|
||||
func (o *OutputState) ApplyFloat64ArrayMap(applier interface{}) Float64ArrayMapOutput {
|
||||
func ApplyFloat64ArrayMap(o Output, applier interface{}) Float64ArrayMapOutput {
|
||||
return o.ApplyT(applier).(Float64ArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64ArrayMapWithContext is like ApplyTWithContext, but returns a Float64ArrayMapOutput.
|
||||
func (o *OutputState) ApplyFloat64ArrayMapWithContext(ctx context.Context, applier interface{}) Float64ArrayMapOutput {
|
||||
func ApplyFloat64ArrayMapWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64ArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64MapArray is like ApplyT, but returns a Float64MapArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64MapArray(applier interface{}) Float64MapArrayOutput {
|
||||
func ApplyFloat64MapArray(o Output, applier interface{}) Float64MapArrayOutput {
|
||||
return o.ApplyT(applier).(Float64MapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64MapArrayWithContext is like ApplyTWithContext, but returns a Float64MapArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64MapArrayWithContext(ctx context.Context, applier interface{}) Float64MapArrayOutput {
|
||||
func ApplyFloat64MapArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64MapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64MapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64MapMap is like ApplyT, but returns a Float64MapMapOutput.
|
||||
func (o *OutputState) ApplyFloat64MapMap(applier interface{}) Float64MapMapOutput {
|
||||
func ApplyFloat64MapMap(o Output, applier interface{}) Float64MapMapOutput {
|
||||
return o.ApplyT(applier).(Float64MapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64MapMapWithContext is like ApplyTWithContext, but returns a Float64MapMapOutput.
|
||||
func (o *OutputState) ApplyFloat64MapMapWithContext(ctx context.Context, applier interface{}) Float64MapMapOutput {
|
||||
func ApplyFloat64MapMapWithContext(ctx context.Context, o Output, applier interface{}) Float64MapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64MapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64ArrayArray is like ApplyT, but returns a Float64ArrayArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64ArrayArray(applier interface{}) Float64ArrayArrayOutput {
|
||||
func ApplyFloat64ArrayArray(o Output, applier interface{}) Float64ArrayArrayOutput {
|
||||
return o.ApplyT(applier).(Float64ArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyFloat64ArrayArrayWithContext is like ApplyTWithContext, but returns a Float64ArrayArrayOutput.
|
||||
func (o *OutputState) ApplyFloat64ArrayArrayWithContext(ctx context.Context, applier interface{}) Float64ArrayArrayOutput {
|
||||
func ApplyFloat64ArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) Float64ArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(Float64ArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyID is like ApplyT, but returns a IDOutput.
|
||||
func (o *OutputState) ApplyID(applier interface{}) IDOutput {
|
||||
func ApplyID(o Output, applier interface{}) IDOutput {
|
||||
return o.ApplyT(applier).(IDOutput)
|
||||
}
|
||||
|
||||
// ApplyIDWithContext is like ApplyTWithContext, but returns a IDOutput.
|
||||
func (o *OutputState) ApplyIDWithContext(ctx context.Context, applier interface{}) IDOutput {
|
||||
func ApplyIDWithContext(ctx context.Context, o Output, applier interface{}) IDOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDOutput)
|
||||
}
|
||||
|
||||
// ApplyIDPtr is like ApplyT, but returns a IDPtrOutput.
|
||||
func (o *OutputState) ApplyIDPtr(applier interface{}) IDPtrOutput {
|
||||
func ApplyIDPtr(o Output, applier interface{}) IDPtrOutput {
|
||||
return o.ApplyT(applier).(IDPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyIDPtrWithContext is like ApplyTWithContext, but returns a IDPtrOutput.
|
||||
func (o *OutputState) ApplyIDPtrWithContext(ctx context.Context, applier interface{}) IDPtrOutput {
|
||||
func ApplyIDPtrWithContext(ctx context.Context, o Output, applier interface{}) IDPtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArray is like ApplyT, but returns a IDArrayOutput.
|
||||
func (o *OutputState) ApplyIDArray(applier interface{}) IDArrayOutput {
|
||||
func ApplyIDArray(o Output, applier interface{}) IDArrayOutput {
|
||||
return o.ApplyT(applier).(IDArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArrayWithContext is like ApplyTWithContext, but returns a IDArrayOutput.
|
||||
func (o *OutputState) ApplyIDArrayWithContext(ctx context.Context, applier interface{}) IDArrayOutput {
|
||||
func ApplyIDArrayWithContext(ctx context.Context, o Output, applier interface{}) IDArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMap is like ApplyT, but returns a IDMapOutput.
|
||||
func (o *OutputState) ApplyIDMap(applier interface{}) IDMapOutput {
|
||||
func ApplyIDMap(o Output, applier interface{}) IDMapOutput {
|
||||
return o.ApplyT(applier).(IDMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMapWithContext is like ApplyTWithContext, but returns a IDMapOutput.
|
||||
func (o *OutputState) ApplyIDMapWithContext(ctx context.Context, applier interface{}) IDMapOutput {
|
||||
func ApplyIDMapWithContext(ctx context.Context, o Output, applier interface{}) IDMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArrayMap is like ApplyT, but returns a IDArrayMapOutput.
|
||||
func (o *OutputState) ApplyIDArrayMap(applier interface{}) IDArrayMapOutput {
|
||||
func ApplyIDArrayMap(o Output, applier interface{}) IDArrayMapOutput {
|
||||
return o.ApplyT(applier).(IDArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArrayMapWithContext is like ApplyTWithContext, but returns a IDArrayMapOutput.
|
||||
func (o *OutputState) ApplyIDArrayMapWithContext(ctx context.Context, applier interface{}) IDArrayMapOutput {
|
||||
func ApplyIDArrayMapWithContext(ctx context.Context, o Output, applier interface{}) IDArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMapArray is like ApplyT, but returns a IDMapArrayOutput.
|
||||
func (o *OutputState) ApplyIDMapArray(applier interface{}) IDMapArrayOutput {
|
||||
func ApplyIDMapArray(o Output, applier interface{}) IDMapArrayOutput {
|
||||
return o.ApplyT(applier).(IDMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMapArrayWithContext is like ApplyTWithContext, but returns a IDMapArrayOutput.
|
||||
func (o *OutputState) ApplyIDMapArrayWithContext(ctx context.Context, applier interface{}) IDMapArrayOutput {
|
||||
func ApplyIDMapArrayWithContext(ctx context.Context, o Output, applier interface{}) IDMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMapMap is like ApplyT, but returns a IDMapMapOutput.
|
||||
func (o *OutputState) ApplyIDMapMap(applier interface{}) IDMapMapOutput {
|
||||
func ApplyIDMapMap(o Output, applier interface{}) IDMapMapOutput {
|
||||
return o.ApplyT(applier).(IDMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDMapMapWithContext is like ApplyTWithContext, but returns a IDMapMapOutput.
|
||||
func (o *OutputState) ApplyIDMapMapWithContext(ctx context.Context, applier interface{}) IDMapMapOutput {
|
||||
func ApplyIDMapMapWithContext(ctx context.Context, o Output, applier interface{}) IDMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArrayArray is like ApplyT, but returns a IDArrayArrayOutput.
|
||||
func (o *OutputState) ApplyIDArrayArray(applier interface{}) IDArrayArrayOutput {
|
||||
func ApplyIDArrayArray(o Output, applier interface{}) IDArrayArrayOutput {
|
||||
return o.ApplyT(applier).(IDArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIDArrayArrayWithContext is like ApplyTWithContext, but returns a IDArrayArrayOutput.
|
||||
func (o *OutputState) ApplyIDArrayArrayWithContext(ctx context.Context, applier interface{}) IDArrayArrayOutput {
|
||||
func ApplyIDArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) IDArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IDArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArray is like ApplyT, but returns a ArrayOutput.
|
||||
func (o *OutputState) ApplyArray(applier interface{}) ArrayOutput {
|
||||
func ApplyArray(o Output, applier interface{}) ArrayOutput {
|
||||
return o.ApplyT(applier).(ArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArrayWithContext is like ApplyTWithContext, but returns a ArrayOutput.
|
||||
func (o *OutputState) ApplyArrayWithContext(ctx context.Context, applier interface{}) ArrayOutput {
|
||||
func ApplyArrayWithContext(ctx context.Context, o Output, applier interface{}) ArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyMap is like ApplyT, but returns a MapOutput.
|
||||
func (o *OutputState) ApplyMap(applier interface{}) MapOutput {
|
||||
func ApplyMap(o Output, applier interface{}) MapOutput {
|
||||
return o.ApplyT(applier).(MapOutput)
|
||||
}
|
||||
|
||||
// ApplyMapWithContext is like ApplyTWithContext, but returns a MapOutput.
|
||||
func (o *OutputState) ApplyMapWithContext(ctx context.Context, applier interface{}) MapOutput {
|
||||
func ApplyMapWithContext(ctx context.Context, o Output, applier interface{}) MapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(MapOutput)
|
||||
}
|
||||
|
||||
// ApplyArrayMap is like ApplyT, but returns a ArrayMapOutput.
|
||||
func (o *OutputState) ApplyArrayMap(applier interface{}) ArrayMapOutput {
|
||||
func ApplyArrayMap(o Output, applier interface{}) ArrayMapOutput {
|
||||
return o.ApplyT(applier).(ArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArrayMapWithContext is like ApplyTWithContext, but returns a ArrayMapOutput.
|
||||
func (o *OutputState) ApplyArrayMapWithContext(ctx context.Context, applier interface{}) ArrayMapOutput {
|
||||
func ApplyArrayMapWithContext(ctx context.Context, o Output, applier interface{}) ArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyMapArray is like ApplyT, but returns a MapArrayOutput.
|
||||
func (o *OutputState) ApplyMapArray(applier interface{}) MapArrayOutput {
|
||||
func ApplyMapArray(o Output, applier interface{}) MapArrayOutput {
|
||||
return o.ApplyT(applier).(MapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyMapArrayWithContext is like ApplyTWithContext, but returns a MapArrayOutput.
|
||||
func (o *OutputState) ApplyMapArrayWithContext(ctx context.Context, applier interface{}) MapArrayOutput {
|
||||
func ApplyMapArrayWithContext(ctx context.Context, o Output, applier interface{}) MapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(MapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyMapMap is like ApplyT, but returns a MapMapOutput.
|
||||
func (o *OutputState) ApplyMapMap(applier interface{}) MapMapOutput {
|
||||
func ApplyMapMap(o Output, applier interface{}) MapMapOutput {
|
||||
return o.ApplyT(applier).(MapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyMapMapWithContext is like ApplyTWithContext, but returns a MapMapOutput.
|
||||
func (o *OutputState) ApplyMapMapWithContext(ctx context.Context, applier interface{}) MapMapOutput {
|
||||
func ApplyMapMapWithContext(ctx context.Context, o Output, applier interface{}) MapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(MapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyArrayArray is like ApplyT, but returns a ArrayArrayOutput.
|
||||
func (o *OutputState) ApplyArrayArray(applier interface{}) ArrayArrayOutput {
|
||||
func ApplyArrayArray(o Output, applier interface{}) ArrayArrayOutput {
|
||||
return o.ApplyT(applier).(ArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyArrayArrayWithContext is like ApplyTWithContext, but returns a ArrayArrayOutput.
|
||||
func (o *OutputState) ApplyArrayArrayWithContext(ctx context.Context, applier interface{}) ArrayArrayOutput {
|
||||
func ApplyArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) ArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(ArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyInt is like ApplyT, but returns a IntOutput.
|
||||
func (o *OutputState) ApplyInt(applier interface{}) IntOutput {
|
||||
func ApplyInt(o Output, applier interface{}) IntOutput {
|
||||
return o.ApplyT(applier).(IntOutput)
|
||||
}
|
||||
|
||||
// ApplyIntWithContext is like ApplyTWithContext, but returns a IntOutput.
|
||||
func (o *OutputState) ApplyIntWithContext(ctx context.Context, applier interface{}) IntOutput {
|
||||
func ApplyIntWithContext(ctx context.Context, o Output, applier interface{}) IntOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntOutput)
|
||||
}
|
||||
|
||||
// ApplyIntPtr is like ApplyT, but returns a IntPtrOutput.
|
||||
func (o *OutputState) ApplyIntPtr(applier interface{}) IntPtrOutput {
|
||||
func ApplyIntPtr(o Output, applier interface{}) IntPtrOutput {
|
||||
return o.ApplyT(applier).(IntPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyIntPtrWithContext is like ApplyTWithContext, but returns a IntPtrOutput.
|
||||
func (o *OutputState) ApplyIntPtrWithContext(ctx context.Context, applier interface{}) IntPtrOutput {
|
||||
func ApplyIntPtrWithContext(ctx context.Context, o Output, applier interface{}) IntPtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArray is like ApplyT, but returns a IntArrayOutput.
|
||||
func (o *OutputState) ApplyIntArray(applier interface{}) IntArrayOutput {
|
||||
func ApplyIntArray(o Output, applier interface{}) IntArrayOutput {
|
||||
return o.ApplyT(applier).(IntArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArrayWithContext is like ApplyTWithContext, but returns a IntArrayOutput.
|
||||
func (o *OutputState) ApplyIntArrayWithContext(ctx context.Context, applier interface{}) IntArrayOutput {
|
||||
func ApplyIntArrayWithContext(ctx context.Context, o Output, applier interface{}) IntArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMap is like ApplyT, but returns a IntMapOutput.
|
||||
func (o *OutputState) ApplyIntMap(applier interface{}) IntMapOutput {
|
||||
func ApplyIntMap(o Output, applier interface{}) IntMapOutput {
|
||||
return o.ApplyT(applier).(IntMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMapWithContext is like ApplyTWithContext, but returns a IntMapOutput.
|
||||
func (o *OutputState) ApplyIntMapWithContext(ctx context.Context, applier interface{}) IntMapOutput {
|
||||
func ApplyIntMapWithContext(ctx context.Context, o Output, applier interface{}) IntMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArrayMap is like ApplyT, but returns a IntArrayMapOutput.
|
||||
func (o *OutputState) ApplyIntArrayMap(applier interface{}) IntArrayMapOutput {
|
||||
func ApplyIntArrayMap(o Output, applier interface{}) IntArrayMapOutput {
|
||||
return o.ApplyT(applier).(IntArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArrayMapWithContext is like ApplyTWithContext, but returns a IntArrayMapOutput.
|
||||
func (o *OutputState) ApplyIntArrayMapWithContext(ctx context.Context, applier interface{}) IntArrayMapOutput {
|
||||
func ApplyIntArrayMapWithContext(ctx context.Context, o Output, applier interface{}) IntArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMapArray is like ApplyT, but returns a IntMapArrayOutput.
|
||||
func (o *OutputState) ApplyIntMapArray(applier interface{}) IntMapArrayOutput {
|
||||
func ApplyIntMapArray(o Output, applier interface{}) IntMapArrayOutput {
|
||||
return o.ApplyT(applier).(IntMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMapArrayWithContext is like ApplyTWithContext, but returns a IntMapArrayOutput.
|
||||
func (o *OutputState) ApplyIntMapArrayWithContext(ctx context.Context, applier interface{}) IntMapArrayOutput {
|
||||
func ApplyIntMapArrayWithContext(ctx context.Context, o Output, applier interface{}) IntMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMapMap is like ApplyT, but returns a IntMapMapOutput.
|
||||
func (o *OutputState) ApplyIntMapMap(applier interface{}) IntMapMapOutput {
|
||||
func ApplyIntMapMap(o Output, applier interface{}) IntMapMapOutput {
|
||||
return o.ApplyT(applier).(IntMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntMapMapWithContext is like ApplyTWithContext, but returns a IntMapMapOutput.
|
||||
func (o *OutputState) ApplyIntMapMapWithContext(ctx context.Context, applier interface{}) IntMapMapOutput {
|
||||
func ApplyIntMapMapWithContext(ctx context.Context, o Output, applier interface{}) IntMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArrayArray is like ApplyT, but returns a IntArrayArrayOutput.
|
||||
func (o *OutputState) ApplyIntArrayArray(applier interface{}) IntArrayArrayOutput {
|
||||
func ApplyIntArrayArray(o Output, applier interface{}) IntArrayArrayOutput {
|
||||
return o.ApplyT(applier).(IntArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyIntArrayArrayWithContext is like ApplyTWithContext, but returns a IntArrayArrayOutput.
|
||||
func (o *OutputState) ApplyIntArrayArrayWithContext(ctx context.Context, applier interface{}) IntArrayArrayOutput {
|
||||
func ApplyIntArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) IntArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(IntArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyString is like ApplyT, but returns a StringOutput.
|
||||
func (o *OutputState) ApplyString(applier interface{}) StringOutput {
|
||||
func ApplyString(o Output, applier interface{}) StringOutput {
|
||||
return o.ApplyT(applier).(StringOutput)
|
||||
}
|
||||
|
||||
// ApplyStringWithContext is like ApplyTWithContext, but returns a StringOutput.
|
||||
func (o *OutputState) ApplyStringWithContext(ctx context.Context, applier interface{}) StringOutput {
|
||||
func ApplyStringWithContext(ctx context.Context, o Output, applier interface{}) StringOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringOutput)
|
||||
}
|
||||
|
||||
// ApplyStringPtr is like ApplyT, but returns a StringPtrOutput.
|
||||
func (o *OutputState) ApplyStringPtr(applier interface{}) StringPtrOutput {
|
||||
func ApplyStringPtr(o Output, applier interface{}) StringPtrOutput {
|
||||
return o.ApplyT(applier).(StringPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyStringPtrWithContext is like ApplyTWithContext, but returns a StringPtrOutput.
|
||||
func (o *OutputState) ApplyStringPtrWithContext(ctx context.Context, applier interface{}) StringPtrOutput {
|
||||
func ApplyStringPtrWithContext(ctx context.Context, o Output, applier interface{}) StringPtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArray is like ApplyT, but returns a StringArrayOutput.
|
||||
func (o *OutputState) ApplyStringArray(applier interface{}) StringArrayOutput {
|
||||
func ApplyStringArray(o Output, applier interface{}) StringArrayOutput {
|
||||
return o.ApplyT(applier).(StringArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArrayWithContext is like ApplyTWithContext, but returns a StringArrayOutput.
|
||||
func (o *OutputState) ApplyStringArrayWithContext(ctx context.Context, applier interface{}) StringArrayOutput {
|
||||
func ApplyStringArrayWithContext(ctx context.Context, o Output, applier interface{}) StringArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMap is like ApplyT, but returns a StringMapOutput.
|
||||
func (o *OutputState) ApplyStringMap(applier interface{}) StringMapOutput {
|
||||
func ApplyStringMap(o Output, applier interface{}) StringMapOutput {
|
||||
return o.ApplyT(applier).(StringMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMapWithContext is like ApplyTWithContext, but returns a StringMapOutput.
|
||||
func (o *OutputState) ApplyStringMapWithContext(ctx context.Context, applier interface{}) StringMapOutput {
|
||||
func ApplyStringMapWithContext(ctx context.Context, o Output, applier interface{}) StringMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArrayMap is like ApplyT, but returns a StringArrayMapOutput.
|
||||
func (o *OutputState) ApplyStringArrayMap(applier interface{}) StringArrayMapOutput {
|
||||
func ApplyStringArrayMap(o Output, applier interface{}) StringArrayMapOutput {
|
||||
return o.ApplyT(applier).(StringArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArrayMapWithContext is like ApplyTWithContext, but returns a StringArrayMapOutput.
|
||||
func (o *OutputState) ApplyStringArrayMapWithContext(ctx context.Context, applier interface{}) StringArrayMapOutput {
|
||||
func ApplyStringArrayMapWithContext(ctx context.Context, o Output, applier interface{}) StringArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMapArray is like ApplyT, but returns a StringMapArrayOutput.
|
||||
func (o *OutputState) ApplyStringMapArray(applier interface{}) StringMapArrayOutput {
|
||||
func ApplyStringMapArray(o Output, applier interface{}) StringMapArrayOutput {
|
||||
return o.ApplyT(applier).(StringMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMapArrayWithContext is like ApplyTWithContext, but returns a StringMapArrayOutput.
|
||||
func (o *OutputState) ApplyStringMapArrayWithContext(ctx context.Context, applier interface{}) StringMapArrayOutput {
|
||||
func ApplyStringMapArrayWithContext(ctx context.Context, o Output, applier interface{}) StringMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMapMap is like ApplyT, but returns a StringMapMapOutput.
|
||||
func (o *OutputState) ApplyStringMapMap(applier interface{}) StringMapMapOutput {
|
||||
func ApplyStringMapMap(o Output, applier interface{}) StringMapMapOutput {
|
||||
return o.ApplyT(applier).(StringMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringMapMapWithContext is like ApplyTWithContext, but returns a StringMapMapOutput.
|
||||
func (o *OutputState) ApplyStringMapMapWithContext(ctx context.Context, applier interface{}) StringMapMapOutput {
|
||||
func ApplyStringMapMapWithContext(ctx context.Context, o Output, applier interface{}) StringMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArrayArray is like ApplyT, but returns a StringArrayArrayOutput.
|
||||
func (o *OutputState) ApplyStringArrayArray(applier interface{}) StringArrayArrayOutput {
|
||||
func ApplyStringArrayArray(o Output, applier interface{}) StringArrayArrayOutput {
|
||||
return o.ApplyT(applier).(StringArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyStringArrayArrayWithContext is like ApplyTWithContext, but returns a StringArrayArrayOutput.
|
||||
func (o *OutputState) ApplyStringArrayArrayWithContext(ctx context.Context, applier interface{}) StringArrayArrayOutput {
|
||||
func ApplyStringArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) StringArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(StringArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURN is like ApplyT, but returns a URNOutput.
|
||||
func (o *OutputState) ApplyURN(applier interface{}) URNOutput {
|
||||
func ApplyURN(o Output, applier interface{}) URNOutput {
|
||||
return o.ApplyT(applier).(URNOutput)
|
||||
}
|
||||
|
||||
// ApplyURNWithContext is like ApplyTWithContext, but returns a URNOutput.
|
||||
func (o *OutputState) ApplyURNWithContext(ctx context.Context, applier interface{}) URNOutput {
|
||||
func ApplyURNWithContext(ctx context.Context, o Output, applier interface{}) URNOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNOutput)
|
||||
}
|
||||
|
||||
// ApplyURNPtr is like ApplyT, but returns a URNPtrOutput.
|
||||
func (o *OutputState) ApplyURNPtr(applier interface{}) URNPtrOutput {
|
||||
func ApplyURNPtr(o Output, applier interface{}) URNPtrOutput {
|
||||
return o.ApplyT(applier).(URNPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyURNPtrWithContext is like ApplyTWithContext, but returns a URNPtrOutput.
|
||||
func (o *OutputState) ApplyURNPtrWithContext(ctx context.Context, applier interface{}) URNPtrOutput {
|
||||
func ApplyURNPtrWithContext(ctx context.Context, o Output, applier interface{}) URNPtrOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNPtrOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArray is like ApplyT, but returns a URNArrayOutput.
|
||||
func (o *OutputState) ApplyURNArray(applier interface{}) URNArrayOutput {
|
||||
func ApplyURNArray(o Output, applier interface{}) URNArrayOutput {
|
||||
return o.ApplyT(applier).(URNArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArrayWithContext is like ApplyTWithContext, but returns a URNArrayOutput.
|
||||
func (o *OutputState) ApplyURNArrayWithContext(ctx context.Context, applier interface{}) URNArrayOutput {
|
||||
func ApplyURNArrayWithContext(ctx context.Context, o Output, applier interface{}) URNArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMap is like ApplyT, but returns a URNMapOutput.
|
||||
func (o *OutputState) ApplyURNMap(applier interface{}) URNMapOutput {
|
||||
func ApplyURNMap(o Output, applier interface{}) URNMapOutput {
|
||||
return o.ApplyT(applier).(URNMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMapWithContext is like ApplyTWithContext, but returns a URNMapOutput.
|
||||
func (o *OutputState) ApplyURNMapWithContext(ctx context.Context, applier interface{}) URNMapOutput {
|
||||
func ApplyURNMapWithContext(ctx context.Context, o Output, applier interface{}) URNMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArrayMap is like ApplyT, but returns a URNArrayMapOutput.
|
||||
func (o *OutputState) ApplyURNArrayMap(applier interface{}) URNArrayMapOutput {
|
||||
func ApplyURNArrayMap(o Output, applier interface{}) URNArrayMapOutput {
|
||||
return o.ApplyT(applier).(URNArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArrayMapWithContext is like ApplyTWithContext, but returns a URNArrayMapOutput.
|
||||
func (o *OutputState) ApplyURNArrayMapWithContext(ctx context.Context, applier interface{}) URNArrayMapOutput {
|
||||
func ApplyURNArrayMapWithContext(ctx context.Context, o Output, applier interface{}) URNArrayMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNArrayMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMapArray is like ApplyT, but returns a URNMapArrayOutput.
|
||||
func (o *OutputState) ApplyURNMapArray(applier interface{}) URNMapArrayOutput {
|
||||
func ApplyURNMapArray(o Output, applier interface{}) URNMapArrayOutput {
|
||||
return o.ApplyT(applier).(URNMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMapArrayWithContext is like ApplyTWithContext, but returns a URNMapArrayOutput.
|
||||
func (o *OutputState) ApplyURNMapArrayWithContext(ctx context.Context, applier interface{}) URNMapArrayOutput {
|
||||
func ApplyURNMapArrayWithContext(ctx context.Context, o Output, applier interface{}) URNMapArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNMapArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMapMap is like ApplyT, but returns a URNMapMapOutput.
|
||||
func (o *OutputState) ApplyURNMapMap(applier interface{}) URNMapMapOutput {
|
||||
func ApplyURNMapMap(o Output, applier interface{}) URNMapMapOutput {
|
||||
return o.ApplyT(applier).(URNMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNMapMapWithContext is like ApplyTWithContext, but returns a URNMapMapOutput.
|
||||
func (o *OutputState) ApplyURNMapMapWithContext(ctx context.Context, applier interface{}) URNMapMapOutput {
|
||||
func ApplyURNMapMapWithContext(ctx context.Context, o Output, applier interface{}) URNMapMapOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNMapMapOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArrayArray is like ApplyT, but returns a URNArrayArrayOutput.
|
||||
func (o *OutputState) ApplyURNArrayArray(applier interface{}) URNArrayArrayOutput {
|
||||
func ApplyURNArrayArray(o Output, applier interface{}) URNArrayArrayOutput {
|
||||
return o.ApplyT(applier).(URNArrayArrayOutput)
|
||||
}
|
||||
|
||||
// ApplyURNArrayArrayWithContext is like ApplyTWithContext, but returns a URNArrayArrayOutput.
|
||||
func (o *OutputState) ApplyURNArrayArrayWithContext(ctx context.Context, applier interface{}) URNArrayArrayOutput {
|
||||
func ApplyURNArrayArrayWithContext(ctx context.Context, o Output, applier interface{}) URNArrayArrayOutput {
|
||||
return o.ApplyTWithContext(ctx, applier).(URNArrayArrayOutput)
|
||||
}
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load diff
|
@ -556,7 +556,7 @@ func TestNil(t *testing.T) {
|
|||
assert.NoError(t, err)
|
||||
assert.Equal(t, nil, v)
|
||||
|
||||
bo := ao.ApplyBool(func(x interface{}) bool {
|
||||
bo := ApplyBool(ao, func(x interface{}) bool {
|
||||
return x == nil
|
||||
})
|
||||
v, known, secret, deps, err = await(bo)
|
||||
|
|
Loading…
Reference in a new issue