vdl: remove generated targets
MultiPart: 5/5
Change-Id: Id1e624f8b982ac4bca47c0e7eeebb909f1f0a935
diff --git a/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go b/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
index 53ebf0a..3cfd1a7 100644
--- a/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
+++ b/go/src/v.io/x/sensorlog/internal/sbmodel/sbmodel.vdl.go
@@ -39,108 +39,6 @@
}) {
}
-func (m *VDeviceCfg) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.Desc == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("Desc"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Desc")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.Desc), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- var7 := (m.SgPublishSb == "")
- if var7 {
- if err := fieldsTarget1.ZeroField("SgPublishSb"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("SgPublishSb")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget6.FromString(string(m.SgPublishSb), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *VDeviceCfg) MakeVDLTarget() vdl.Target {
- return &VDeviceCfgTarget{Value: m}
-}
-
-type VDeviceCfgTarget struct {
- Value *VDeviceCfg
- descTarget vdl.StringTarget
- sgPublishSbTarget vdl.StringTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *VDeviceCfgTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*VDeviceCfg)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *VDeviceCfgTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "Desc":
- t.descTarget.Value = &t.Value.Desc
- target, err := &t.descTarget, error(nil)
- return nil, target, err
- case "SgPublishSb":
- t.sgPublishSbTarget.Value = &t.Value.SgPublishSb
- target, err := &t.sgPublishSbTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *VDeviceCfgTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *VDeviceCfgTarget) ZeroField(name string) error {
- switch name {
- case "Desc":
- t.Value.Desc = ""
- return nil
- case "SgPublishSb":
- t.Value.SgPublishSb = ""
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *VDeviceCfgTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x VDeviceCfg) VDLIsZero() bool {
return x == VDeviceCfg{}
}
@@ -238,81 +136,6 @@
}) {
}
-func (m *KDeviceCfg) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.DevId == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("DevId"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.DevId), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *KDeviceCfg) MakeVDLTarget() vdl.Target {
- return &KDeviceCfgTarget{Value: m}
-}
-
-type KDeviceCfgTarget struct {
- Value *KDeviceCfg
- devIdTarget vdl.StringTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *KDeviceCfgTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*KDeviceCfg)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *KDeviceCfgTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "DevId":
- t.devIdTarget.Value = &t.Value.DevId
- target, err := &t.devIdTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *KDeviceCfgTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *KDeviceCfgTarget) ZeroField(name string) error {
- switch name {
- case "DevId":
- t.Value.DevId = ""
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *KDeviceCfgTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x KDeviceCfg) VDLIsZero() bool {
return x == KDeviceCfg{}
}
@@ -391,147 +214,6 @@
}) {
}
-func (m *SamplerDef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.Script == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("Script"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Script")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.Script), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- var wireValue5 vdltime.Time
- if err := vdltime.TimeFromNative(&wireValue5, m.Start); err != nil {
- return err
- }
-
- var8 := (wireValue5 == vdltime.Time{})
- if var8 {
- if err := fieldsTarget1.ZeroField("Start"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget6, fieldTarget7, err := fieldsTarget1.StartField("Start")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
-
- if err := wireValue5.FillVDLTarget(fieldTarget7, tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget6, fieldTarget7); err != nil {
- return err
- }
- }
- }
- var wireValue9 vdltime.Duration
- if err := vdltime.DurationFromNative(&wireValue9, m.Interval); err != nil {
- return err
- }
-
- var12 := (wireValue9 == vdltime.Duration{})
- if var12 {
- if err := fieldsTarget1.ZeroField("Interval"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget10, fieldTarget11, err := fieldsTarget1.StartField("Interval")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
-
- if err := wireValue9.FillVDLTarget(fieldTarget11, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget10, fieldTarget11); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *SamplerDef) MakeVDLTarget() vdl.Target {
- return &SamplerDefTarget{Value: m}
-}
-
-type SamplerDefTarget struct {
- Value *SamplerDef
- scriptTarget vdl.StringTarget
- startTarget vdltime.TimeTarget
- intervalTarget vdltime.DurationTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *SamplerDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*SamplerDef)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *SamplerDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "Script":
- t.scriptTarget.Value = &t.Value.Script
- target, err := &t.scriptTarget, error(nil)
- return nil, target, err
- case "Start":
- t.startTarget.Value = &t.Value.Start
- target, err := &t.startTarget, error(nil)
- return nil, target, err
- case "Interval":
- t.intervalTarget.Value = &t.Value.Interval
- target, err := &t.intervalTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *SamplerDefTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *SamplerDefTarget) ZeroField(name string) error {
- switch name {
- case "Script":
- t.Value.Script = ""
- return nil
- case "Start":
- t.Value.Start = time.Time{}
- return nil
- case "Interval":
- t.Value.Interval = time.Duration(0)
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *SamplerDefTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x SamplerDef) VDLIsZero() bool {
if x.Script != "" {
return false
@@ -660,136 +342,6 @@
}) {
}
-func (m *VStreamDef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.Desc == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("Desc"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Desc")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.Desc), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- var7 := (m.Sampler == SamplerDef{})
- if var7 {
- if err := fieldsTarget1.ZeroField("Sampler"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("Sampler")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
-
- if err := m.Sampler.FillVDLTarget(fieldTarget6, tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
- return err
- }
- }
- }
- var10 := (m.Enabled == false)
- if var10 {
- if err := fieldsTarget1.ZeroField("Enabled"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget8, fieldTarget9, err := fieldsTarget1.StartField("Enabled")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget9.FromBool(bool(m.Enabled), tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget8, fieldTarget9); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *VStreamDef) MakeVDLTarget() vdl.Target {
- return &VStreamDefTarget{Value: m}
-}
-
-type VStreamDefTarget struct {
- Value *VStreamDef
- descTarget vdl.StringTarget
- samplerTarget SamplerDefTarget
- enabledTarget vdl.BoolTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *VStreamDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*VStreamDef)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *VStreamDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "Desc":
- t.descTarget.Value = &t.Value.Desc
- target, err := &t.descTarget, error(nil)
- return nil, target, err
- case "Sampler":
- t.samplerTarget.Value = &t.Value.Sampler
- target, err := &t.samplerTarget, error(nil)
- return nil, target, err
- case "Enabled":
- t.enabledTarget.Value = &t.Value.Enabled
- target, err := &t.enabledTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *VStreamDefTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *VStreamDefTarget) ZeroField(name string) error {
- switch name {
- case "Desc":
- t.Value.Desc = ""
- return nil
- case "Sampler":
- t.Value.Sampler = SamplerDef{}
- return nil
- case "Enabled":
- t.Value.Enabled = false
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *VStreamDefTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x VStreamDef) VDLIsZero() bool {
if x.Desc != "" {
return false
@@ -909,108 +461,6 @@
}) {
}
-func (m *KStreamDef) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.DevId == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("DevId"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.DevId), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- var7 := (m.StreamId == "")
- if var7 {
- if err := fieldsTarget1.ZeroField("StreamId"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("StreamId")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget6.FromString(string(m.StreamId), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *KStreamDef) MakeVDLTarget() vdl.Target {
- return &KStreamDefTarget{Value: m}
-}
-
-type KStreamDefTarget struct {
- Value *KStreamDef
- devIdTarget vdl.StringTarget
- streamIdTarget vdl.StringTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *KStreamDefTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*KStreamDef)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *KStreamDefTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "DevId":
- t.devIdTarget.Value = &t.Value.DevId
- target, err := &t.devIdTarget, error(nil)
- return nil, target, err
- case "StreamId":
- t.streamIdTarget.Value = &t.Value.StreamId
- target, err := &t.streamIdTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *KStreamDefTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *KStreamDefTarget) ZeroField(name string) error {
- switch name {
- case "DevId":
- t.Value.DevId = ""
- return nil
- case "StreamId":
- t.Value.StreamId = ""
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *KStreamDefTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x KStreamDef) VDLIsZero() bool {
return x == KStreamDef{}
}
@@ -1112,141 +562,6 @@
}) {
}
-func (m *KDataPoint) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- var4 := (m.DevId == "")
- if var4 {
- if err := fieldsTarget1.ZeroField("DevId"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("DevId")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.DevId), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- }
- }
- var7 := (m.StreamId == "")
- if var7 {
- if err := fieldsTarget1.ZeroField("StreamId"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget5, fieldTarget6, err := fieldsTarget1.StartField("StreamId")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
- if err := fieldTarget6.FromString(string(m.StreamId), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget5, fieldTarget6); err != nil {
- return err
- }
- }
- }
- var wireValue8 vdltime.Time
- if err := vdltime.TimeFromNative(&wireValue8, m.Timestamp); err != nil {
- return err
- }
-
- var11 := (wireValue8 == vdltime.Time{})
- if var11 {
- if err := fieldsTarget1.ZeroField("Timestamp"); err != nil && err != vdl.ErrFieldNoExist {
- return err
- }
- } else {
- keyTarget9, fieldTarget10, err := fieldsTarget1.StartField("Timestamp")
- if err != vdl.ErrFieldNoExist {
- if err != nil {
- return err
- }
-
- if err := wireValue8.FillVDLTarget(fieldTarget10, tt.NonOptional().Field(2).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget9, fieldTarget10); err != nil {
- return err
- }
- }
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
- return nil
-}
-
-func (m *KDataPoint) MakeVDLTarget() vdl.Target {
- return &KDataPointTarget{Value: m}
-}
-
-type KDataPointTarget struct {
- Value *KDataPoint
- devIdTarget vdl.StringTarget
- streamIdTarget vdl.StringTarget
- timestampTarget vdltime.TimeTarget
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *KDataPointTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
-
- if ttWant := vdl.TypeOf((*KDataPoint)(nil)).Elem(); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
- return t, nil
-}
-func (t *KDataPointTarget) StartField(name string) (key, field vdl.Target, _ error) {
- switch name {
- case "DevId":
- t.devIdTarget.Value = &t.Value.DevId
- target, err := &t.devIdTarget, error(nil)
- return nil, target, err
- case "StreamId":
- t.streamIdTarget.Value = &t.Value.StreamId
- target, err := &t.streamIdTarget, error(nil)
- return nil, target, err
- case "Timestamp":
- t.timestampTarget.Value = &t.Value.Timestamp
- target, err := &t.timestampTarget, error(nil)
- return nil, target, err
- default:
- return nil, nil, vdl.ErrFieldNoExist
- }
-}
-func (t *KDataPointTarget) FinishField(_, _ vdl.Target) error {
- return nil
-}
-func (t *KDataPointTarget) ZeroField(name string) error {
- switch name {
- case "DevId":
- t.Value.DevId = ""
- return nil
- case "StreamId":
- t.Value.StreamId = ""
- return nil
- case "Timestamp":
- t.Value.Timestamp = time.Time{}
- return nil
- default:
- return vdl.ErrFieldNoExist
- }
-}
-func (t *KDataPointTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
func (x KDataPoint) VDLIsZero() bool {
if x.DevId != "" {
return false
@@ -1375,7 +690,6 @@
Name() string
// __VDLReflect describes the VDataPoint union type.
__VDLReflect(__VDataPointReflect)
- FillVDLTarget(vdl.Target, *vdl.Type) error
VDLIsZero() bool
VDLWrite(vdl.Encoder) error
}
@@ -1385,10 +699,9 @@
VDataPointError struct{ Value string }
// __VDataPointReflect describes the VDataPoint union type.
__VDataPointReflect struct {
- Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.VDataPoint"`
- Type VDataPoint
- UnionTargetFactory vDataPointTargetFactory
- Union struct {
+ Name string `vdl:"v.io/x/sensorlog/internal/sbmodel.VDataPoint"`
+ Type VDataPoint
+ Union struct {
Value VDataPointValue
Error VDataPointError
}
@@ -1400,114 +713,11 @@
func (x VDataPointValue) Name() string { return "Value" }
func (x VDataPointValue) __VDLReflect(__VDataPointReflect) {}
-func (m VDataPointValue) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Value")
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromFloat(float64(m.Value), tt.NonOptional().Field(0).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
-
- return nil
-}
-
-func (m VDataPointValue) MakeVDLTarget() vdl.Target {
- return nil
-}
-
func (x VDataPointError) Index() int { return 1 }
func (x VDataPointError) Interface() interface{} { return x.Value }
func (x VDataPointError) Name() string { return "Error" }
func (x VDataPointError) __VDLReflect(__VDataPointReflect) {}
-func (m VDataPointError) FillVDLTarget(t vdl.Target, tt *vdl.Type) error {
- fieldsTarget1, err := t.StartFields(tt)
- if err != nil {
- return err
- }
- keyTarget2, fieldTarget3, err := fieldsTarget1.StartField("Error")
- if err != nil {
- return err
- }
- if err := fieldTarget3.FromString(string(m.Value), tt.NonOptional().Field(1).Type); err != nil {
- return err
- }
- if err := fieldsTarget1.FinishField(keyTarget2, fieldTarget3); err != nil {
- return err
- }
- if err := t.FinishFields(fieldsTarget1); err != nil {
- return err
- }
-
- return nil
-}
-
-func (m VDataPointError) MakeVDLTarget() vdl.Target {
- return nil
-}
-
-type VDataPointTarget struct {
- Value *VDataPoint
- fieldName string
-
- vdl.TargetBase
- vdl.FieldsTargetBase
-}
-
-func (t *VDataPointTarget) StartFields(tt *vdl.Type) (vdl.FieldsTarget, error) {
- if ttWant := vdl.TypeOf((*VDataPoint)(nil)); !vdl.Compatible(tt, ttWant) {
- return nil, fmt.Errorf("type %v incompatible with %v", tt, ttWant)
- }
-
- return t, nil
-}
-func (t *VDataPointTarget) StartField(name string) (key, field vdl.Target, _ error) {
- t.fieldName = name
- switch name {
- case "Value":
- val := float64(0)
- return nil, &vdl.Float64Target{Value: &val}, nil
- case "Error":
- val := ""
- return nil, &vdl.StringTarget{Value: &val}, nil
- default:
- return nil, nil, fmt.Errorf("field %s not in union v.io/x/sensorlog/internal/sbmodel.VDataPoint", name)
- }
-}
-func (t *VDataPointTarget) FinishField(_, fieldTarget vdl.Target) error {
- switch t.fieldName {
- case "Value":
- *t.Value = VDataPointValue{*(fieldTarget.(*vdl.Float64Target)).Value}
- case "Error":
- *t.Value = VDataPointError{*(fieldTarget.(*vdl.StringTarget)).Value}
- }
- return nil
-}
-func (t *VDataPointTarget) FinishFields(_ vdl.FieldsTarget) error {
-
- return nil
-}
-
-type vDataPointTargetFactory struct{}
-
-func (t vDataPointTargetFactory) VDLMakeUnionTarget(union interface{}) (vdl.Target, error) {
- if typedUnion, ok := union.(*VDataPoint); ok {
- return &VDataPointTarget{Value: typedUnion}, nil
- }
- return nil, fmt.Errorf("got %T, want *VDataPoint", union)
-}
-
func (x VDataPointValue) VDLIsZero() bool {
return x.Value == 0
}
